feat: boostrap hicn 22.02

The current patch provides several new features, improvements,
bug fixes and also complete rewrite of entire components.

- lib
The hicn packet parser has been improved with a new packet
format fully based on UDP. The TCP header is still temporarily
supported but the UDP header will replace completely the new hicn
packet format. Improvements have been made to make sure every
packet parsing operation is made via this library. The current
new header can be used as header between the payload and the
UDP header or as trailer in the UDP surplus area to be tested
when UDP options will start to be used.

- hicn-light
The portable packet forwarder has been completely rewritten from
scratch with the twofold objective to improve performance and
code size but  also to drop dependencies such as libparc which is
now removed by the current implementation.

- hicn control
the control library is the agent that is used to program the
packet forwarders via their binary API. This component has
benefited from significant improvements in terms of interaction
model which is now event driven and more robust to failures.

- VPP plugin has been updated to support VPP 22.02

- transport
Major improvement have been made to the RTC protocol, to the
support of IO modules and to the security sub system. Signed
manifests are the default data authenticity and integrity framework.
Confidentiality can be enabled by sharing the encryption key to the
prod/cons layer. The library has been tested with group key based
applications such as broadcast/multicast and real-time on-line
meetings with trusted server keys or MLS.

- testing
Unit testing has been introduced using GoogleTest. One third of
the code base is covered by unit testing with priority on
critical features. Functional testing has also been introduce
using Docker, linux bridging and Robot Framework to define
test with Less Code techniques to facilitate the extension
of the coverage.

Co-authored-by: Mauro Sardara <msardara@cisco.com>
Co-authored-by: Jordan Augé <jordan.auge+fdio@cisco.com>
Co-authored-by: Michele Papalini <micpapal@cisco.com>
Co-authored-by: Angelo Mantellini <manangel@cisco.com>
Co-authored-by: Jacques Samain <jsamain@cisco.com>
Co-authored-by: Olivier Roques <oroques+fdio@cisco.com>
Co-authored-by: Enrico Loparco <eloparco@cisco.com>
Co-authored-by: Giulio Grassi <gigrassi@cisco.com>

Change-Id: I75d0ef70f86d921e3ef503c99271216ff583c215
Signed-off-by: Luca Muscariello <muscariello@ieee.org>
Signed-off-by: Mauro Sardara <msardara@cisco.com>

1096 files changed, 68012 insertions, 64497 deletions

diff --git a/.cz.toml b/.cz.toml
new file mode 100644
index 000000000..2cbf9452e
--- /dev/null
+++ b/.cz.toml
@@ -0,0 +1,5 @@
+[tool]
+[tool.commitizen]
+name = "cz_conventional_commits"
+version = "3.9.1"
+tag_format = "v$version"
diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 000000000..486e001fb
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,12 @@
+**/report.xml
+**/build*
+**/.devcontainer
+**/.vscode
+**/docker/Dockerfile
+**/docker/Dockerfile.clang
+ci/Dockerfile*
+#**/deb
+**/*.tar
+**/.gitignore
+**/info.txt
+./install*
diff --git a/.gitignore b/.gitignore
index 52ecb4eba..685e356c6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,18 @@
 build*
 .ccls-cache/
 compile_commands.json
+sonar*
+.scannerwork*
+deb
+info.txt
+.vscode
+.DS_Store
+
+# Local install
+install*
+
+# Robot
+tests/**/*.xml
+tests/**/*.html
+tests/**/*.log
+*.tar
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 000000000..55a6478e7
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "cmake"]
+	path = cmake
+	url = https://github.com/icn-team/cmake-modules.git
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 000000000..af94bbc3d
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,7 @@
+repos:
+- hooks:
+  - id: commitizen
+    stages:
+    - commit-msg
+  repo: https://github.com/commitizen-tools/commitizen
+  rev: v2.19.0
diff --git a/AUTHORS b/AUTHORS
index 8f67db1f5..535ea8297 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -1,8 +1,10 @@
 Jordan Augé <jordan.auge@cisco.com>
 Giovanna Carofiglio <gcarofig@cisco.com>
 Alberto Compagno <acompagn@cisco.com>
+Enrico Loparco <eloparco@cisco.com>
 Angelo Mantellini <manangel@cisco.com>
 Luca Muscariello <lumuscar@cisco.com>
 Michele Papalini <mpapal@cisco.com>
+Olivier Roques <oroques@cisco.com>
 Jacques Samain <jsamain@cisco.com>
 Mauro Sardara <msardara@cisco.com>
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8ad59c81d..1ba276c41 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,15 +11,55 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
-
+##############################################################
+# Project and cmake version
+##############################################################
+cmake_minimum_required(VERSION 3.11 FATAL_ERROR)
 project(hicn-fdio)
 
+##############################################################
+# Fetch submodules if needed
+##############################################################
+find_package(Git QUIET)
+if(GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
+  # Update submodules as needed
+  option(GIT_SUBMODULE "Check submodules during build" ON)
+  if(GIT_SUBMODULE)
+    message(STATUS "Submodule update")
+    execute_process(
+      COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      RESULT_VARIABLE GIT_SUBMOD_RESULT
+    )
+
+    if(NOT GIT_SUBMOD_RESULT EQUAL "0")
+      message(FATAL_ERROR "git submodule update --init --recursive failed with ${GIT_SUBMOD_RESULT}, please checkout submodules")
+    endif()
+  endif()
+endif()
+
+if(NOT EXISTS "${PROJECT_SOURCE_DIR}/cmake/Modules")
+    message(
+      FATAL_ERROR
+      "The submodules were not downloaded! GIT_SUBMODULE was turned off or failed. Please update submodules and try again."
+    )
+endif()
+
+##############################################################
+# CMake Modules
+##############################################################
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules")
+if(EXISTS "${PROJECT_SOURCE_DIR}/internal/cmake/Modules")
+  set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/internal/cmake/Modules")
+  set(INTERNAL_ENVIRONMENT True)
+endif()
+include("${CMAKE_CURRENT_SOURCE_DIR}/versions.cmake")
 
-set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+include(CommonSetup)
 
-## Enabled components
+##############################################################
+# Enabled components
+##############################################################
 option(BUILD_LIBHICN "Build the hicn core library" ON)
 option(BUILD_HICNLIGHT "Build the hicn light forwarder" ON)
 option(BUILD_LIBTRANSPORT "Build the hicn transport library" ON)
@@ -38,6 +78,10 @@ option(BUILD_TELEMETRY "Build telemetry projects" OFF)
 option(BUILD_TESTS "Build unit tests" OFF)
 option(DISABLE_EXECUTABLES "Disable executables" OFF)
 
+
+##############################################################
+# Basic sanity checks
+##############################################################
 if (BUILD_APPS AND NOT BUILD_LIBTRANSPORT)
   message(STATUS "Libhicntransport required. Enabled by default.")
   set (BUILD_LIBTRANSPORT ON)
@@ -61,9 +105,9 @@ endif()
 
 list(APPEND dir_options
   BUILD_LIBHICN
-  BUILD_HICNLIGHT
   BUILD_HICNPLUGIN
   BUILD_CTRL
+  BUILD_HICNLIGHT
   BUILD_LIBTRANSPORT
   BUILD_APPS
   BUILD_SYSREPOPLUGIN
@@ -81,7 +125,10 @@ set(BUILD_SYSREPOPLUGIN_DIR ctrl/sysrepo-plugins)
 set(BUILD_EXTRAS_DIR extras/)
 set(BUILD_TELEMETRY_DIR telemetry)
 
-## Add enabled components
+
+##############################################################
+# Add enabled components to the build
+##############################################################
 foreach (opt ${dir_options})
   if (${opt})
     list(APPEND subdirs
@@ -90,7 +137,10 @@ foreach (opt ${dir_options})
   endif()
 endforeach()
 
-# Add unit tests
+
+##############################################################
+# Build gtest if tests are enabled
+##############################################################
 if (BUILD_TESTS)
   message(STATUS "Tests enabled.")
   include (GTestImport)
@@ -105,10 +155,10 @@ endif()
 message(STATUS "Building the following subprojects: ${subdirs}")
 
 foreach(dir ${subdirs})
+  pr_title("Subproject" "${dir}")
   add_subdirectory(${dir})
 endforeach()
 
 add_subdirectory(docs/doxygen)
 
-include(Packager)
-make_packages()
\ No newline at end of file
+make_packages()
diff --git a/Dockerfile.dev b/Dockerfile.dev
new file mode 100644
index 000000000..bcd75746f
--- /dev/null
+++ b/Dockerfile.dev
@@ -0,0 +1,53 @@
+FROM ubuntu:focal
+
+WORKDIR /hicn-build
+
+RUN apt-get update
+
+# Do not prompt
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Prevent vpp to set sysctl
+ENV VPP_INSTALL_SKIP_SYSCTL=1
+
+# Add packagecloud repo
+RUN apt-get install -y git curl
+
+# Get versions from versions.cmake
+ARG VERSIONS_PATH=/tmp/versions.cmake
+COPY versions.cmake ${VERSIONS_PATH}
+
+RUN export VPP_VERSION=$(cat ${VERSIONS_PATH} | grep VPP_DEFAULT_VERSION | cut -d ' ' -f 2 | tr -d '"' | grep -Po '\d\d.\d\d') && echo ${VPP_VERSION}
+
+# Install devel packages
+RUN apt update
+SHELL ["/bin/bash", "-c"]
+RUN export VPP_VERSION=$(cat ${VERSIONS_PATH} | grep VPP_DEFAULT_VERSION | cut -d ' ' -f 2 | tr -d '"' | grep -Po '\d\d.\d\d') && \
+  curl -s https://packagecloud.io/install/repositories/fdio/${VPP_VERSION//./}/script.deb.sh  | bash && \
+  apt-get install -y                          \
+  cmake                                       \
+  ninja-build                                 \
+  unzip                                       \
+  libconfig-dev                               \
+  python3-ply                                 \
+  libconfig++-dev                             \
+  build-essential                             \
+  vpp-dev                                     \
+  libvppinfra-dev                             \
+  vpp-plugin-core                             \
+  vpp                                         \
+  libvppinfra                                 \
+  libevent-dev                                \
+  libssl-dev                                  \
+  make                                        \
+  sudo                                        \
+  libcurl4-openssl-dev                        \
+  iproute2                                    \
+  iperf3                                      \
+  iputils-ping                                \
+  tcpdump                                     \
+  gdb                                         \
+  libasio-dev --no-install-recommends
+
+# Switch back to dialog for any ad-hoc use of apt-get
+ENV DEBIAN_FRONTEND=
diff --git a/Makefile b/Makefile
new file mode 100644
index 000000000..3d74f9b72
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,240 @@
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+export WS_ROOT=$(CURDIR)
+SHELL := /bin/bash
+FUNCTIONAL := tests/run-functional.sh
+MKDIR := mkdir -p
+RM := rm
+VERSIONFILE := $(CURDIR)/versions.cmake
+
+# Docker stuff
+DOCKER := docker
+DEV_IMAGE := hicn-dev-img
+DOCKERFILE := Dockerfile.dev
+DEV_CONTAINER := hicn-dev
+
+#
+# OS Detection
+#
+ifeq ($(shell uname),Darwin)
+OS_ID = macos
+OPENSSL_ROOT=/usr/local/opt/openssl@1.1
+else
+OS_ID         = $(shell grep '^ID=' /etc/os-release | cut -f2- -d= | sed -e 's/\"//g')
+OS_VERSION_ID = $(shell grep '^VERSION_ID=' /etc/os-release | cut -f2- -d= | sed -e 's/\"//g')
+endif
+
+ifeq ($(shell uname),Darwin)
+BUILD_HICNPLUGIN := OFF
+PUNTING := OFF
+else
+BUILD_HICNPLUGIN := ON
+PUNTING := ON
+endif
+
+DEB_DEPENDS  = cmake ninja-build unzip python3-ply libasio-dev
+DEB_DEPENDS += libconfig-dev libconfig++-dev libevent-dev
+DEB_DEPENDS += build-essential vpp-dev libvppinfra-dev
+DEB_DEPENDS += vpp-plugin-core libcurl4-openssl-dev
+DEB_DEPENDS += doxygen
+
+MACOS_DEPENDS = asio libconfig ninja
+
+.PHONY = help
+help:
+	@echo "Targets"
+	@echo " dep                 - install software dependencies"
+	@echo " build               - build debug binaries. Optional argument: INSTALL_DIR"
+	@echo " build-release       - build release binaries"
+	@echo " build-coverage      - build with coverage metainformation"
+	@echo " wipe                - wipe debug binaries"
+	@echo " wipe-release        - wipe release binaries"
+	@echo " docs                - build documentation"
+	@echo ""
+	@echo "Make Arguments:"
+	@echo " INSTALL_PREFIX=<path>   	- Install software at specified location."
+	@echo " BUILD_PATH=<path>   		- Path of build folder."
+	@echo " VPP_HOME=<path>         	- Path of VPP"
+	@echo " OPENSSL_ROOT=<path>         	- Path of Openssl installation"
+	@echo " ENABLE_RELY=<ON/OFF>         	- Enable/disable rely compilation"
+	@echo " SONAR_BUILD_WRAPPER=<path>"	- Path of sonarqube build wrapper
+	@echo " SONAR_OUT_DIR=<path>"		- Path of directory of sonarqube report
+	@echo "Current Arguments:"
+	@echo " INSTALL_PREFIX=$(INSTALL_PREFIX)"
+	@echo " VPP_HOME=$(VPP_HOME)"
+	@echo " OPENSSL_ROOT=$(OPENSSL_ROOT)"
+	@echo " ENABLE_RELY=$(ENABLE_RELY)"
+	@echo " SONAR_BUILD_WRAPPER=$(SONAR_BUILD_WRAPPER)"
+	@echo " SONAR_OUT_DIR=$(SONAR_OUT_DIR)"
+
+.PHONY = vpp-dep
+vpp-dep:
+	VERSION_PATH=$(VERSIONFILE) sudo -E $(SHELL) scripts/install-vpp.sh
+
+.PHONY = dep
+dep: vpp-dep
+ifeq ($(shell uname),Darwin)
+	brew install $(MACOS_DEPENDS)
+else ifeq ($(filter ubuntu debian,$(OS_ID)),$(OS_ID))
+	@sudo -E apt-get update
+	@sudo -E apt-get $(APT_ARGS) -y install $(DEB_DEPENDS) --no-install-recommends
+else
+	@echo "Operating system not supported (yet)"
+endif
+
+.PHONY = deps
+deps: dep
+
+define build_folder
+	$(eval LOWER_BUILDTYPE=$(shell echo $(2) | tr A-Z a-z))
+	$(eval BUILD_FOLDER=$(or $(BUILD_PATH), build-$(LOWER_BUILDTYPE)-$(OS_ID)))
+	$(1) := $$(BUILD_FOLDER)
+endef
+
+define configure
+	$(eval $(call build_folder,BUILD_FOLDER,$(1)))
+	$(eval PREFIX=$(or $(INSTALL_PREFIX), $(WS_ROOT)/install-$(LOWER_BUILDTYPE)))
+	$(eval COVERAGE=$(or $(COVERAGE), OFF))
+	$(eval VPP_HOME=$(or $(VPP_HOME), /usr))
+	$(eval ENABLE_RELY=$(or $(ENABLE_RELY), OFF))
+	$(MKDIR) $(BUILD_FOLDER)
+	cmake \
+		-B $(BUILD_FOLDER) \
+		-S $(WS_ROOT) \
+		-G Ninja \
+		-DCMAKE_INSTALL_PREFIX=$(PREFIX) \
+		-DCMAKE_BUILD_TYPE=$(1) \
+		-DBUILD_HICNLIGHT=ON \
+		-DBUILD_APPS=ON \
+		-DBUILD_SYSREPOPLUGIN=OFF \
+		-DBUILD_EXTRAS=OFF \
+		-DBUILD_TELEMETRY=OFF \
+		-DBUILD_CTRL=ON \
+		-DBUILD_HICNPLUGIN=$(BUILD_HICNPLUGIN) \
+		-DVPP_HOME=$(VPP_HOME) \
+		-DCOVERAGE=$(COVERAGE) \
+		-DENABLE_RELY=$(ENABLE_RELY) \
+		-DOPENSSL_ROOT_DIR=$(OPENSSL_ROOT) \
+		-DBUILD_TESTS=ON
+endef
+
+define build
+	$(eval $(call build_folder,BUILD_FOLDER,$(1)))
+	cmake --build $(BUILD_FOLDER) -- -j 4 install
+endef
+
+define build_coverage
+	$(eval $(call build_folder,BUILD_FOLDER,$(1)))
+	$(eval SONAR_OUT_DIR=$(or $(SONAR_OUT_DIR), $(WS_ROOT)/sonarqube-output))
+	$(SONAR_BUILD_WRAPPER) --out-dir $(SONAR_OUT_DIR) cmake --build $(BUILD_FOLDER) -- install
+endef
+
+define package
+	$(eval $(call build_folder,BUILD_FOLDER,$(1)))
+	cmake --build $(BUILD_FOLDER) -- package
+endef
+
+.PHONY: configure-debug
+configure-debug:
+	$(call configure,Debug,)
+
+.PHONY: configure-release
+configure-release:
+	$(call configure,Release,)
+
+.PHONY = build
+build: configure-debug
+	$(call build,Debug,)
+
+.PHONY = build-coverage
+build-coverage:
+ifndef SONAR_BUILD_WRAPPER
+	$(error SONAR_BUILD_WRAPPER is not set)
+endif
+	$(eval COVERAGE := ON)
+	$(call configure,Debug,)
+	$(call build_coverage,Debug,)
+
+.PHONY = build-release
+build-release: configure-release
+	$(call build,Release,)
+
+.PHONY = package
+package: build
+	$(call package,Debug,)
+
+.PHONY = package-release
+package-release: build-release
+	$(call package,Release,)
+
+define wipe
+	$(eval LOWER_BUILDTYPE=$(shell echo $(1) | tr A-Z a-z))
+	$(RM) -rf build-$(LOWER_BUILDTYPE)-$(OS_ID)
+	$(RM) -rf install-$(LOWER_BUILDTYPE)
+endef
+
+.PHONY = wipe
+wipe:
+	$(call wipe,Debug,)
+
+.PHONY = wipe-release
+wipe-release:
+	$(call wipe,Release,)
+
+define test
+	$(eval $(call build_folder,BUILD_FOLDER,$(1)))
+	cmake --build $(BUILD_FOLDER) -- test
+endef
+
+.PHONY = test-debug
+test-debug: build
+	$(call test, Debug,)
+
+.PHONY = test
+test: build-release
+	$(call test, Release,)
+
+.PHONY = functional
+functional:
+	$(SHELL) $(FUNCTIONAL)
+
+define documentation
+	python3 -m pip install --user virtualenv
+	python3 -m virtualenv env
+	(source $(WS_ROOT)/env/bin/activate; \
+	pip install -r $(WS_ROOT)/docs/etc/requirements.txt; \
+	cd docs; \
+	make html )
+endef
+
+.PHONY = doc
+doc:
+	$(call documentation,)
+
+
+.PHONY = docker
+docker:
+	$(DOCKER) build -t $(DEV_IMAGE) -f $(DOCKERFILE) ${PWD}
+ifeq ($(strip $(shell $(DOCKER) ps -q -f name=$(DEV_CONTAINER))),)
+ifneq ($(shell $(DOCKER) ps -aq -f status=exited -f name=$(DEV_CONTAINER)),)
+	docker rm $(DEV_CONTAINER)
+endif
+	$(DOCKER) run -dv ${PWD}:/workspace -w /workspace --name $(DEV_CONTAINER) --entrypoint=tail $(DEV_IMAGE) -f /dev/null
+endif
+	$(DOCKER) exec -it $(DEV_CONTAINER) bash
+
+.PHONY = wipe-docker
+wipe-docker:
+	$(DOCKER) rm --force $(DEV_CONTAINER)
\ No newline at end of file
diff --git a/README.md b/README.md
index 4ddd78fcf..98f57d61c 100644
--- a/README.md
+++ b/README.md
@@ -2,10 +2,13 @@
 
 ## Introduction
 
-hicn is an open source implementation of Cisco's hICN. It includes a network stack, that implements
-ICN forwarding path in IPv6, and a transport stack that implements two main transport protocols and
-a socket API. The transport protocols provide one reliable transport service implementation and a
-real-time transport service for audio/video media.
+This is an open source implementation of Cisco's hICN. It includes a network
+stack, that implements ICN forwarding path in IPv6, and a transport stack that
+implements reliable and unrelieable transport with congestion control and loss
+management by ARQ or FEC. It supports applications such as reliable multicast
+for ABR video, real-time video conferencing and on-line multiplayer games.
+The client stack has been tested on iOS and Android over Wi-Fi, LTE and Ethernet
+including multi-homing use cases.
 
 ## Directory layout
 
@@ -15,29 +18,27 @@ real-time transport service for audio/video media.
 | hicn-plugin    | VPP plugin                                                |
 | hicn-light     | Lightweight packet forwarder                              |
 | libtransport   | Support library with transport layer and API              |
-| utils          | Tools for testing                                         |
-| apps           | Application examples using hicn stack                     |
+| apps           | Application examples using hicn stack and tools           |
 | ctrl           | Tools and libraries for network configuration and control |
 
-hicn plugin is a VPP plugin that implement hicn packet processing as specified in
-https://datatracker.ietf.org/doc/draft-muscariello-intarea-hicn/. The transport library is used to
-implement the hicn host stack and makes use of libmemif as high performance connector between
-transport and the network stack. The transport library makes use of VPP binary API to configure the
-local namespace (local face management).
+hicn plugin is a VPP plugin that implement hicn packet processing as specified
+in https://datatracker.ietf.org/doc/draft-muscariello-intarea-hicn/. The
+transport library is used to implement the hicn host stack and makes use of
+libmemif as high performance connector between transport and the network stack.
+The transport library makes use of VPP binary API to configure the local
+namespace (local face management).
 
 ## Supported platforms
 
-- Ubuntu 16.04 LTS (amd64)
-- Ubuntu 18.04 LTS (amd64, arm64)
-- CentOS 7 (x86_64)
-- Android 10
-- iOS 13
-- macOS 10.15
-- Windows 10
+- Ubuntu 20.04 LTS (amd64, arm64)
+- Android 10+
+- iOS 13+
+- macOS 10.15+
+- Windows 10+
 
 ## Binaries
 
-### Ubuntu 16/18 (amd64) and CentOS 7 (x86_64)
+### Ubuntu (amd64, arm64)
 
 <https://packagecloud.io/fdio/release>
 
@@ -45,17 +46,12 @@ local namespace (local face management).
 
 <https://hub.docker.com/u/icnteam>
 
-### Vagrant
-
-<https://app.vagrantup.com/icnteam/>
-
 ### Release note
 
-The current master branch provides the latest release which is compatible with the latest VPP stable.
-No other VPP releases are supported nor maintained. At every new VPP release distribution hicn
-master branch is updated to work with the latest stable release. All previous stable releases
-are discontinued and not maintained. The user who is interested in a specific release can always
-checkout the right code tree by searching the latest commit under a given git tag carrying the
-release version.
-
-
+The current master branch provides the latest release which is compatible with
+the latest VPP stable. No other VPP releases are supported nor maintained. At
+every new VPP release distribution hicn master branch is updated to work with
+the latest stable release. All previous stable releases are discontinued and not
+maintained. The user who is interested in a specific release can always checkout
+the right code tree by searching the latest commit under a given git tag
+carrying the release version.
diff --git a/apps/.clang-format b/apps/.clang-format
index cd21e2017..adc73c6fd 100644
--- a/apps/.clang-format
+++ b/apps/.clang-format
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2021 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/apps/CMakeLists.txt b/apps/CMakeLists.txt
index df1b9fc7c..b06d7bcb4 100644
--- a/apps/CMakeLists.txt
+++ b/apps/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,37 +11,68 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+##############################################################
+# Project and cmake version
+##############################################################
 cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
-set(CMAKE_CXX_STANDARD 14)
-
 project(apps)
 
+
+##############################################################
+# C Standard
+##############################################################
+set(CMAKE_CXX_STANDARD 17)
+
+
+##############################################################
+# Cmake modules
+##############################################################
+include("${CMAKE_CURRENT_SOURCE_DIR}/../versions.cmake")
 set(CMAKE_MODULE_PATH
   ${CMAKE_MODULE_PATH}
-  "${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Modules"
-  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
+  ${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Modules
 )
 
-if (NOT CMAKE_BUILD_TYPE)
-  message(STATUS "${PROJECT_NAME}: No build type selected, default to Release")
-  set(CMAKE_BUILD_TYPE "Release")
-endif ()
-
-include(BuildMacros)
-include(WindowsMacros)
 
+##############################################################
+# Libs and Bins names
+##############################################################
 set(HICN_APPS hicn-apps CACHE INTERNAL "" FORCE)
+set(HIGET higet)
+set(HTTP_PROXY hicn-http-proxy)
+set(LIBHTTP_PROXY hicnhttpproxy)
+set(LIBHTTP_PROXY_STATIC ${LIBHTTP_PROXY}.static)
+
 
+##############################################################
+# Dependencies and third party libs
+##############################################################
 find_package(Threads REQUIRED)
-find_package(Libconfig++ REQUIRED)
+find_package(Libconfig++ ${LIBCONFIG_DEFAULT_VERSION} REQUIRED)
 
+
+##############################################################
+# Check if building as subproject or as root project
+##############################################################
 if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-  find_package(Libtransport REQUIRED)
-  find_package(Libhicn REQUIRED)
-  find_package(hicnctrl REQUIRED)
+  include(CommonSetup)
+
+  find_package(Libhicn ${CURRENT_VERSION} REQUIRED NO_MODULE)
+  find_package(Libhicnctrl ${CURRENT_VERSION} REQUIRED NO_MODULE)
+  find_package(Libhicntransport ${CURRENT_VERSION} REQUIRED NO_MODULE)
+
+  if (DISABLE_SHARED_LIBRARIES)
+    set(LIBTYPE static)
+  else()
+    set(LIBTYPE shared)
+  endif()
+
+  list(APPEND LIBHICN_LIBRARIES hicn::hicn.${LIBTYPE})
+  list(APPEND LIBTRANSPORT_LIBRARIES hicn::hicntransport.${LIBTYPE})
+  list(APPEND LIBHICNCTRL_LIBRARIES hicn::hicnctrl.${LIBTYPE})
 else()
   if (DISABLE_SHARED_LIBRARIES)
-    find_package(OpenSSL REQUIRED)
+    find_package(OpenSSL ${OPENSSL_DEFAULT_VERSION} REQUIRED)
     set(LIBTRANSPORT_LIBRARIES ${LIBTRANSPORT_STATIC})
     set(LIBHICN_LIBRARIES ${LIBHICN_STATIC})
     set(LIBHICNCTRL_LIBRARIES ${LIBHICNCTRL_STATIC})
@@ -56,20 +87,18 @@ else()
   )
 endif()
 
-if (WIN32)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4200 /wd4996")
-endif ()
 
-include(Packaging)
+##############################################################
+# Packaging and versioning
+##############################################################
+include(${CMAKE_CURRENT_SOURCE_DIR}/../versions.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/packaging.cmake)
 
+
+##############################################################
+# Subdirectories
+##############################################################
 add_subdirectory(ping)
 add_subdirectory(hiperf)
-
-set(HIGET higet)
-set(HTTP_PROXY hicn-http-proxy)
-
-if (NOT WIN32)
-  add_subdirectory(http-proxy)
-endif ()
-
+add_subdirectory(http-proxy)
 add_subdirectory(higet)
diff --git a/apps/cmake/Modules/Packaging.cmake b/apps/cmake/packaging.cmake
index 981eb728e..9142598ad 100644
--- a/apps/cmake/Modules/Packaging.cmake
+++ b/apps/cmake/packaging.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -18,21 +18,34 @@ useful for testing and debugging within a hicn network."
 )
 
 set(${HICN_APPS}_DEB_DEPENDENCIES
-  "lib${LIBTRANSPORT} (>= stable_version), lib${LIBHICNCTRL} (>= stable_version)"
+  "lib${LIBTRANSPORT} (= stable_version), lib${LIBHICNCTRL} (= stable_version)"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(${HICN_APPS}-dev_DEB_DEPENDENCIES
-  "${HICN_APPS} (>= stable_version), lib${LIBTRANSPORT}-dev (>= stable_version), lib${LIBHICNCTRL}-dev (>= stable_version)"
+  "${HICN_APPS} (= stable_version), lib${LIBTRANSPORT}-dev (= stable_version), lib${LIBHICNCTRL}-dev (= stable_version)"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(${HICN_APPS}_RPM_DEPENDENCIES
-  "lib${LIBTRANSPORT} >= stable_version, lib${LIBHICNCTRL} >= stable_version"
+  "lib${LIBTRANSPORT} = stable_version, lib${LIBHICNCTRL} = stable_version"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(${HICN_APPS}-dev_RPM_DEPENDENCIES
-  "${HICN_APPS} >= stable_version, lib${LIBTRANSPORT}-dev >= stable_version, lib${LIBHICNCTRL}-dev >= stable_version"
+  "${HICN_APPS} = stable_version, lib${LIBTRANSPORT}-dev = stable_version, lib${LIBHICNCTRL}-dev = stable_version"
   CACHE STRING "Dependencies for deb/rpm package."
-)
\ No newline at end of file
+)
+
+if (INTERNAL_ENVIRONMENT)
+  include(CheckSsl)
+  CheckSsl()
+  set(${HICN_APPS}_DEB_DEPENDENCIES
+    "${${HICN_APPS}_DEB_DEPENDENCIES}, ${OPENSSL_DEPENDENCY}"
+    CACHE STRING "Dependencies for deb/rpm package."
+  )
+  set(${HICN_APPS}-dev_DEB_DEPENDENCIES
+    "${${HICN_APPS}-dev_DEB_DEPENDENCIES}, ${OPENSSL_DEPENDENCY_DEV}"
+    CACHE STRING "Dependencies for deb/rpm package."
+  )
+endif ()
\ No newline at end of file
diff --git a/apps/higet/CMakeLists.txt b/apps/higet/CMakeLists.txt
index 8d112d3a3..f4d2d4ec4 100644
--- a/apps/higet/CMakeLists.txt
+++ b/apps/higet/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,36 +11,40 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
-set(CMAKE_CXX_STANDARD 14)
-
-project(utils)
-
-find_package(Threads REQUIRED)
-
-set(CMAKE_MODULE_PATH
-  ${CMAKE_MODULE_PATH}
-  "${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Modules"
-  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
-)
-
-if (NOT CMAKE_BUILD_TYPE)
-  message(STATUS "${PROJECT_NAME}: No build type selected, default to Release")
-  set(CMAKE_BUILD_TYPE "Release")
-endif ()
-
+##############################################################
+# Source files
+##############################################################
 list(APPEND APPS_SRC
   higet.cc
 )
 
+
+##############################################################
+# Linker flags
+##############################################################
 if (WIN32)
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /NODEFAULTLIB:\"LIBCMT\"" )
+  set(CMAKE_EXE_LINKER_FLAGS
+    "${CMAKE_EXE_LINKER_FLAGS} /NODEFAULTLIB:\"LIBCMT\""
+  )
 endif()
 
+
+##############################################################
+# Compiler options
+##############################################################
+set(COMPILER_OPTIONS
+  ${DEFAULT_COMPILER_OPTIONS}
+)
+
+
+##############################################################
+# Build higet
+##############################################################
 if (NOT DISABLE_EXECUTABLES)
   build_executable(${HIGET}
     SOURCES ${APPS_SRC}
     LINK_LIBRARIES
+      ${LIBHICN_LIBRARIES}
       ${LIBTRANSPORT_LIBRARIES}
       ${CMAKE_THREAD_LIBS_INIT}
       ${WSOCK32_LIBRARY}
@@ -49,5 +53,6 @@ if (NOT DISABLE_EXECUTABLES)
     COMPONENT ${HICN_APPS}
     DEFINITIONS ${COMPILER_DEFINITIONS}
     LINK_FLAGS ${LINK_FLAGS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS}
   )
 endif ()
diff --git a/apps/higet/higet.cc b/apps/higet/higet.cc
index 9ae869731..d72d7d74f 100644
--- a/apps/higet/higet.cc
+++ b/apps/higet/higet.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,23 +14,20 @@
  */
 
 #include <hicn/transport/http/client_connection.h>
+#include <hicn/transport/utils/chrono_typedefs.h>
 
 #include <algorithm>
+#include <asio.hpp>
 #include <fstream>
 #include <functional>
 #include <map>
 
+#ifndef ASIO_STANDALONE
 #define ASIO_STANDALONE
+#endif
 #include <asio.hpp>
-#undef ASIO_STANDALONE
-
 #include <thread>
 
-typedef std::chrono::time_point<std::chrono::system_clock> Time;
-typedef std::chrono::milliseconds TimeDuration;
-
-Time t1;
-
 #define DEFAULT_BETA 0.99
 #define DEFAULT_GAMMA 0.07
 
@@ -181,7 +178,7 @@ class ReadBytesCallbackImplementation
     });
   }
 
-  void onError(const std::error_code ec) {
+  void onError(const std::error_code &ec) {
     io_service_.post([this]() {
       of_.close();
       delete out_;
@@ -345,8 +342,6 @@ int main(int argc, char **argv) {
     connection.setVerifier(verifier);
   }
 
-  t1 = std::chrono::system_clock::now();
-
   http::ReadBytesCallbackImplementation readBytesCallback(conf.file_name,
                                                           yetDownloaded);
 
diff --git a/apps/hiperf/CMakeLists.txt b/apps/hiperf/CMakeLists.txt
index 564525e67..6986c90aa 100644
--- a/apps/hiperf/CMakeLists.txt
+++ b/apps/hiperf/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -12,6 +12,9 @@
 # limitations under the License.
 
 if (NOT DISABLE_EXECUTABLES)
+##############################################################
+# Source files
+##############################################################
   list(APPEND HIPERF_SRC
     ${CMAKE_CURRENT_SOURCE_DIR}/src/client.cc
     ${CMAKE_CURRENT_SOURCE_DIR}/src/main.cc
@@ -19,26 +22,40 @@ if (NOT DISABLE_EXECUTABLES)
     ${CMAKE_CURRENT_SOURCE_DIR}/src/forwarder_interface.cc
   )
 
+
+##############################################################
+# Libraries
+##############################################################
   list (APPEND HIPERF_LIBRARIES
-    ${LIBTRANSPORT_LIBRARIES}
-    ${LIBHICNCTRL_LIBRARIES}
-    ${LIBHICN_LIBRARIES}
-    ${CMAKE_THREAD_LIBS_INIT}
-    ${LIBCONFIG_CPP_LIBRARIES}
-    ${WSOCK32_LIBRARY}
-    ${WS2_32_LIBRARY}
+    PRIVATE ${LIBTRANSPORT_LIBRARIES}
+    PRIVATE ${LIBHICNCTRL_LIBRARIES}
+    PRIVATE ${LIBHICN_LIBRARIES}
+    PRIVATE ${CMAKE_THREAD_LIBS_INIT}
+    PRIVATE ${LIBCONFIG_CPP_LIBRARIES}
+    PRIVATE ${WSOCK32_LIBRARY}
+    PRIVATE ${WS2_32_LIBRARY}
+  )
+
+##############################################################
+# Compiler options
+##############################################################
+  set(COMPILER_OPTIONS
+    ${DEFAULT_COMPILER_OPTIONS}
   )
 
+
+##############################################################
+# Build hiperf
+##############################################################
   build_executable(hiperf
     SOURCES ${HIPERF_SRC}
     LINK_LIBRARIES ${HIPERF_LIBRARIES}
     INCLUDE_DIRS
-      ${CMAKE_CURRENT_SOURCE_DIR}/src
-      ${LIBTRANSPORT_INCLUDE_DIRS}
-      ${LIBHICNCTRL_INCLUDE_DIRS}
-      ${LIBCONFIG_CPP_INCLUDE_DIRS}
+      PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+      PRIVATE ${LIBCONFIG_CPP_INCLUDE_DIRS}
     DEPENDS ${DEPENDENCIES}
     COMPONENT ${HICN_APPS}
     LINK_FLAGS ${LINK_FLAGS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS}
   )
 endif()
\ No newline at end of file
diff --git a/apps/hiperf/src/client.cc b/apps/hiperf/src/client.cc
index 820ebf0ce..319fa82ab 100644
--- a/apps/hiperf/src/client.cc
+++ b/apps/hiperf/src/client.cc
@@ -31,17 +31,12 @@ class Callback;
  * Hiperf client class: configure and setup an hicn consumer following the
  * ClientConfiguration.
  */
-class HIperfClient::Impl
-#ifdef FORWARDER_INTERFACE
-    : ForwarderInterface::ICallback
-#endif
-{
-  typedef std::chrono::time_point<std::chrono::steady_clock> Time;
-  typedef std::chrono::microseconds TimeDuration;
-
+class HIperfClient::Impl : ForwarderInterface::ICallback {
   friend class Callback;
   friend class RTCCallback;
 
+  static const constexpr uint16_t log2_header_counter = 4;
+
   struct nack_packet_t {
     uint64_t timestamp;
     uint32_t prod_rate;
@@ -76,21 +71,29 @@ class HIperfClient::Impl
         delay_sample_(0),
         received_bytes_(0),
         received_data_pkt_(0),
+        auth_alerts_(0),
         data_delays_(""),
         signals_(io_service_),
         rtc_callback_(*this),
         callback_(*this),
         socket_(io_service_),
-        done_(false),
-        switch_threshold_(~0)
-#ifdef FORWARDER_INTERFACE
-        ,
-        forwarder_interface_(io_service_, this)
-#endif
-  {
+        // switch_threshold_(~0),
+        fwd_connected_(false),
+        use_bestpath_(false),
+        rtt_threshold_(~0),
+        loss_threshold_(~0),
+        prefix_name_(""),
+        prefix_len_(0),
+        // done_(false),
+        header_counter_mask_((1 << log2_header_counter) - 1),
+        header_counter_(0),
+        print_headers_(configuration_.print_headers_),
+        first_(true),
+        forwarder_interface_(io_service_) {
+    setForwarderConnection(conf.forwarder_type_);
   }
 
-  ~Impl() {}
+  virtual ~Impl() {}
 
   void checkReceivedRtcContent(ConsumerSocket &c,
                                const ContentObject &contentObject) {}
@@ -104,174 +107,187 @@ class HIperfClient::Impl
   void handleTimerExpiration(ConsumerSocket &c,
                              const TransportStatistics &stats) {
     const char separator = ' ';
-    const int width = 15;
+    const int width = 18;
 
-    utils::TimePoint t2 = utils::SteadyClock::now();
-    auto exact_duration =
-        std::chrono::duration_cast<utils::Milliseconds>(t2 - t_stats_);
+    utils::SteadyTime::TimePoint t2 = utils::SteadyTime::Clock::now();
+    auto exact_duration = utils::SteadyTime::getDurationMs(t_stats_, t2);
 
-    std::stringstream interval;
-    interval << total_duration_milliseconds_ / 1000 << "-"
-             << total_duration_milliseconds_ / 1000 +
-                    exact_duration.count() / 1000;
+    std::stringstream interval_ms;
+    interval_ms << total_duration_milliseconds_ << "-"
+                << total_duration_milliseconds_ + exact_duration.count();
 
     std::stringstream bytes_transferred;
     bytes_transferred << std::fixed << std::setprecision(3)
                       << (stats.getBytesRecv() - old_bytes_value_) / 1000000.0
-                      << std::setfill(separator) << "[MB]";
+                      << std::setfill(separator);
 
     std::stringstream bandwidth;
     bandwidth << ((stats.getBytesRecv() - old_bytes_value_) * 8) /
                      (exact_duration.count()) / 1000.0
-              << std::setfill(separator) << "[Mbps]";
+              << std::setfill(separator);
 
     std::stringstream window;
-    window << stats.getAverageWindowSize() << std::setfill(separator)
-           << "[Int]";
+    window << stats.getAverageWindowSize() << std::setfill(separator);
 
     std::stringstream avg_rtt;
-    avg_rtt << stats.getAverageRtt() << std::setfill(separator) << "[ms]";
+    avg_rtt << stats.getAverageRtt() << std::setfill(separator);
 
     if (configuration_.rtc_) {
-      // we get rtc stats more often, thus we need ms in the interval
-      std::stringstream interval_ms;
-      interval_ms << total_duration_milliseconds_ << "-"
-                  << total_duration_milliseconds_ + exact_duration.count();
-
       std::stringstream lost_data;
       lost_data << stats.getLostData() - old_lost_data_value_
-                << std::setfill(separator) << "[pkt]";
+                << std::setfill(separator);
 
       std::stringstream bytes_recovered_data;
       bytes_recovered_data << stats.getBytesRecoveredData() -
                                   old_bytes_recovered_value_
-                           << std::setfill(separator) << "[pkt]";
+                           << std::setfill(separator);
 
       std::stringstream definitely_lost_data;
       definitely_lost_data << stats.getDefinitelyLostData() -
                                   old_definitely_lost_data_value_
-                           << std::setfill(separator) << "[pkt]";
+                           << std::setfill(separator);
 
       std::stringstream data_delay;
-      data_delay << avg_data_delay_ << std::setfill(separator) << "[ms]";
+      data_delay << std::fixed << std::setprecision(3) << avg_data_delay_
+                 << std::setfill(separator);
 
       std::stringstream received_data_pkt;
-      received_data_pkt << received_data_pkt_ << std::setfill(separator)
-                        << "[pkt]";
+      received_data_pkt << received_data_pkt_ << std::setfill(separator);
 
       std::stringstream goodput;
-      goodput << (received_bytes_ * 8.0) / (exact_duration.count()) / 1000.0
-              << std::setfill(separator) << "[Mbps]";
+      goodput << std::fixed << std::setprecision(3)
+              << (received_bytes_ * 8.0) / (exact_duration.count()) / 1000.0
+              << std::setfill(separator);
 
       std::stringstream loss_rate;
       loss_rate << std::fixed << std::setprecision(2)
-                << stats.getLossRatio() * 100.0 << std::setfill(separator)
-                << "[%]";
+                << stats.getLossRatio() * 100.0 << std::setfill(separator);
 
       std::stringstream retx_sent;
       retx_sent << stats.getRetxCount() - old_retx_value_
-                << std::setfill(separator) << "[pkt]";
+                << std::setfill(separator);
 
       std::stringstream interest_sent;
       interest_sent << stats.getInterestTx() - old_sent_int_value_
-                    << std::setfill(separator) << "[pkt]";
+                    << std::setfill(separator);
 
       std::stringstream nacks;
       nacks << stats.getReceivedNacks() - old_received_nacks_value_
-            << std::setfill(separator) << "[pkt]";
+            << std::setfill(separator);
 
       std::stringstream fec_pkt;
       fec_pkt << stats.getReceivedFEC() - old_fec_pkt_
-              << std::setfill(separator) << "[pkt]";
+              << std::setfill(separator);
 
       std::stringstream queuing_delay;
-      queuing_delay << stats.getQueuingDelay() << std::setfill(separator)
-                    << "[ms]";
+      queuing_delay << std::fixed << std::setprecision(3)
+                    << stats.getQueuingDelay() << std::setfill(separator);
 
-#ifdef FORWARDER_INTERFACE
-      if (!done_ && stats.getQueuingDelay() >= switch_threshold_ &&
-          total_duration_milliseconds_ > 1000) {
-        std::cout << "Switching due to queuing delay" << std::endl;
-        forwarder_interface_.createFaceAndRoutes(backup_routes_);
-        forwarder_interface_.deleteFaceAndRoutes(main_routes_);
-        std::swap(backup_routes_, main_routes_);
-        done_ = true;
+      std::stringstream residual_losses;
+      double rl_perc = stats.getResidualLossRate() * 100;
+      residual_losses << std::fixed << std::setprecision(2) << rl_perc
+                      << std::setfill(separator);
+
+      std::stringstream quality_score;
+      quality_score << std::fixed << (int)stats.getQualityScore()
+                    << std::setfill(separator);
+
+      std::stringstream alerts;
+      alerts << stats.getAlerts() << std::setfill(separator);
+
+      std::stringstream auth_alerts;
+      auth_alerts << auth_alerts_ << std::setfill(separator);
+
+      if (fwd_connected_ && use_bestpath_ &&
+          ((stats.getAverageRtt() > rtt_threshold_) ||
+           ((stats.getResidualLossRate() * 100) > loss_threshold_))) {
+        forwarder_interface_.setStrategy(prefix_name_, prefix_len_, "bestpath");
       }
-#endif
 
-      // statistics not yet available in the transport
-      // std::stringstream interest_fec_tx;
-      // interest_fec_tx << stats.getInterestFecTxCount() -
-      //    old_fec_interest_tx_value_ << std::setfill(separator) << "[pkt]";
-      // std::stringstream bytes_fec_recv;
-      // bytes_fec_recv << stats.getBytesFecRecv() - old_fec_data_rx_value_
-      //              << std::setfill(separator) << "[bytes]";
-      std::cout << std::left << std::setw(width) << "Interval";
-      std::cout << std::left << std::setw(width) << "RecvData";
-      std::cout << std::left << std::setw(width) << "Bandwidth";
-      std::cout << std::left << std::setw(width) << "Goodput";
-      std::cout << std::left << std::setw(width) << "LossRate";
-      std::cout << std::left << std::setw(width) << "Retr";
-      std::cout << std::left << std::setw(width) << "InterestSent";
-      std::cout << std::left << std::setw(width) << "ReceivedNacks";
-      std::cout << std::left << std::setw(width) << "SyncWnd";
-      std::cout << std::left << std::setw(width) << "MinRtt";
-      std::cout << std::left << std::setw(width) << "QueuingDelay";
-      std::cout << std::left << std::setw(width) << "LostData";
-      std::cout << std::left << std::setw(width) << "RecoveredData";
-      std::cout << std::left << std::setw(width) << "DefinitelyLost";
-      std::cout << std::left << std::setw(width) << "State";
-      std::cout << std::left << std::setw(width) << "DataDelay";
-      std::cout << std::left << std::setw(width) << "FecPkt" << std::endl;
-
-      std::cout << std::left << std::setw(width) << interval_ms.str();
-      std::cout << std::left << std::setw(width) << received_data_pkt.str();
-      std::cout << std::left << std::setw(width) << bandwidth.str();
-      std::cout << std::left << std::setw(width) << goodput.str();
-      std::cout << std::left << std::setw(width) << loss_rate.str();
-      std::cout << std::left << std::setw(width) << retx_sent.str();
-      std::cout << std::left << std::setw(width) << interest_sent.str();
-      std::cout << std::left << std::setw(width) << nacks.str();
-      std::cout << std::left << std::setw(width) << window.str();
-      std::cout << std::left << std::setw(width) << avg_rtt.str();
-      std::cout << std::left << std::setw(width) << queuing_delay.str();
-      std::cout << std::left << std::setw(width) << lost_data.str();
-      std::cout << std::left << std::setw(width) << bytes_recovered_data.str();
-      std::cout << std::left << std::setw(width) << definitely_lost_data.str();
-      std::cout << std::left << std::setw(width) << stats.getCCStatus();
-      std::cout << std::left << std::setw(width) << data_delay.str();
-      std::cout << std::left << std::setw(width) << fec_pkt.str();
+      if ((header_counter_ == 0 && print_headers_) || first_) {
+        std::cout << std::right << std::setw(width) << "Interval[ms]";
+        std::cout << std::right << std::setw(width) << "RecvData[pkt]";
+        std::cout << std::right << std::setw(width) << "Bandwidth[Mbps]";
+        std::cout << std::right << std::setw(width) << "Goodput[Mbps]";
+        std::cout << std::right << std::setw(width) << "LossRate[%]";
+        std::cout << std::right << std::setw(width) << "Retr[pkt]";
+        std::cout << std::right << std::setw(width) << "InterestSent";
+        std::cout << std::right << std::setw(width) << "ReceivedNacks";
+        std::cout << std::right << std::setw(width) << "SyncWnd[pkt]";
+        std::cout << std::right << std::setw(width) << "MinRtt[ms]";
+        std::cout << std::right << std::setw(width) << "QueuingDelay[ms]";
+        std::cout << std::right << std::setw(width) << "LostData[pkt]";
+        std::cout << std::right << std::setw(width) << "RecoveredData";
+        std::cout << std::right << std::setw(width) << "DefinitelyLost";
+        std::cout << std::right << std::setw(width) << "State";
+        std::cout << std::right << std::setw(width) << "DataDelay[ms]";
+        std::cout << std::right << std::setw(width) << "FecPkt";
+        std::cout << std::right << std::setw(width) << "Congestion";
+        std::cout << std::right << std::setw(width) << "ResidualLosses";
+        std::cout << std::right << std::setw(width) << "QualityScore";
+        std::cout << std::right << std::setw(width) << "Alerts";
+        std::cout << std::right << std::setw(width) << "AuthAlerts"
+                  << std::endl;
+
+        first_ = false;
+      }
+
+      std::cout << std::right << std::setw(width) << interval_ms.str();
+      std::cout << std::right << std::setw(width) << received_data_pkt.str();
+      std::cout << std::right << std::setw(width) << bandwidth.str();
+      std::cout << std::right << std::setw(width) << goodput.str();
+      std::cout << std::right << std::setw(width) << loss_rate.str();
+      std::cout << std::right << std::setw(width) << retx_sent.str();
+      std::cout << std::right << std::setw(width) << interest_sent.str();
+      std::cout << std::right << std::setw(width) << nacks.str();
+      std::cout << std::right << std::setw(width) << window.str();
+      std::cout << std::right << std::setw(width) << avg_rtt.str();
+      std::cout << std::right << std::setw(width) << queuing_delay.str();
+      std::cout << std::right << std::setw(width) << lost_data.str();
+      std::cout << std::right << std::setw(width) << bytes_recovered_data.str();
+      std::cout << std::right << std::setw(width) << definitely_lost_data.str();
+      std::cout << std::right << std::setw(width) << stats.getCCStatus();
+      std::cout << std::right << std::setw(width) << data_delay.str();
+      std::cout << std::right << std::setw(width) << fec_pkt.str();
+      std::cout << std::right << std::setw(width) << stats.isCongested();
+      std::cout << std::right << std::setw(width) << residual_losses.str();
+      std::cout << std::right << std::setw(width) << quality_score.str();
+      std::cout << std::right << std::setw(width) << alerts.str();
+      std::cout << std::right << std::setw(width) << auth_alerts.str();
       std::cout << std::endl;
 
       if (configuration_.test_mode_) {
         if (data_delays_.size() > 0) data_delays_.pop_back();
 
-        uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                           std::chrono::system_clock::now().time_since_epoch())
-                           .count();
-        std::cout << now << " DATA-DELAYS:[" << data_delays_ << "]"
-                  << std::endl;
+        auto now = utils::SteadyTime::nowMs();
+        std::cout << std::fixed << std::setprecision(0) << now.count()
+                  << " DATA-DELAYS:[" << data_delays_ << "]" << std::endl;
       }
 
       // statistics not yet available in the transport
-      // std::cout << std::left << std::setw(width) << interest_fec_tx.str();
-      // std::cout << std::left << std::setw(width) << bytes_fec_recv.str();
+      // std::cout << std::right << std::setw(width) << interest_fec_tx.str();
+      // std::cout << std::right << std::setw(width) << bytes_fec_recv.str();
     } else {
-      std::cout << std::left << std::setw(width) << "Interval";
-      std::cout << std::left << std::setw(width) << "Transfer";
-      std::cout << std::left << std::setw(width) << "Bandwidth";
-      std::cout << std::left << std::setw(width) << "Retr";
-      std::cout << std::left << std::setw(width) << "Cwnd";
-      std::cout << std::left << std::setw(width) << "AvgRtt" << std::endl;
-
-      std::cout << std::left << std::setw(width) << interval.str();
-      std::cout << std::left << std::setw(width) << bytes_transferred.str();
-      std::cout << std::left << std::setw(width) << bandwidth.str();
-      std::cout << std::left << std::setw(width) << stats.getRetxCount();
-      std::cout << std::left << std::setw(width) << window.str();
-      std::cout << std::left << std::setw(width) << avg_rtt.str() << std::endl;
-      std::cout << std::endl;
+      if ((header_counter_ == 0 && print_headers_) || first_) {
+        std::cout << std::right << std::setw(width) << "Interval[ms]";
+        std::cout << std::right << std::setw(width) << "Transfer[MB]";
+        std::cout << std::right << std::setw(width) << "Bandwidth[Mbps]";
+        std::cout << std::right << std::setw(width) << "Retr[pkt]";
+        std::cout << std::right << std::setw(width) << "Cwnd[Int]";
+        std::cout << std::right << std::setw(width) << "AvgRtt[ms]"
+                  << std::endl;
+
+        first_ = false;
+      }
+
+      std::cout << std::right << std::setw(width) << interval_ms.str();
+      std::cout << std::right << std::setw(width) << bytes_transferred.str();
+      std::cout << std::right << std::setw(width) << bandwidth.str();
+      std::cout << std::right << std::setw(width) << stats.getRetxCount();
+      std::cout << std::right << std::setw(width) << window.str();
+      std::cout << std::right << std::setw(width) << avg_rtt.str() << std::endl;
     }
+
     total_duration_milliseconds_ += (uint32_t)exact_duration.count();
     old_bytes_value_ = stats.getBytesRecv();
     old_lost_data_value_ = stats.getLostData();
@@ -289,9 +305,95 @@ class HIperfClient::Impl
     received_data_pkt_ = 0;
     data_delays_ = "";
 
-    t_stats_ = utils::SteadyClock::now();
+    t_stats_ = utils::SteadyTime::Clock::now();
+
+    header_counter_ = (header_counter_ + 1) & header_counter_mask_;
+
+    if (--configuration_.nb_iterations_ == 0) {
+      // We reached the maximum nb of runs. Stop now.
+      io_service_.stop();
+    }
   }
 
+  bool setForwarderConnection(forwarder_type_t forwarder_type) {
+    using namespace libconfig;
+    Config cfg;
+
+    const char *conf_file = getenv("FORWARDER_CONFIG");
+    if (!conf_file) return false;
+
+    if ((forwarder_type != HICNLIGHT) && (forwarder_type != HICNLIGHT_NG))
+      return false;
+
+    try {
+      cfg.readFile(conf_file);
+    } catch (const FileIOException &fioex) {
+      std::cerr << "I/O error while reading file." << std::endl;
+      return false;
+    } catch (const ParseException &pex) {
+      std::cerr << "Parse error at " << pex.getFile() << ":" << pex.getLine()
+                << " - " << pex.getError() << std::endl;
+      return false;
+    }
+
+    Setting &config = cfg.getRoot();
+
+    /* conf file example
+     *
+     * use_bestpath = "ON | OFF"
+     * rtt_threshold = 200 //ms
+     * loss_threshold = 20 //%
+     * name = "b001::/16"
+     */
+
+    if (config.exists("use_bestpath")) {
+      std::string val;
+      config.lookupValue("use_bestpath", val);
+      if (val.compare("ON") == 0) use_bestpath_ = true;
+    }
+
+    if (config.exists("rtt_threshold")) {
+      unsigned val;
+      config.lookupValue("rtt_threshold", val);
+      rtt_threshold_ = val;
+    }
+
+    if (config.exists("loss_threshold")) {
+      unsigned val;
+      config.lookupValue("loss_threshold", val);
+      loss_threshold_ = val;
+    }
+
+    if (config.exists("name")) {
+      std::string route;
+      config.lookupValue("name", route);
+
+      std::string delimiter = "/";
+      size_t pos = 0;
+
+      if ((pos = route.find(delimiter)) != std::string::npos) {
+        prefix_name_ = route.substr(0, pos);
+        route.erase(0, pos + delimiter.length());
+        prefix_len_ = std::stoul(route.substr(0));
+      }
+    }
+
+    forwarder_interface_.initForwarderInterface(this, forwarder_type);
+
+    return true;
+  }
+
+  void onHicnServiceReady() override {
+    std::cout << "Successfully connected to local forwarder!" << std::endl;
+    fwd_connected_ = true;
+  }
+
+  void onRouteConfigured(
+      std::vector<ForwarderInterface::RouteInfoPtr> &route_info) override {
+    std::cout << "Routes successfully configured!" << std::endl;
+  }
+
+#ifdef FORWARDER_INTERFACE
   bool parseConfig(const char *conf_file) {
     using namespace libconfig;
     Config cfg;
@@ -439,7 +541,6 @@ class HIperfClient::Impl
     return true;
   }
 
-#ifdef FORWARDER_INTERFACE
   void onHicnServiceReady() override {
     std::cout << "Successfully connected to local forwarder!" << std::endl;
 
@@ -541,6 +642,13 @@ class HIperfClient::Impl
   }
 #endif
 
+  transport::auth::VerificationPolicy onAuthFailed(
+      transport::auth::Suffix suffix,
+      transport::auth::VerificationPolicy policy) {
+    auth_alerts_++;
+    return transport::auth::VerificationPolicy::ACCEPT;
+  }
+
   int setup() {
     int ret;
 
@@ -557,6 +665,7 @@ class HIperfClient::Impl
       producer_socket_ = std::make_unique<ProducerSocket>(production_protocol);
       producer_socket_->registerPrefix(configuration_.relay_name_);
       producer_socket_->connect();
+      producer_socket_->start();
     }
 
     if (configuration_.output_stream_mode_ && configuration_.rtc_) {
@@ -586,6 +695,17 @@ class HIperfClient::Impl
         GeneralTransportOptions::INTEREST_LIFETIME,
         configuration_.interest_lifetime_);
 
+    consumer_socket_->setSocketOption(
+        GeneralTransportOptions::MAX_UNVERIFIED_TIME,
+        configuration_.unverified_delay_);
+
+    if (consumer_socket_->setSocketOption(
+            GeneralTransportOptions::PACKET_FORMAT,
+            configuration_.packet_format_) == SOCKET_OPTION_NOT_SET) {
+      std::cerr << "ERROR -- Impossible to set the packet format." << std::endl;
+      return ERROR_SETUP;
+    }
+
 #if defined(DEBUG) && defined(__linux__)
     std::shared_ptr<transport::BasePortal> portal;
     consumer_socket_->getSocketOption(GeneralTransportOptions::PORTAL, portal);
@@ -623,20 +743,24 @@ class HIperfClient::Impl
       }
     }
 
+    std::shared_ptr<Verifier> verifier = std::make_shared<VoidVerifier>();
+
     if (!configuration_.producer_certificate.empty()) {
-      std::shared_ptr<Verifier> verifier = std::make_shared<AsymmetricVerifier>(
+      verifier = std::make_shared<AsymmetricVerifier>(
           configuration_.producer_certificate);
-      if (consumer_socket_->setSocketOption(GeneralTransportOptions::VERIFIER,
-                                            verifier) == SOCKET_OPTION_NOT_SET)
-        return ERROR_SETUP;
     }
 
     if (!configuration_.passphrase.empty()) {
-      std::shared_ptr<Verifier> verifier =
-          std::make_shared<SymmetricVerifier>(configuration_.passphrase);
-      if (consumer_socket_->setSocketOption(GeneralTransportOptions::VERIFIER,
-                                            verifier) == SOCKET_OPTION_NOT_SET)
-        return ERROR_SETUP;
+      verifier = std::make_shared<SymmetricVerifier>(configuration_.passphrase);
+    }
+
+    verifier->setVerificationFailedCallback(
+        std::bind(&HIperfClient::Impl::onAuthFailed, this,
+                  std::placeholders::_1, std::placeholders::_2));
+
+    if (consumer_socket_->setSocketOption(GeneralTransportOptions::VERIFIER,
+                                          verifier) == SOCKET_OPTION_NOT_SET) {
+      return ERROR_SETUP;
     }
 
     ret = consumer_socket_->setSocketOption(
@@ -662,6 +786,65 @@ class HIperfClient::Impl
     }
 
     if (configuration_.rtc_) {
+      if (configuration_.recovery_strategy_ == 1) {  // unreliable
+        ret = consumer_socket_->setSocketOption(
+            RtcTransportOptions::RECOVERY_STRATEGY,
+            (uint32_t)RtcTransportRecoveryStrategies::RECOVERY_OFF);
+      } else if (configuration_.recovery_strategy_ == 2) {  // rtx only
+        ret = consumer_socket_->setSocketOption(
+            RtcTransportOptions::RECOVERY_STRATEGY,
+            (uint32_t)RtcTransportRecoveryStrategies::RTX_ONLY);
+      } else if (configuration_.recovery_strategy_ == 3) {  // fec only
+        ret = consumer_socket_->setSocketOption(
+            RtcTransportOptions::RECOVERY_STRATEGY,
+            (uint32_t)RtcTransportRecoveryStrategies::FEC_ONLY);
+      } else if (configuration_.recovery_strategy_ == 4) {  // delay based
+        ret = consumer_socket_->setSocketOption(
+            RtcTransportOptions::RECOVERY_STRATEGY,
+            (uint32_t)RtcTransportRecoveryStrategies::DELAY_BASED);
+      } else if (configuration_.recovery_strategy_ == 5) {  // low rate flow
+        ret = consumer_socket_->setSocketOption(
+            RtcTransportOptions::RECOVERY_STRATEGY,
+            (uint32_t)RtcTransportRecoveryStrategies::LOW_RATE);
+      } else if (configuration_.recovery_strategy_ ==
+                 6) {  // low rate + bestpath
+        ret = consumer_socket_->setSocketOption(
+            RtcTransportOptions::RECOVERY_STRATEGY,
+            (uint32_t)RtcTransportRecoveryStrategies::LOW_RATE_AND_BESTPATH);
+      } else if (configuration_.recovery_strategy_ ==
+                 7) {  // low rate + replication
+        ret = consumer_socket_->setSocketOption(
+            RtcTransportOptions::RECOVERY_STRATEGY,
+            (uint32_t)RtcTransportRecoveryStrategies::LOW_RATE_AND_REPLICATION);
+      } else if (configuration_.recovery_strategy_ ==
+                 8) {  // low rate + bestpath or replication
+        ret = consumer_socket_->setSocketOption(
+            RtcTransportOptions::RECOVERY_STRATEGY,
+            (uint32_t)RtcTransportRecoveryStrategies::
+                LOW_RATE_AND_ALL_FWD_STRATEGIES);
+      } else {
+        // default
+        ret = consumer_socket_->setSocketOption(
+            RtcTransportOptions::RECOVERY_STRATEGY,
+            (uint32_t)RtcTransportRecoveryStrategies::RTX_ONLY);
+      }
+
+      if (ret == SOCKET_OPTION_NOT_SET) {
+        return ERROR_SETUP;
+      }
+    }
+
+    if (configuration_.rtc_) {
+      ret = consumer_socket_->setSocketOption(
+          RtcTransportOptions::AGGREGATED_DATA,
+          configuration_.aggregated_data_);
+
+      if (ret == SOCKET_OPTION_NOT_SET) {
+        return ERROR_SETUP;
+      }
+    }
+
+    if (configuration_.rtc_) {
       ret = consumer_socket_->setSocketOption(
           ConsumerCallbacksOptions::CONTENT_OBJECT_INPUT,
           (ConsumerContentObjectCallback)std::bind(
@@ -673,6 +856,15 @@ class HIperfClient::Impl
     }
 
     if (configuration_.rtc_) {
+      ret = consumer_socket_->setSocketOption(GeneralTransportOptions::FEC_TYPE,
+                                              configuration_.fec_type_);
+
+      if (ret == SOCKET_OPTION_NOT_SET) {
+        return ERROR_SETUP;
+      }
+    }
+
+    if (configuration_.rtc_) {
       std::shared_ptr<TransportStatistics> transport_stats;
       consumer_socket_->getSocketOption(
           OtherOptions::STATISTICS, (TransportStatistics **)&transport_stats);
@@ -708,10 +900,10 @@ class HIperfClient::Impl
     signals_.async_wait(
         [this](const std::error_code &, const int &) { io_service_.stop(); });
 
-    t_download_ = t_stats_ = std::chrono::steady_clock::now();
-    consumer_socket_->asyncConsume(configuration_.name);
-    io_service_.run();
+    t_download_ = t_stats_ = utils::SteadyTime::now();
+    consumer_socket_->consume(configuration_.name);
 
+    io_service_.run();
     consumer_socket_->stop();
 
     return ERROR_SUCCESS;
@@ -719,11 +911,15 @@ class HIperfClient::Impl
 
  private:
   class RTCCallback : public ConsumerSocket::ReadCallback {
-    static constexpr std::size_t mtu = 1500;
+    static constexpr std::size_t mtu = HIPERF_MTU;
 
    public:
     RTCCallback(Impl &hiperf_client) : client_(hiperf_client) {
       client_.configuration_.receive_buffer = utils::MemBuf::create(mtu);
+      Packet::Format format =
+          PayloadSize::getFormatFromName(client_.configuration_.name, false);
+      payload_size_max_ =
+          PayloadSize(format).getPayloadSizeMax(RTC_HEADER_SIZE);
     }
 
     bool isBufferMovable() noexcept override { return false; }
@@ -743,9 +939,7 @@ class HIperfClient::Impl
       uint64_t *senderTimeStamp =
           (uint64_t *)client_.configuration_.receive_buffer->writableData();
 
-      uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                         std::chrono::system_clock::now().time_since_epoch())
-                         .count();
+      auto now = utils::SystemTime::nowMs().count();
       double new_delay = (double)(now - *senderTimeStamp);
 
       if (*senderTimeStamp > now)
@@ -765,7 +959,7 @@ class HIperfClient::Impl
         client_.producer_socket_->produceDatagram(
             client_.configuration_.relay_name_.getName(),
             client_.configuration_.receive_buffer->writableData(),
-            length < 1400 ? length : 1400);
+            length < payload_size_max_ ? length : payload_size_max_);
       }
       if (client_.configuration_.output_stream_mode_) {
         uint8_t *start =
@@ -778,7 +972,7 @@ class HIperfClient::Impl
 
     size_t maxBufferSize() const override { return mtu; }
 
-    void readError(const std::error_code ec) noexcept override {
+    void readError(const std::error_code &ec) noexcept override {
       std::cerr << "Error while reading from RTC socket" << std::endl;
       client_.io_service_.stop();
     }
@@ -789,6 +983,7 @@ class HIperfClient::Impl
 
    private:
     Impl &client_;
+    std::size_t payload_size_max_;
   };
 
   class Callback : public ConsumerSocket::ReadCallback {
@@ -816,16 +1011,15 @@ class HIperfClient::Impl
       return client_.configuration_.receive_buffer_size_;
     }
 
-    void readError(const std::error_code ec) noexcept override {
+    void readError(const std::error_code &ec) noexcept override {
       std::cerr << "Error " << ec.message() << " while reading from socket"
                 << std::endl;
       client_.io_service_.stop();
     }
 
     void readSuccess(std::size_t total_size) noexcept override {
-      Time t2 = std::chrono::steady_clock::now();
-      TimeDuration dt =
-          std::chrono::duration_cast<TimeDuration>(t2 - client_.t_download_);
+      auto t2 = utils::SteadyTime::now();
+      auto dt = utils::SteadyTime::getDurationUs(client_.t_download_, t2);
       long usec = (long)dt.count();
 
       std::cout << "Content retrieved. Size: " << total_size << " [Bytes]"
@@ -843,8 +1037,8 @@ class HIperfClient::Impl
   };
 
   hiperf::ClientConfiguration configuration_;
-  Time t_stats_;
-  Time t_download_;
+  utils::SteadyTime::TimePoint t_stats_;
+  utils::SteadyTime::TimePoint t_download_;
   uint32_t total_duration_milliseconds_;
   uint64_t old_bytes_value_;
   uint64_t old_interest_tx_value_;
@@ -865,6 +1059,7 @@ class HIperfClient::Impl
 
   uint32_t received_bytes_;
   uint32_t received_data_pkt_;
+  uint32_t auth_alerts_;
 
   std::string data_delays_;
 
@@ -878,19 +1073,44 @@ class HIperfClient::Impl
   asio::ip::udp::endpoint remote_;
 
   ForwarderConfiguration config_;
-  uint16_t switch_threshold_; /* ms */
-  bool done_;
+  // uint16_t switch_threshold_; /* ms */
+  bool fwd_connected_;
+  bool use_bestpath_;
+  uint32_t rtt_threshold_;   /* ms */
+  uint32_t loss_threshold_;  /* ms */
+  std::string prefix_name_;  // bestpath route
+  uint32_t prefix_len_;
+  // bool done_;
+
   std::vector<ForwarderInterface::RouteInfoPtr> main_routes_;
   std::vector<ForwarderInterface::RouteInfoPtr> backup_routes_;
-#ifdef FORWARDER_INTERFACE
+  uint16_t header_counter_mask_;
+  uint16_t header_counter_;
+
+  bool print_headers_;
+  bool first_;
+
   ForwarderInterface forwarder_interface_;
-#endif
 };
 
 HIperfClient::HIperfClient(const ClientConfiguration &conf) {
   impl_ = new Impl(conf);
 }
 
+HIperfClient::HIperfClient(HIperfClient &&other) {
+  impl_ = other.impl_;
+  other.impl_ = nullptr;
+}
+
+HIperfClient &HIperfClient::operator=(HIperfClient &&other) {
+  if (this != &other) {
+    impl_ = other.impl_;
+    other.impl_ = nullptr;
+  }
+
+  return *this;
+}
+
 HIperfClient::~HIperfClient() { delete impl_; }
 
 int HIperfClient::setup() { return impl_->setup(); }
diff --git a/apps/hiperf/src/client.h b/apps/hiperf/src/client.h
index f45b9af43..bc80c874c 100644
--- a/apps/hiperf/src/client.h
+++ b/apps/hiperf/src/client.h
@@ -16,12 +16,16 @@
 #pragma once
 
 #include <common.h>
+#include <hicn/transport/utils/noncopyable.h>
 
 namespace hiperf {
 
-class HIperfClient {
+class HIperfClient : ::utils::NonCopyable {
  public:
   HIperfClient(const ClientConfiguration &conf);
+  HIperfClient(HIperfClient &&other);
+  HIperfClient &operator=(HIperfClient &&other);
+
   ~HIperfClient();
   int setup();
   void run();
diff --git a/apps/hiperf/src/common.h b/apps/hiperf/src/common.h
index e6ba526f9..13c9dcc1d 100644
--- a/apps/hiperf/src/common.h
+++ b/apps/hiperf/src/common.h
@@ -15,7 +15,7 @@
 
 #pragma once
 
-#include <hicn/transport/auth/identity.h>
+#include <forwarder_interface.h>
 #include <hicn/transport/auth/signer.h>
 #include <hicn/transport/config.h>
 #include <hicn/transport/core/content_object.h>
@@ -45,6 +45,9 @@
 #endif
 #define ERROR_SETUP -5
 #define MIN_PROBE_SEQ 0xefffffff
+#define RTC_HEADER_SIZE 12
+#define FEC_HEADER_MAX_SIZE 36
+#define HIPERF_MTU 1500
 
 using namespace transport::interface;
 using namespace transport::auth;
@@ -73,11 +76,51 @@ static inline uint64_t _htonll(const uint64_t *input) {
 namespace hiperf {
 
 /**
+ * Class to retrieve the maximum payload size given the MTU and packet headers.
+ */
+class PayloadSize {
+ public:
+  PayloadSize(Packet::Format format, std::size_t mtu = HIPERF_MTU)
+      : mtu_(mtu), format_(format) {}
+
+  std::size_t getPayloadSizeMax(std::size_t transport_size = 0,
+                                std::size_t fec_size = 0,
+                                std::size_t signature_size = 0) {
+    return mtu_ - Packet::getHeaderSizeFromFormat(format_, signature_size) -
+           transport_size - fec_size;
+  }
+
+  static Packet::Format getFormatFromName(Name name, bool ah = false) {
+    switch (name.getAddressFamily()) {
+      case AF_INET:
+        return ah ? HF_INET_TCP_AH : HF_INET_TCP;
+      case AF_INET6:
+        return ah ? HF_INET6_TCP_AH : HF_INET6_TCP;
+      default:
+        return HF_UNSPEC;
+    }
+  }
+
+ private:
+  std::size_t mtu_;
+  Packet::Format format_;
+};
+
+/**
  * Class for handling the production rate for the RTC producer.
  */
 class Rate {
  public:
   Rate() : rate_kbps_(0) {}
+  ~Rate() {}
+
+  Rate &operator=(const Rate &other) {
+    if (this != &other) {
+      rate_kbps_ = other.rate_kbps_;
+    }
+
+    return *this;
+  }
 
   Rate(const std::string &rate) {
     std::size_t found = rate.find("kbps");
@@ -137,9 +180,16 @@ struct ClientConfiguration {
         secure_(false),
         producer_prefix_(),
         interest_lifetime_(500),
+        unverified_delay_(2000),
         relay_name_("c001::abcd/64"),
         output_stream_mode_(false),
-        port_(0) {}
+        port_(0),
+        recovery_strategy_(4),
+        aggregated_data_(false),
+        fec_type_(""),
+        packet_format_(default_values::packet_format),
+        print_headers_(true),
+        nb_iterations_(std::numeric_limits<decltype(nb_iterations_)>::max()) {}
 
   Name name;
   double beta;
@@ -158,9 +208,17 @@ struct ClientConfiguration {
   bool secure_;
   Prefix producer_prefix_;
   uint32_t interest_lifetime_;
+  uint32_t unverified_delay_;
   Prefix relay_name_;
   bool output_stream_mode_;
   uint16_t port_;
+  uint32_t recovery_strategy_;
+  bool aggregated_data_;
+  std::string fec_type_;
+  Packet::Format packet_format_;
+  bool print_headers_;
+  std::uint32_t nb_iterations_;
+  forwarder_type_t forwarder_type_;
 };
 
 /**
@@ -170,11 +228,11 @@ struct ServerConfiguration {
   ServerConfiguration()
       : name("b001::abcd/64"),
         virtual_producer(true),
-        manifest(false),
+        manifest(0),
         live_production(false),
         content_lifetime(600000000_U32),
         download_size(20 * 1024 * 1024),
-        hash_algorithm(CryptoHashType::SHA256),
+        hash_algorithm_(CryptoHashType::SHA256),
         keystore_name(""),
         passphrase(""),
         keystore_password("cisco"),
@@ -185,18 +243,21 @@ struct ServerConfiguration {
         trace_index_(0),
         trace_file_(nullptr),
         production_rate_(std::string("2048kbps")),
-        payload_size_(1400),
+        payload_size_(1384),
         secure_(false),
         input_stream_mode_(false),
-        port_(0) {}
+        port_(0),
+        aggregated_data_(false),
+        fec_type_(""),
+        packet_format_(default_values::packet_format) {}
 
   Prefix name;
   bool virtual_producer;
-  bool manifest;
+  std::uint32_t manifest;
   bool live_production;
   std::uint32_t content_lifetime;
   std::uint32_t download_size;
-  CryptoHashType hash_algorithm;
+  CryptoHashType hash_algorithm_;
   std::string keystore_name;
   std::string passphrase;
   std::string keystore_password;
@@ -212,6 +273,9 @@ struct ServerConfiguration {
   bool input_stream_mode_;
   uint16_t port_;
   std::vector<struct packet_t> trace_;
+  bool aggregated_data_;
+  std::string fec_type_;
+  Packet::Format packet_format_;
 };
 
 }  // namespace hiperf
diff --git a/apps/hiperf/src/forwarder_config.h b/apps/hiperf/src/forwarder_config.h
index 655ac3b66..aaac14839 100644
--- a/apps/hiperf/src/forwarder_config.h
+++ b/apps/hiperf/src/forwarder_config.h
@@ -94,4 +94,4 @@ class ForwarderConfiguration {
   std::size_t n_threads_;
 };
 
-}
\ No newline at end of file
+}  // namespace hiperf
\ No newline at end of file
diff --git a/apps/hiperf/src/forwarder_interface.cc b/apps/hiperf/src/forwarder_interface.cc
index 864208239..e87a5953d 100644
--- a/apps/hiperf/src/forwarder_interface.cc
+++ b/apps/hiperf/src/forwarder_interface.cc
@@ -25,6 +25,7 @@
 extern "C" {
 #include <hicn/error.h>
 #include <hicn/util/ip_address.h>
+#include <hicn/util/sstrncpy.h>
 }
 
 // XXX the main listener should be retrieve in this class at initialization, aka
@@ -36,27 +37,14 @@ extern "C" {
 
 namespace hiperf {
 
+ForwarderInterface::ForwarderInterface(asio::io_service &io_service)
+    : external_ioservice_(io_service), timer_(io_service) {}
+
 ForwarderInterface::ForwarderInterface(asio::io_service &io_service,
-                                       ICallback *callback)
-    : external_ioservice_(io_service),
-      forwarder_interface_callback_(callback),
-      work_(std::make_unique<asio::io_service::work>(internal_ioservice_)),
-      sock_(nullptr),
-      thread_(std::make_unique<std::thread>([this]() {
-        std::cout << "Starting Forwarder Interface thread" << std::endl;
-        internal_ioservice_.run();
-        std::cout << "Stopping Forwarder Interface thread" << std::endl;
-      })),
-      // set_route_callback_(std::forward<Callback &&>(setRouteCallback)),
-      check_routes_timer_(nullptr),
-      pending_add_route_counter_(0),
-      hicn_listen_port_(9695),
-      /* We start in disabled state even when a forwarder is always available */
-      state_(State::Disabled),
-      timer_(io_service),
-      num_reattempts(0) {
-  std::cout << "Forwarder interface created... connecting to forwarder...\n";
-  internal_ioservice_.post([this]() { onHicnServiceAvailable(true); });
+                                       ICallback *callback,
+                                       forwarder_type_t fwd_type)
+    : external_ioservice_(io_service), timer_(io_service) {
+  initForwarderInterface(callback, fwd_type);
 }
 
 ForwarderInterface::~ForwarderInterface() {
@@ -72,8 +60,27 @@ ForwarderInterface::~ForwarderInterface() {
 
     thread_->join();
   }
+}
 
-  std::cout << "ForwarderInterface::~ForwarderInterface" << std::endl;
+void ForwarderInterface::initForwarderInterface(ICallback *callback,
+                                                forwarder_type_t fwd_type) {
+  forwarder_interface_callback_ = callback;
+  work_ = std::make_unique<asio::io_service::work>(internal_ioservice_);
+  sock_ = nullptr;
+  thread_ = std::make_unique<std::thread>([this]() {
+    std::cout << "Starting Forwarder Interface thread" << std::endl;
+    internal_ioservice_.run();
+    std::cout << "Stopping Forwarder Interface thread" << std::endl;
+  });
+  check_routes_timer_ = nullptr;
+  pending_add_route_counter_ = 0;
+  hicn_listen_port_ = 9695;
+  /* We start in disabled state even when a forwarder is always available */
+  state_ = State::Disabled;
+  fwd_type_ = fwd_type;
+  num_reattempts = 0;
+  std::cout << "Forwarder interface created... connecting to forwarder...\n";
+  internal_ioservice_.post([this]() { onHicnServiceAvailable(true); });
 }
 
 void ForwarderInterface::onHicnServiceAvailable(bool flag) {
@@ -93,26 +100,15 @@ void ForwarderInterface::onHicnServiceAvailable(bool flag) {
 
         std::cout << "Connected to forwarder... cancelling reconnection timer"
                   << std::endl;
+
         timer_.cancel();
         num_reattempts = 0;
 
-        // case State::Connected:
-        //   checkListener();
-
-        //   if (state_ != State::Ready) {
-        //     std::cout << "Listener not found" << std::endl;
-        //     goto REATTEMPT;
-        //   }
-        //   state_ = State::Ready;
-
-        //   timer_.cancel();
-        //   num_reattempts = 0;
-
         std::cout << "Forwarder interface is ready... communicate to controller"
                   << std::endl;
 
         forwarder_interface_callback_->onHicnServiceReady();
-
+      case State::Connected:
       case State::Ready:
         break;
     }
@@ -136,14 +132,14 @@ REATTEMPT:
       std::chrono::milliseconds(ForwarderInterface::REATTEMPT_DELAY_MS));
   // timer_.async_wait(std::bind(&ForwarderInterface::onHicnServiceAvailable,
   // this, flag, std::placeholders::_1));
-  timer_.async_wait([this, flag](std::error_code ec) {
+  timer_.async_wait([this, flag](const std::error_code &ec) {
     if (ec) return;
     onHicnServiceAvailable(flag);
   });
 }
 
 int ForwarderInterface::connectToForwarder() {
-  sock_ = hc_sock_create();
+  sock_ = hc_sock_create_forwarder(fwd_type_);
   if (!sock_) {
     std::cout << "Could not create socket" << std::endl;
     goto ERR_SOCK;
@@ -256,6 +252,27 @@ void ForwarderInterface::deleteFaceAndRoutes(
   });
 }
 
+void ForwarderInterface::setStrategy(std::string prefix, uint32_t prefix_len,
+                                     std::string strategy) {
+  if (!sock_) return;
+
+  ip_address_t ip_prefix;
+  if (ip_address_pton(prefix.c_str(), &ip_prefix) < 0) {
+    return;
+  }
+
+  strategy_type_t strategy_type = strategy_type_from_str(strategy.c_str());
+  if (strategy_type == STRATEGY_TYPE_UNDEFINED) return;
+
+  hc_strategy_t strategy_conf;
+  strategy_conf.address = ip_prefix;
+  strategy_conf.len = prefix_len;
+  strategy_conf.family = AF_INET6;
+  strategy_conf.type = strategy_type;
+
+  hc_strategy_set(sock_, &strategy_conf);
+}
+
 void ForwarderInterface::internalDeleteFaceAndRoute(
     const RouteInfoPtr &route_info) {
   if (!sock_) return;
@@ -346,10 +363,11 @@ void ForwarderInterface::internalCreateFaceAndRoutes(
     }
     max_try--;
     timer->expires_from_now(std::chrono::milliseconds(500));
-    timer->async_wait([this, failed, max_try, timer](std::error_code ec) {
-      if (ec) return;
-      internalCreateFaceAndRoutes(failed, max_try, timer);
-    });
+    timer->async_wait(
+        [this, failed, max_try, timer](const std::error_code &ec) {
+          if (ec) return;
+          internalCreateFaceAndRoutes(failed, max_try, timer);
+        });
     return;
   }
 
@@ -422,16 +440,18 @@ int ForwarderInterface::tryToCreateFace(RouteInfo *route_info,
 
     std::string name = "l_" + route_info->name;
     listener.local_addr = local_address;
-    listener.type = CONNECTION_TYPE_UDP;
+    listener.type = FACE_TYPE_UDP;
     listener.family = AF_INET;
     listener.local_port = route_info->local_port;
-    strncpy(listener.name, name.c_str(), sizeof(listener.name));
-    strncpy(listener.interface_name, route_info->interface.c_str(),
-            sizeof(listener.interface_name));
+    int ret = strcpy_s(listener.name, SYMBOLIC_NAME_LEN - 1, name.c_str());
+    if (ret < EOK) goto ERR;
+    ret = strcpy_s(listener.interface_name, INTERFACE_LEN - 1,
+                   route_info->interface.c_str());
+    if (ret < EOK) goto ERR;
 
     std::cout << "------------> " << route_info->interface << std::endl;
 
-    int ret = hc_listener_create(sock_, &listener);
+    ret = hc_listener_create(sock_, &listener);
 
     if (ret < 0) {
       std::cerr << "Error creating listener." << std::endl;
@@ -520,7 +540,7 @@ int ForwarderInterface::tryToCreateRoute(RouteInfo *route_info,
 #if 0  // not used
 void ForwarderInterface::checkRoutesLoop() {
   check_routes_timer_->expires_from_now(std::chrono::milliseconds(1000));
-  check_routes_timer_->async_wait([this](std::error_code ec) {
+  check_routes_timer_->async_wait([this](const std::error_code &ec) {
     if (ec) return;
     if (pending_add_route_counter_ == 0) checkRoutes();
   });
@@ -580,7 +600,7 @@ void ForwarderInterface::checkRoutes() {
         } else {
           // XXX This should be moved somewhere else
           getMainListener(
-              [this](std::error_code ec, uint32_t hicn_listen_port) {
+              [this](const std::error_code &ec, uint32_t hicn_listen_port) {
                 if (!ec)
                 {
                   hicn_listen_port_ = hicn_listen_port;
@@ -597,7 +617,7 @@ void ForwarderInterface::checkRoutes() {
         tryToConnectToForwarder();
       }
     private:
-      void doGetMainListener(std::error_code ec)
+      void doGetMainListener(const std::error_code &ec)
       {
         if (!ec)
         {
@@ -607,7 +627,7 @@ void ForwarderInterface::checkRoutes() {
           {
             // Since without the main listener of the forwarder the proxy cannot
             // work, we can stop the program here until we get the listener port.
-            std::cout << 
+            std::cout <<
                 "Could not retrieve main listener port from the forwarder. "
                 "Retrying.";
 
@@ -635,7 +655,7 @@ void ForwarderInterface::checkRoutes() {
         doTryToConnectToForwarder(std::make_error_code(std::errc(0)));
       }
 
-      void doTryToConnectToForwarder(std::error_code ec)
+      void doTryToConnectToForwarder(const std::error_code &ec)
       {
         if (!ec)
         {
@@ -673,4 +693,4 @@ void ForwarderInterface::checkRoutes() {
 constexpr uint32_t ForwarderInterface::REATTEMPT_DELAY_MS;
 constexpr uint32_t ForwarderInterface::MAX_REATTEMPT;
 
-}  // namespace hiperf
\ No newline at end of file
+}  // namespace hiperf
diff --git a/apps/hiperf/src/forwarder_interface.h b/apps/hiperf/src/forwarder_interface.h
index 7591ea257..e58989295 100644
--- a/apps/hiperf/src/forwarder_interface.h
+++ b/apps/hiperf/src/forwarder_interface.h
@@ -15,6 +15,8 @@
 
 #pragma once
 
+#include <hicn/transport/utils/noncopyable.h>
+
 extern "C" {
 #ifndef WITH_POLICY
 #define WITH_POLICY
@@ -27,14 +29,13 @@ extern "C" {
 #define ASIO_STANDALONE
 #endif
 #include <asio.hpp>
-
 #include <functional>
 #include <thread>
 #include <unordered_map>
 
 namespace hiperf {
 
-class ForwarderInterface {
+class ForwarderInterface : ::utils::NonCopyable {
   static const uint32_t REATTEMPT_DELAY_MS = 500;
   static const uint32_t MAX_REATTEMPT = 10;
 
@@ -68,10 +69,14 @@ class ForwarderInterface {
   };
 
  public:
-  ForwarderInterface(asio::io_service &io_service, ICallback *callback);
+  explicit ForwarderInterface(asio::io_service &io_service);
+  explicit ForwarderInterface(asio::io_service &io_service, ICallback *callback,
+                              forwarder_type_t fwd_type);
 
   ~ForwarderInterface();
 
+  void initForwarderInterface(ICallback *callback, forwarder_type_t fwd_type);
+
   State getState();
 
   void setState(State state);
@@ -88,11 +93,16 @@ class ForwarderInterface {
 
   void deleteFaceAndRoute(const RouteInfoPtr &route_info);
 
+  void setStrategy(std::string prefix, uint32_t prefix_len,
+                   std::string strategy);
+
   void close();
 
   uint16_t getHicnListenerPort() { return hicn_listen_port_; }
 
  private:
+  ForwarderInterface &operator=(const ForwarderInterface &other) = delete;
+
   int connectToForwarder();
 
   int checkListener();
@@ -123,6 +133,8 @@ class ForwarderInterface {
 
   State state_;
 
+  forwarder_type_t fwd_type_;
+
   /* Reattempt timer */
   asio::steady_timer timer_;
   unsigned num_reattempts;
diff --git a/apps/hiperf/src/main.cc b/apps/hiperf/src/main.cc
index b2d99c4a4..b69392de8 100644
--- a/apps/hiperf/src/main.cc
+++ b/apps/hiperf/src/main.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,13 +14,13 @@
  */
 
 #include <client.h>
-#include <server.h>
 #include <forwarder_interface.h>
+#include <server.h>
 
 namespace hiperf {
 
 void usage() {
-  std::cerr << "HIPERF - A tool for performing network throughput "
+  std::cerr << "HIPERF - Instrumentation tool for performing active network"
                "measurements with hICN"
             << std::endl;
   std::cerr << "usage: hiperf [-S|-C] [options] [prefix|name]" << std::endl;
@@ -34,19 +34,27 @@ void usage() {
   std::cerr << "-f\t<filename>\t\t\t"
             << "Log file" << std::endl;
   std::cerr << "-z\t<io_module>\t\t\t"
-            << "IO module to use. Default: hicnlight_module" << std::endl;
+            << "IO module to use. Default: hicnlightng_module" << std::endl;
+  std::cerr << "-F\t<conf_file>\t\t\t"
+            << "Path to optional configuration file for libtransport"
+            << std::endl;
+  std::cerr << "-a\t\t\t\t\t"
+            << "Enables data packet aggregation. "
+            << "Works only in RTC mode" << std::endl;
+  std::cerr << "-X\t<param>\t\t\t\t"
+            << "Set FEC params. Options are Rely_K#_N# or RS_K#_N#"
+            << std::endl;
 #endif
   std::cerr << std::endl;
   std::cerr << "SERVER SPECIFIC:" << std::endl;
   std::cerr << "-A\t<content_size>\t\t\t"
-               "Size of the content to publish. This "
-               "is not the size of the packet (see -s for it)."
-            << std::endl;
-  std::cerr << "-s\t<packet_size>\t\t\tSize of the payload of each data packet."
+               "Sends an application data unit in bytes that is published once "
+               "before exit"
             << std::endl;
+  std::cerr << "-s\t<packet_size>\t\t\tData packet payload size." << std::endl;
   std::cerr << "-r\t\t\t\t\t"
             << "Produce real content of <content_size> bytes" << std::endl;
-  std::cerr << "-m\t\t\t\t\t"
+  std::cerr << "-m\t<manifest_capacity>\t\t"
             << "Produce transport manifest" << std::endl;
   std::cerr << "-l\t\t\t\t\t"
             << "Start producing content upon the reception of the "
@@ -60,20 +68,17 @@ void usage() {
             << "String from which a 128-bit symmetric key will be "
                "derived for signing packets"
             << std::endl;
+  std::cerr << "-p\t<password>\t\t\t"
+            << "Password for p12 keystore" << std::endl;
   std::cerr << "-y\t<hash_algorithm>\t\t"
             << "Use the selected hash algorithm for "
-               "calculating manifest digests"
+               "computing manifest digests (default: SHA256)"
             << std::endl;
-  std::cerr << "-p\t<password>\t\t\t"
-            << "Password for p12 keystore" << std::endl;
   std::cerr << "-x\t\t\t\t\t"
-            << "Produce a content of <content_size>, then after downloading "
-               "it produce a new content of"
-            << "\n\t\t\t\t\t<content_size> without resetting "
-               "the suffix to 0."
-            << std::endl;
+            << "Produces application data units of size <content_size> "
+            << "without resetting the name suffix to 0." << std::endl;
   std::cerr << "-B\t<bitrate>\t\t\t"
-            << "Bitrate for RTC producer, to be used with the -R option."
+            << "RTC producer data bitrate, to be used with the -R option."
             << std::endl;
 #ifndef _WIN32
   std::cerr << "-I\t\t\t\t\t"
@@ -92,8 +97,8 @@ void usage() {
                "file containing the "
                "crypto material used for the TLS handshake"
             << std::endl;
-  std::cerr << "-G\t<port>\t\t\t"
-            << "input stream from localhost at the specified port" << std::endl;
+  std::cerr << "-G\t<port>\t\t\t\t"
+            << "Input stream from localhost at the specified port" << std::endl;
 #endif
   std::cerr << std::endl;
   std::cerr << "CLIENT SPECIFIC:" << std::endl;
@@ -105,6 +110,8 @@ void usage() {
             << std::endl;
   std::cerr << "-L\t<interest lifetime>\t\t"
             << "Set interest lifetime." << std::endl;
+  std::cerr << "-u\t<delay>\t\t\t\t"
+            << "Set max lifetime of unverified packets." << std::endl;
   std::cerr << "-M\t<input_buffer_size>\t\t"
             << "Size of consumer input buffer. If 0, reassembly of packets "
                "will be disabled."
@@ -127,17 +134,31 @@ void usage() {
   std::cerr << "-t\t\t\t\t\t"
                "Test mode, check if the client is receiving the "
                "correct data. This is an RTC specific option, to be "
-               "used with the -R (default false)"
+               "used with the -R (default: false)"
             << std::endl;
   std::cerr << "-P\t\t\t\t\t"
             << "Prefix of the producer where to do the handshake" << std::endl;
   std::cerr << "-j\t<relay_name>\t\t\t"
-            << "Publish the received content under the name relay_name."
+            << "Publish received content under the name relay_name."
                "This is an RTC specific option, to be "
-               "used with the -R (default false)"
+               "used with the -R (default: false)"
+            << std::endl;
+  std::cerr << "-g\t<port>\t\t\t\t"
+            << "Output stream to localhost at the specified port" << std::endl;
+  std::cerr << "-e\t<strategy>\t\t\t"
+            << "Enance the network with a realiability strategy. Options 1:"
+            << " unreliable, 2: rtx only, 3: fec only, "
+            << "4: delay based, 5: low rate, 6: low rate and best path "
+            << "7: low rate and replication, 8: low rate and best"
+            << " path/replication"
+            << "(default: 2 = rtx only) " << std::endl;
+  std::cerr << "-H\t\t\t\t\t"
+            << "Disable periodic print headers in stats report." << std::endl;
+  std::cerr << "-n\t<nb_iterations>\t\t\t"
+            << "Print the stats report <nb_iterations> times and exit.\n"
+            << "\t\t\t\t\tThis option limits the duration of the run to "
+               "<nb_iterations> * <stats_interval> milliseconds."
             << std::endl;
-  std::cerr << "-g\t<port>\t\t\t"
-            << "output stream to localhost at the specified port" << std::endl;
 }
 
 int main(int argc, char *argv[]) {
@@ -156,7 +177,7 @@ int main(int argc, char *argv[]) {
   char *log_file = nullptr;
   transport::interface::global_config::IoModuleConfiguration config;
   std::string conf_file;
-  config.name = "hicnlight_module";
+  config.name = "hicnlightng_module";
 
   // Consumer
   ClientConfiguration client_configuration;
@@ -166,10 +187,9 @@ int main(int argc, char *argv[]) {
 
   int opt;
 #ifndef _WIN32
-  while ((opt = getopt(
-              argc, argv,
-              "DSCf:b:d:W:RM:c:vA:s:rmlK:k:y:p:hi:xE:P:B:ItL:z:T:F:j:g:G:")) !=
-         -1) {
+  while ((opt = getopt(argc, argv,
+                       "DSCf:b:d:W:RM:c:vA:s:rm:lK:k:y:p:hi:xE:P:B:ItL:z:T:F:j:"
+                       "g:G:e:awHn:X:u:")) != -1) {
     switch (opt) {
       // Common
       case 'D': {
@@ -202,9 +222,11 @@ int main(int argc, char *argv[]) {
         break;
       }
 #else
-  while ((opt = getopt(argc, argv,
-                       "SCf:b:d:W:RM:c:vA:s:rmlK:k:y:p:hi:xB:E:P:tL:z:F:j:")) !=
-         -1) {
+  while (
+      (opt = getopt(
+           argc, argv,
+           "SCf:b:d:W:RM:c:vA:s:rm:lK:k:y:p:hi:xB:E:P:tL:z:F:j:e:awHn:X:u:")) !=
+      -1) {
     switch (opt) {
 #endif
       case 'f': {
@@ -216,6 +238,21 @@ int main(int argc, char *argv[]) {
         server_configuration.rtc_ = true;
         break;
       }
+      case 'a': {
+        client_configuration.aggregated_data_ = true;
+        server_configuration.aggregated_data_ = true;
+        break;
+      }
+      case 'X': {
+        client_configuration.fec_type_ = std::string(optarg);
+        server_configuration.fec_type_ = std::string(optarg);
+        break;
+      }
+      case 'w': {
+        client_configuration.packet_format_ = Packet::Format::HF_INET6_UDP;
+        server_configuration.packet_format_ = Packet::Format::HF_INET6_UDP;
+        break;
+      }
       case 'z': {
         config.name = optarg;
         break;
@@ -286,12 +323,27 @@ int main(int argc, char *argv[]) {
         options = 1;
         break;
       }
+      case 'u': {
+        client_configuration.unverified_delay_ = std::stoul(optarg);
+        options = 1;
+        break;
+      }
       case 'j': {
         client_configuration.relay_ = true;
         client_configuration.relay_name_ = Prefix(optarg);
         options = 1;
         break;
       }
+      case 'H': {
+        client_configuration.print_headers_ = false;
+        options = 1;
+        break;
+      }
+      case 'n': {
+        client_configuration.nb_iterations_ = std::stoul(optarg);
+        options = 1;
+        break;
+      }
       // Server specific
       case 'A': {
         server_configuration.download_size = std::stoul(optarg);
@@ -309,7 +361,7 @@ int main(int argc, char *argv[]) {
         break;
       }
       case 'm': {
-        server_configuration.manifest = true;
+        server_configuration.manifest = std::stoul(optarg);
         options = -1;
         break;
       }
@@ -324,18 +376,19 @@ int main(int argc, char *argv[]) {
         break;
       }
       case 'y': {
+        CryptoHashType hash_algorithm = CryptoHashType::SHA256;
         if (strncasecmp(optarg, "sha256", 6) == 0) {
-          server_configuration.hash_algorithm = CryptoHashType::SHA256;
+          hash_algorithm = CryptoHashType::SHA256;
         } else if (strncasecmp(optarg, "sha512", 6) == 0) {
-          server_configuration.hash_algorithm = CryptoHashType::SHA512;
+          hash_algorithm = CryptoHashType::SHA512;
         } else if (strncasecmp(optarg, "blake2b512", 10) == 0) {
-          server_configuration.hash_algorithm = CryptoHashType::BLAKE2B512;
+          hash_algorithm = CryptoHashType::BLAKE2B512;
         } else if (strncasecmp(optarg, "blake2s256", 10) == 0) {
-          server_configuration.hash_algorithm = CryptoHashType::BLAKE2S256;
+          hash_algorithm = CryptoHashType::BLAKE2S256;
         } else {
-          std::cerr << "Ignored unknown hash algorithm. Using SHA 256."
-                    << std::endl;
+          std::cerr << "Unknown hash algorithm. Using SHA 256." << std::endl;
         }
+        server_configuration.hash_algorithm_ = hash_algorithm;
         options = -1;
         break;
       }
@@ -361,6 +414,11 @@ int main(int argc, char *argv[]) {
         server_configuration.secure_ = true;
         break;
       }
+      case 'e': {
+        client_configuration.recovery_strategy_ = std::stoul(optarg);
+        options = 1;
+        break;
+      }
       case 'h':
       default:
         usage();
@@ -430,6 +488,13 @@ int main(int argc, char *argv[]) {
   transport::interface::global_config::parseConfigurationFile(conf_file);
 
   if (role > 0) {
+    // set forwarder type
+    client_configuration.forwarder_type_ = UNDEFINED;
+    if (config.name.compare("hicnlightng_module") == 0)
+      client_configuration.forwarder_type_ = HICNLIGHT;
+    else if (config.name.compare("hicnlightng_module") == 0)
+      client_configuration.forwarder_type_ = HICNLIGHT_NG;
+
     HIperfClient c(client_configuration);
     if (c.setup() != ERROR_SETUP) {
       c.run();
diff --git a/apps/hiperf/src/server.cc b/apps/hiperf/src/server.cc
index 968d42e2c..7101e7a4a 100644
--- a/apps/hiperf/src/server.cc
+++ b/apps/hiperf/src/server.cc
@@ -21,7 +21,7 @@ namespace hiperf {
  * Hiperf server class: configure and setup an hicn producer following the
  * ServerConfiguration.
  */
-class HIperfServer::Impl {
+class HIperfServer::Impl : public ProducerSocket::Callback {
   const std::size_t log2_content_object_buffer_size = 8;
 
  public:
@@ -35,11 +35,8 @@ class HIperfServer::Impl {
         mask_((std::uint16_t)(1 << log2_content_object_buffer_size) - 1),
         last_segment_(0),
 #ifndef _WIN32
-        ptr_last_segment_(&last_segment_),
         input_(io_service_),
         rtc_running_(false),
-#else
-        ptr_last_segment_(&last_segment_),
 #endif
         flow_name_(configuration_.name.getName()),
         socket_(io_service_),
@@ -54,14 +51,16 @@ class HIperfServer::Impl {
 #endif
 
     for (int i = 0; i < (1 << log2_content_object_buffer_size); i++) {
-      content_objects_[i] = ContentObject::Ptr(
-          new ContentObject(conf.name.getName(), HF_INET6_TCP, 0,
-                            (const uint8_t *)buffer.data(), buffer.size()));
+      content_objects_[i] = ContentObject::Ptr(new ContentObject(
+          configuration_.name.getName(), configuration_.packet_format_, 0,
+          (const uint8_t *)buffer.data(), buffer.size()));
       content_objects_[i]->setLifetime(
           default_values::content_object_expiry_time);
     }
   }
 
+  virtual ~Impl() {}
+
   void virtualProcessInterest(ProducerSocket &p, const Interest &interest) {
     content_objects_[content_objects_index_ & mask_]->setName(
         interest.getName());
@@ -91,16 +90,14 @@ class HIperfServer::Impl {
 
     if (suffix == 0) {
       last_segment_ = 0;
-      ptr_last_segment_ = &last_segment_;
       unsatisfied_interests_.clear();
     }
 
-    // The suffix will either be the one from the received interest or the
-    // smallest suffix of a previous interest not satisfed
+    // The suffix will either come from the received interest or will be set to
+    // the smallest suffix of a previous interest not satisfied
     if (!unsatisfied_interests_.empty()) {
-      auto it =
-          std::lower_bound(unsatisfied_interests_.begin(),
-                           unsatisfied_interests_.end(), *ptr_last_segment_);
+      auto it = std::lower_bound(unsatisfied_interests_.begin(),
+                                 unsatisfied_interests_.end(), last_segment_);
       if (it != unsatisfied_interests_.end()) {
         suffix = *it;
       }
@@ -121,27 +118,28 @@ class HIperfServer::Impl {
     b->append(configuration_.download_size);
     uint32_t total;
 
-    utils::TimePoint t0 = utils::SteadyClock::now();
+    utils::SteadyTime::TimePoint t0 = utils::SteadyTime::Clock::now();
     total = p.produceStream(content_name, std::move(b),
                             !configuration_.multiphase_produce_, suffix);
-    utils::TimePoint t1 = utils::SteadyClock::now();
+    utils::SteadyTime::TimePoint t1 = utils::SteadyTime::Clock::now();
 
-    std::cout
-        << "Written " << total
-        << " data packets in output buffer (Segmentation time: "
-        << std::chrono::duration_cast<utils::Microseconds>(t1 - t0).count()
-        << " us)" << std::endl;
+    std::cout << "Written " << total
+              << " data packets in output buffer (Segmentation time: "
+              << utils::SteadyTime::getDurationUs(t0, t1).count() << " us)"
+              << std::endl;
   }
 
   void produceContentAsync(ProducerSocket &p, Name content_name,
                            uint32_t suffix) {
-    auto b = utils::MemBuf::create(configuration_.download_size);
-    std::memset(b->writableData(), '?', configuration_.download_size);
-    b->append(configuration_.download_size);
-
-    p.asyncProduce(content_name, std::move(b),
-                   !configuration_.multiphase_produce_, suffix,
-                   &ptr_last_segment_);
+    produce_thread_.add([this, suffix, content_name]() {
+      auto b = utils::MemBuf::create(configuration_.download_size);
+      std::memset(b->writableData(), '?', configuration_.download_size);
+      b->append(configuration_.download_size);
+
+      last_segment_ = suffix + producer_socket_->produceStream(
+                                   content_name, std::move(b),
+                                   !configuration_.multiphase_produce_, suffix);
+    });
   }
 
   void cacheMiss(ProducerSocket &p, const Interest &interest) {
@@ -156,27 +154,22 @@ class HIperfServer::Impl {
                           std::placeholders::_1, std::placeholders::_2));
   }
 
-  std::shared_ptr<Identity> getProducerIdentity(std::string &keystore_path,
-                                                std::string &keystore_pwd,
-                                                CryptoHashType &hash_type) {
-    if (access(keystore_path.c_str(), F_OK) != -1) {
-      return std::make_shared<Identity>(keystore_path, keystore_pwd, hash_type);
-    }
-    return std::make_shared<Identity>(keystore_path, keystore_pwd,
-                                      CryptoSuite::RSA_SHA256, 1024, 365,
-                                      "producer-test");
+  void produceError(const std::error_code &err) noexcept override {
+    std::cerr << "Error from producer transport: " << err.message()
+              << std::endl;
+    producer_socket_->stop();
+    io_service_.stop();
   }
 
   int setup() {
     int ret;
     int production_protocol;
+    std::shared_ptr<Signer> signer = std::make_shared<VoidSigner>();
 
     if (configuration_.secure_) {
-      auto identity = getProducerIdentity(configuration_.keystore_name,
-                                          configuration_.keystore_password,
-                                          configuration_.hash_algorithm);
       producer_socket_ = std::make_unique<P2PSecureProducerSocket>(
-          configuration_.rtc_, identity);
+          configuration_.rtc_, configuration_.keystore_name,
+          configuration_.keystore_password);
     } else {
       if (!configuration_.rtc_) {
         production_protocol = ProductionProtocolAlgorithms::BYTE_STREAM;
@@ -188,36 +181,79 @@ class HIperfServer::Impl {
     }
 
     if (producer_socket_->setSocketOption(
+            ProducerCallbacksOptions::PRODUCER_CALLBACK, this) ==
+        SOCKET_OPTION_NOT_SET) {
+      std::cerr << "Failed to set producer callback." << std::endl;
+      return ERROR_SETUP;
+    }
+
+    if (producer_socket_->setSocketOption(
             GeneralTransportOptions::MAKE_MANIFEST, configuration_.manifest) ==
         SOCKET_OPTION_NOT_SET) {
       return ERROR_SETUP;
     }
 
+    if (producer_socket_->setSocketOption(
+            GeneralTransportOptions::HASH_ALGORITHM,
+            configuration_.hash_algorithm_) == SOCKET_OPTION_NOT_SET) {
+      return ERROR_SETUP;
+    }
+
+    if (producer_socket_->setSocketOption(PACKET_FORMAT,
+                                          configuration_.packet_format_) ==
+        SOCKET_OPTION_NOT_SET) {
+      std::cerr << "ERROR -- Impossible to set the packet format." << std::endl;
+      return ERROR_SETUP;
+    }
+
     if (!configuration_.passphrase.empty()) {
-      std::shared_ptr<Signer> signer = std::make_shared<SymmetricSigner>(
-          CryptoSuite::HMAC_SHA256, configuration_.passphrase);
-      producer_socket_->setSocketOption(GeneralTransportOptions::SIGNER,
-                                        signer);
+      signer = std::make_shared<SymmetricSigner>(CryptoSuite::HMAC_SHA256,
+                                                 configuration_.passphrase);
     }
 
     if (!configuration_.keystore_name.empty()) {
-      auto identity = getProducerIdentity(configuration_.keystore_name,
-                                          configuration_.keystore_password,
-                                          configuration_.hash_algorithm);
-      std::shared_ptr<Signer> signer = identity->getSigner();
-      producer_socket_->setSocketOption(GeneralTransportOptions::SIGNER,
-                                        signer);
+      signer = std::make_shared<AsymmetricSigner>(
+          configuration_.keystore_name, configuration_.keystore_password);
+    }
+
+    producer_socket_->setSocketOption(GeneralTransportOptions::SIGNER, signer);
+
+    // Compute maximum payload size
+    Packet::Format format = PayloadSize::getFormatFromName(
+        configuration_.name.getName(), !configuration_.manifest);
+    payload_size_max_ = PayloadSize(format).getPayloadSizeMax(
+        configuration_.rtc_ ? RTC_HEADER_SIZE : 0,
+        configuration_.fec_type_.empty() ? 0 : FEC_HEADER_MAX_SIZE,
+        !configuration_.manifest ? signer->getSignatureFieldSize() : 0);
+
+    if (configuration_.payload_size_ > payload_size_max_) {
+      std::cerr << "WARNING: Payload has size " << configuration_.payload_size_
+                << ", maximum is " << payload_size_max_
+                << ". Payload will be truncated to fit." << std::endl;
+    }
+
+    if (configuration_.rtc_) {
+      ret = producer_socket_->setSocketOption(
+          RtcTransportOptions::AGGREGATED_DATA,
+          configuration_.aggregated_data_);
+
+      if (ret == SOCKET_OPTION_NOT_SET) {
+        return ERROR_SETUP;
+      }
+    }
+
+    if (configuration_.rtc_) {
+      ret = producer_socket_->setSocketOption(GeneralTransportOptions::FEC_TYPE,
+                                              configuration_.fec_type_);
+
+      if (ret == SOCKET_OPTION_NOT_SET) {
+        return ERROR_SETUP;
+      }
     }
 
-    uint32_t rtc_header_size = 0;
-    if (configuration_.rtc_) rtc_header_size = 12;
-    producer_socket_->setSocketOption(
-        GeneralTransportOptions::DATA_PACKET_SIZE,
-        (uint32_t)(
-            configuration_.payload_size_ + rtc_header_size +
-            (configuration_.name.getAddressFamily() == AF_INET ? 40 : 60)));
     producer_socket_->registerPrefix(configuration_.name);
     producer_socket_->connect();
+    producer_socket_->start();
 
     if (configuration_.rtc_) {
       std::cout << "Running RTC producer: the prefix length will be ignored."
@@ -239,6 +275,13 @@ class HIperfServer::Impl {
         return ERROR_SETUP;
       }
 
+      if (producer_socket_->setSocketOption(
+              GeneralTransportOptions::MAX_SEGMENT_SIZE,
+              static_cast<uint32_t>(configuration_.payload_size_)) ==
+          SOCKET_OPTION_NOT_SET) {
+        return ERROR_SETUP;
+      }
+
       if (!configuration_.live_production) {
         produceContent(*producer_socket_, configuration_.name.getName(), 0);
       } else {
@@ -283,7 +326,7 @@ class HIperfServer::Impl {
   void receiveStream() {
     socket_.async_receive_from(
         asio::buffer(recv_buffer_.first, recv_buffer_.second), remote_,
-        [this](std::error_code ec, std::size_t length) {
+        [this](const std::error_code &ec, std::size_t length) {
           if (ec) return;
           sendRTCContentFromStream(recv_buffer_.first, length);
           receiveStream();
@@ -296,9 +339,8 @@ class HIperfServer::Impl {
     // this is used to compute the data packet delay
     // Used only for performance evaluation
     // It requires clock synchronization between producer and consumer
-    uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                       std::chrono::system_clock::now().time_since_epoch())
-                       .count();
+    uint64_t now = utils::SystemTime::nowMs().count();
+
     uint8_t *start = (uint8_t *)payload->writableData();
     std::memcpy(start, &now, sizeof(uint64_t));
     std::memcpy(start + sizeof(uint64_t), buff, len);
@@ -306,7 +348,7 @@ class HIperfServer::Impl {
                                       len + sizeof(uint64_t));
   }
 
-  void sendRTCContentObjectCallback(std::error_code ec) {
+  void sendRTCContentObjectCallback(const std::error_code &ec) {
     if (ec) return;
     rtc_timer_.expires_from_now(
         configuration_.production_rate_.getMicrosecondsForPacket(
@@ -319,18 +361,17 @@ class HIperfServer::Impl {
     // this is used to compute the data packet delay
     // Used only for performance evaluation
     // It requires clock synchronization between producer and consumer
-    uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                       std::chrono::system_clock::now().time_since_epoch())
-                       .count();
+    uint64_t now = utils::SystemTime::nowMs().count();
 
     std::memcpy(payload->writableData(), &now, sizeof(uint64_t));
 
-    producer_socket_->produceDatagram(
-        flow_name_, payload->data(),
-        payload->length() < 1400 ? payload->length() : 1400);
+    producer_socket_->produceDatagram(flow_name_, payload->data(),
+                                      payload->length() < payload_size_max_
+                                          ? payload->length()
+                                          : payload_size_max_);
   }
 
-  void sendRTCContentObjectCallbackWithTrace(std::error_code ec) {
+  void sendRTCContentObjectCallbackWithTrace(const std::error_code &ec) {
     if (ec) return;
 
     auto payload =
@@ -342,14 +383,11 @@ class HIperfServer::Impl {
     // this is used to compute the data packet delay
     // used only for performance evaluation
     // it requires clock synchronization between producer and consumer
-    uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                       std::chrono::system_clock::now().time_since_epoch())
-                       .count();
-
+    uint64_t now = utils::SystemTime::nowMs().count();
     std::memcpy(payload->writableData(), &now, sizeof(uint64_t));
 
     if (packet_len > payload->length()) packet_len = payload->length();
-    if (packet_len > 1400) packet_len = 1400;
+    if (packet_len > payload_size_max_) packet_len = payload_size_max_;
 
     producer_socket_->produceDatagram(flow_name_, payload->data(), packet_len);
 
@@ -450,13 +488,13 @@ class HIperfServer::Impl {
                       std::placeholders::_1));
       } else if (configuration_.input_stream_mode_) {
         rtc_running_ = true;
-        // crate socket
+        // create socket
         remote_ = asio::ip::udp::endpoint(
             asio::ip::address::from_string("127.0.0.1"), configuration_.port_);
         socket_.open(asio::ip::udp::v4());
         socket_.bind(remote_);
-        recv_buffer_.first = (uint8_t *)malloc(1500);
-        recv_buffer_.second = 1500;
+        recv_buffer_.first = (uint8_t *)malloc(HIPERF_MTU);
+        recv_buffer_.second = HIPERF_MTU;
         receiveStream();
       } else {
         rtc_running_ = true;
@@ -490,8 +528,9 @@ class HIperfServer::Impl {
   std::uint16_t content_objects_index_;
   std::uint16_t mask_;
   std::uint32_t last_segment_;
-  std::uint32_t *ptr_last_segment_;
   std::unique_ptr<ProducerSocket> producer_socket_;
+  ::utils::EventThread produce_thread_;
+  std::size_t payload_size_max_;
 #ifndef _WIN32
   asio::posix::stream_descriptor input_;
   asio::streambuf input_buffer_;
@@ -507,6 +546,20 @@ HIperfServer::HIperfServer(const ServerConfiguration &conf) {
   impl_ = new Impl(conf);
 }
 
+HIperfServer::HIperfServer(HIperfServer &&other) {
+  impl_ = other.impl_;
+  other.impl_ = nullptr;
+}
+
+HIperfServer &HIperfServer::operator=(HIperfServer &&other) {
+  if (this != &other) {
+    impl_ = other.impl_;
+    other.impl_ = nullptr;
+  }
+
+  return *this;
+}
+
 HIperfServer::~HIperfServer() { delete impl_; }
 
 int HIperfServer::setup() { return impl_->setup(); }
diff --git a/apps/hiperf/src/server.h b/apps/hiperf/src/server.h
index 05407a807..73ac72123 100644
--- a/apps/hiperf/src/server.h
+++ b/apps/hiperf/src/server.h
@@ -22,6 +22,9 @@ namespace hiperf {
 class HIperfServer {
  public:
   HIperfServer(const ServerConfiguration &conf);
+  HIperfServer(HIperfServer &&other);
+  HIperfServer &operator=(HIperfServer &&other);
+
   ~HIperfServer();
   int setup();
   void run();
diff --git a/apps/http-proxy/CMakeLists.txt b/apps/http-proxy/CMakeLists.txt
index 66b9c1bab..dbe9bc51c 100644
--- a/apps/http-proxy/CMakeLists.txt
+++ b/apps/http-proxy/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,8 +11,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
-set(CMAKE_CXX_STANDARD 14)
+##############################################################
+# Compiler options
+##############################################################
+set(COMPILER_OPTIONS
+  ${DEFAULT_COMPILER_OPTIONS}
+)
 
 # -Wno-c99-designator issue
 #
@@ -22,20 +26,22 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
   EXECUTE_PROCESS( COMMAND ${CMAKE_CXX_COMPILER} --version OUTPUT_VARIABLE clang_full_version_string )
   string (REGEX REPLACE ".*clang version ([0-9]+\\.[0-9]+).*" "\\1" CLANG_VERSION_STRING ${clang_full_version_string})
   if (CLANG_VERSION_STRING VERSION_GREATER_EQUAL 11)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-c99-designator")
+    list(APPEND COMPILER_OPTIONS
+      "-Wno-c99-designator"
+    )
   endif()
 endif()
 
-set(CMAKE_MODULE_PATH
-  ${CMAKE_MODULE_PATH}
-  "${CMAKE_SOURCE_DIR}/cmake/Modules/"
-)
 
-if (NOT CMAKE_BUILD_TYPE)
-  message(STATUS "${PROJECT_NAME}: No build type selected, default to Release")
-  set(CMAKE_BUILD_TYPE "Release")
-endif ()
+##############################################################
+# Includes subdirectory
+##############################################################
+add_subdirectory(includes/hicn/http-proxy)
+
 
+##############################################################
+# Source files
+##############################################################
 set(LIB_SOURCE_FILES
   src/http_session.cc
   src/http_proxy.cc
@@ -48,41 +54,45 @@ set(APP_SOURCE_FILES
   main.cc
 )
 
-add_subdirectory(includes/hicn/http-proxy)
-set(LIBHTTP_PROXY hicnhttpproxy)
-set(LIBHTTP_PROXY_STATIC ${LIBHTTP_PROXY}.static)
-
-list(APPEND COMPILER_DEFINITIONS
-  -DWITH_POLICY
-)
-
+##############################################################
+# Libraries to link
+##############################################################
 list(APPEND HTTP_PROXY_LIBRARIES
-  ${LIBTRANSPORT_LIBRARIES}
-  ${LIBHICNCTRL_LIBRARIES}
-  ${LIBHICN_LIBRARIES}
-  ${OPENSSL_LIBRARIES}
-  ${CMAKE_THREAD_LIBS_INIT}
+  PUBLIC ${LIBTRANSPORT_LIBRARIES}
+  PUBLIC ${LIBHICNCTRL_LIBRARIES}
+  PUBLIC ${LIBHICN_LIBRARIES}
+  PRIVATE ${CMAKE_THREAD_LIBS_INIT}
 )
 
+
+##############################################################
+# Build http proxy library
+##############################################################
 build_library(${LIBHTTP_PROXY}
   STATIC
   SOURCES ${LIB_SOURCE_FILES}
   LINK_LIBRARIES ${HTTP_PROXY_LIBRARIES}
   DEPENDS ${DEPENDENCIES}
   INSTALL_HEADERS ${LIBPROXY_TO_INSTALL_HEADER_FILES}
-  INCLUDE_DIRS ${LIBTRANSPORT_INCLUDE_DIRS} ${LIBHICNCTRL_INCLUDE_DIRS} ${LIBPROXY_INCLUDE_DIRS}
+  INCLUDE_DIRS
+    PUBLIC
+      $<BUILD_INTERFACE:${LIBPROXY_INCLUDE_DIRS}>
+      $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
   COMPONENT ${HICN_APPS}
   LINK_FLAGS ${LINK_FLAGS}
-  DEFINITIONS ${COMPILER_DEFINITIONS}
+  COMPILE_OPTIONS ${COMPILER_OPTIONS}
 )
 
+
+##############################################################
+# Build http proxy executable
+##############################################################
 if (NOT DISABLE_EXECUTABLES)
   build_executable(${HTTP_PROXY}
     SOURCES ${APP_SOURCE_FILES}
     LINK_LIBRARIES ${LIBHTTP_PROXY_STATIC}
     DEPENDS ${LIBHTTP_PROXY_STATIC}
     COMPONENT ${HICN_APPS}
-    DEFINITIONS ${COMPILER_DEFINITIONS}
     LINK_FLAGS ${LINK_FLAGS}
   )
 endif ()
diff --git a/apps/http-proxy/includes/hicn/http-proxy/CMakeLists.txt b/apps/http-proxy/includes/hicn/http-proxy/CMakeLists.txt
index 5cc80a168..18f5704d1 100644
--- a/apps/http-proxy/includes/hicn/http-proxy/CMakeLists.txt
+++ b/apps/http-proxy/includes/hicn/http-proxy/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -24,7 +24,7 @@ list(APPEND HEADER_FILES
 set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
 
 set(LIBPROXY_INCLUDE_DIRS
-  ${CMAKE_CURRENT_SOURCE_DIR}/../.. ""
+  ${CMAKE_CURRENT_SOURCE_DIR}/../..
   CACHE INTERNAL
   "" FORCE
 )
@@ -34,4 +34,3 @@ set(LIBPROXY_TO_INSTALL_HEADER_FILES
   CACHE INTERNAL
   "" FORCE
 )
-
diff --git a/apps/http-proxy/includes/hicn/http-proxy/forwarder_config.h b/apps/http-proxy/includes/hicn/http-proxy/forwarder_config.h
index e02b9d9a7..935b85e78 100644
--- a/apps/http-proxy/includes/hicn/http-proxy/forwarder_config.h
+++ b/apps/http-proxy/includes/hicn/http-proxy/forwarder_config.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -60,7 +60,7 @@ class ForwarderConfig {
     doTryToConnectToForwarder(std::make_error_code(std::errc(0)));
   }
 
-  void doTryToConnectToForwarder(std::error_code ec) {
+  void doTryToConnectToForwarder(const std::error_code& ec) {
     if (!ec) {
       // ec == 0 --> timer expired
       int ret = forwarder_interface_.connectToForwarder();
@@ -84,7 +84,7 @@ class ForwarderConfig {
     }
   }
 
-  void doGetMainListener(std::error_code ec) {
+  void doGetMainListener(const std::error_code& ec) {
     if (!ec) {
       // ec == 0 --> timer expired
       int ret = forwarder_interface_.getMainListenerPort();
@@ -114,7 +114,7 @@ class ForwarderConfig {
   TRANSPORT_ALWAYS_INLINE bool parseHicnHeader(std::string& header,
                                                Callback&& callback) {
     std::stringstream ss(header);
-    route_info_t* ret = new route_info_t();
+    RouteInfoPtr ret = std::make_shared<route_info_t>();
     std::string port_string;
 
     while (ss.good()) {
@@ -174,9 +174,9 @@ class ForwarderConfig {
         ret->family = AF_INET;
         std::string _prefix = ret->route_addr;
         forwarder_interface_.createFaceAndRoute(
-            RouteInfoPtr(ret), [callback = std::forward<Callback>(callback),
-                                configured_prefix = std::move(_prefix)](
-                                   uint32_t route_id, bool result) {
+            std::move(ret), [callback = std::forward<Callback>(callback),
+                             configured_prefix = std::move(_prefix)](
+                                uint32_t route_id, bool result) {
               callback(result, configured_prefix);
             });
 
diff --git a/apps/http-proxy/includes/hicn/http-proxy/forwarder_interface.h b/apps/http-proxy/includes/hicn/http-proxy/forwarder_interface.h
index 54941a4ba..1741aedc6 100644
--- a/apps/http-proxy/includes/hicn/http-proxy/forwarder_interface.h
+++ b/apps/http-proxy/includes/hicn/http-proxy/forwarder_interface.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/apps/http-proxy/includes/hicn/http-proxy/http_1x_message_fast_parser.h b/apps/http-proxy/includes/hicn/http-proxy/http_1x_message_fast_parser.h
index 7c035c83b..87a5c7d4e 100644
--- a/apps/http-proxy/includes/hicn/http-proxy/http_1x_message_fast_parser.h
+++ b/apps/http-proxy/includes/hicn/http-proxy/http_1x_message_fast_parser.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/apps/http-proxy/includes/hicn/http-proxy/http_proxy.h b/apps/http-proxy/includes/hicn/http-proxy/http_proxy.h
index a4139a620..efb9f850e 100644
--- a/apps/http-proxy/includes/hicn/http-proxy/http_proxy.h
+++ b/apps/http-proxy/includes/hicn/http-proxy/http_proxy.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -22,7 +22,9 @@
 #include "http_session.h"
 #include "icn_receiver.h"
 
+#ifndef ASIO_STANDALONE
 #define ASIO_STANDALONE
+#endif
 #include <asio.hpp>
 #include <asio/version.hpp>
 #include <unordered_set>
@@ -50,9 +52,9 @@ class TcpListener {
   void doAccept() {
 #if ((ASIO_VERSION / 100 % 1000) >= 12)
     acceptor_.async_accept(
-        [this](std::error_code ec, asio::ip::tcp::socket socket) {
+        [this](const std::error_code& ec, asio::ip::tcp::socket socket) {
 #else
-    acceptor_.async_accept(socket_, [this](std::error_code ec) {
+    acceptor_.async_accept(socket_, [this](const std::error_code& ec) {
       auto socket = std::move(socket_);
 #endif
           if (!ec) {
diff --git a/apps/http-proxy/includes/hicn/http-proxy/http_session.h b/apps/http-proxy/includes/hicn/http-proxy/http_session.h
index f4a3dbdee..ee9380a8c 100644
--- a/apps/http-proxy/includes/hicn/http-proxy/http_session.h
+++ b/apps/http-proxy/includes/hicn/http-proxy/http_session.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -17,13 +17,12 @@
 
 #include <hicn/transport/core/packet.h>
 
-#include "http_1x_message_fast_parser.h"
-
-#define ASIO_STANDALONE
 #include <asio.hpp>
 #include <deque>
 #include <functional>
 
+#include "http_1x_message_fast_parser.h"
+
 namespace transport {
 
 using asio::ip::tcp;
@@ -98,7 +97,7 @@ class HTTPSession {
   bool checkConnected();
 
  private:
-  void handleRead(std::error_code ec, std::size_t length);
+  void handleRead(const std::error_code &ec, std::size_t length);
   void tryReconnection();
   void startConnectionTimer();
   void handleDeadline(const std::error_code &ec);
diff --git a/apps/http-proxy/includes/hicn/http-proxy/icn_receiver.h b/apps/http-proxy/includes/hicn/http-proxy/icn_receiver.h
index 780037665..ab90fab07 100644
--- a/apps/http-proxy/includes/hicn/http-proxy/icn_receiver.h
+++ b/apps/http-proxy/includes/hicn/http-proxy/icn_receiver.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+#include <hicn/http-proxy/http_session.h>
 #include <hicn/transport/core/prefix.h>
 #include <hicn/transport/interfaces/publication_options.h>
 #include <hicn/transport/interfaces/socket_producer.h>
@@ -23,8 +24,6 @@
 #include <cstring>
 #include <queue>
 #include <utility>
-
-#include <hicn/http-proxy/http_session.h>
 //#include "http_session.h"
 
 namespace transport {
diff --git a/apps/http-proxy/includes/hicn/http-proxy/utils.h b/apps/http-proxy/includes/hicn/http-proxy/utils.h
index d87c796d0..0df24dfd9 100644
--- a/apps/http-proxy/includes/hicn/http-proxy/utils.h
+++ b/apps/http-proxy/includes/hicn/http-proxy/utils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -35,14 +35,13 @@ TRANSPORT_ALWAYS_INLINE std::string generatePrefix(
   str += pos;
 
   uint32_t locator_hash = utils::hash::fnv32_buf(str, strlen(str));
+  uint16_t* word = (uint16_t*)&locator_hash;
 
   std::stringstream stream;
   stream << first_ipv6_word << ":0";
 
-  for (uint16_t* word = (uint16_t*)&locator_hash;
-       std::size_t(word) < (std::size_t(&locator_hash) + sizeof(locator_hash));
-       word++) {
-    stream << ":" << std::hex << *word;
+  for (std::size_t i = 0; i < sizeof(locator_hash) / 2; i++) {
+    stream << ":" << std::hex << word[i];
   }
 
   stream << "::";
diff --git a/apps/http-proxy/main.cc b/apps/http-proxy/main.cc
index d9c29ecde..9bd97e02e 100644
--- a/apps/http-proxy/main.cc
+++ b/apps/http-proxy/main.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -139,7 +139,6 @@ int main(int argc, char** argv) {
       case 'h':
       default:
         return usage(argv[0]);
-        break;
     }
   }
 
diff --git a/apps/http-proxy/src/forwarder_interface.cc b/apps/http-proxy/src/forwarder_interface.cc
index c2448de9a..1c034f60f 100644
--- a/apps/http-proxy/src/forwarder_interface.cc
+++ b/apps/http-proxy/src/forwarder_interface.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -163,7 +163,7 @@ void ForwarderInterface::internalCreateFaceAndRoute(RouteInfoPtr route_info,
     max_try--;
     timer->expires_from_now(std::chrono::milliseconds(500));
     timer->async_wait([this, _route_info = std::move(route_info), max_try,
-                       timer, callback](std::error_code ec) {
+                       timer, callback](const std::error_code &ec) {
       if (ec) return;
       internalCreateFaceAndRoute(std::move(_route_info), max_try, timer,
                                  std::move(callback));
diff --git a/apps/http-proxy/src/http_1x_message_fast_parser.cc b/apps/http-proxy/src/http_1x_message_fast_parser.cc
index 4b6b78d55..e97c33161 100644
--- a/apps/http-proxy/src/http_1x_message_fast_parser.cc
+++ b/apps/http-proxy/src/http_1x_message_fast_parser.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/apps/http-proxy/src/http_proxy.cc b/apps/http-proxy/src/http_proxy.cc
index 2040f7cfa..5abe8780f 100644
--- a/apps/http-proxy/src/http_proxy.cc
+++ b/apps/http-proxy/src/http_proxy.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -36,7 +36,7 @@ class HTTPClientConnectionCallback : interface::ConsumerSocket::ReadCallback {
       : tcp_receiver_(tcp_receiver),
         thread_(thread),
         prefix_hash_(tcp_receiver_.prefix_hash_),
-        consumer_(TransportProtocolAlgorithms::RAAQM, thread_.getIoService()),
+        consumer_(TransportProtocolAlgorithms::RAAQM, thread_),
         session_(nullptr),
         current_size_(0) {
     consumer_.setSocketOption(ConsumerCallbacksOptions::READ_CALLBACK, this);
@@ -69,8 +69,8 @@ class HTTPClientConnectionCallback : interface::ConsumerSocket::ReadCallback {
             std::uint16_t remote_port = socket.remote_endpoint().port();
             TRANSPORT_LOG_INFO << "Client " << remote_address << ":"
                                << remote_port << "disconnected.";
-          } catch (std::system_error& e) {
-            // Do nothing
+          } catch (asio::system_error& e) {
+            TRANSPORT_LOG_INFO << "Client disconnected.";
           }
 
           consumer_.stop();
@@ -191,7 +191,7 @@ class HTTPClientConnectionCallback : interface::ConsumerSocket::ReadCallback {
     session_->send(_buffer, []() {});
   }
 
-  void readError(const std::error_code ec) noexcept {
+  void readError(const std::error_code& ec) noexcept {
     TRANSPORT_LOG_ERROR
         << "Error reading from hicn consumer socket. Closing session.";
     session_->close();
@@ -265,7 +265,7 @@ TcpReceiver::TcpReceiver(std::uint16_t port, const std::string& prefix,
       prefix_hash_(generatePrefix(prefix_, ipv6_first_word_)),
       forwarder_config_(
           thread_.getIoService(),
-          [this](std::error_code ec) {
+          [this](const std::error_code& ec) {
             if (!ec) {
               listener_.doAccept();
               for (int i = 0; i < 10; i++) {
diff --git a/apps/http-proxy/src/http_session.cc b/apps/http-proxy/src/http_session.cc
index 84c814cbd..870f188cd 100644
--- a/apps/http-proxy/src/http_session.cc
+++ b/apps/http-proxy/src/http_session.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -92,7 +92,7 @@ void HTTPSession::send(const uint8_t *packet, std::size_t len,
   io_service_.dispatch([this, packet, len, content_sent]() {
     asio::async_write(socket_, asio::buffer(packet, len),
                       [content_sent = std::move(content_sent)](
-                          std::error_code ec, std::size_t /*length*/) {
+                          const std::error_code &ec, std::size_t /*length*/) {
                         if (!ec) {
                           content_sent();
                         }
@@ -131,7 +131,7 @@ void HTTPSession::doWrite() {
   auto &buffer = write_msgs_.front().first;
 
   asio::async_write(socket_, asio::buffer(buffer->data(), buffer->length()),
-                    [this](std::error_code ec, std::size_t length) {
+                    [this](const std::error_code &ec, std::size_t length) {
                       if (TRANSPORT_EXPECT_FALSE(!ec)) {
                         write_msgs_.front().second();
                         write_msgs_.pop_front();
@@ -142,7 +142,7 @@ void HTTPSession::doWrite() {
                     });
 }  // namespace transport
 
-void HTTPSession::handleRead(std::error_code ec, std::size_t length) {
+void HTTPSession::handleRead(const std::error_code &ec, std::size_t length) {
   if (TRANSPORT_EXPECT_TRUE(!ec)) {
     content_length_ -= length;
     const uint8_t *buffer =
@@ -207,7 +207,7 @@ void HTTPSession::doReadBody(std::size_t body_size,
 void HTTPSession::doReadChunkedHeader() {
   asio::async_read_until(
       socket_, input_buffer_, "\r\n",
-      [this](std::error_code ec, std::size_t length) {
+      [this](const std::error_code &ec, std::size_t length) {
         if (TRANSPORT_EXPECT_TRUE(!ec)) {
           const uint8_t *buffer =
               asio::buffer_cast<const uint8_t *>(input_buffer_.data());
@@ -226,7 +226,7 @@ void HTTPSession::doReadChunkedHeader() {
 void HTTPSession::doReadHeader() {
   asio::async_read_until(
       socket_, input_buffer_, "\r\n\r\n",
-      [this](std::error_code ec, std::size_t length) {
+      [this](const std::error_code &ec, std::size_t length) {
         if (TRANSPORT_EXPECT_TRUE(!ec)) {
           const uint8_t *buffer =
               asio::buffer_cast<const uint8_t *>(input_buffer_.data());
@@ -287,7 +287,7 @@ void HTTPSession::tryReconnection() {
 void HTTPSession::doConnect() {
   asio::async_connect(
       socket_, endpoint_iterator_,
-      [this](std::error_code ec, tcp::resolver::iterator) {
+      [this](const std::error_code &ec, tcp::resolver::iterator) {
         if (!ec) {
           timer_.cancel();
           state_ = ConnectorState::CONNECTED;
diff --git a/apps/http-proxy/src/icn_receiver.cc b/apps/http-proxy/src/icn_receiver.cc
index ea8ac7191..954861e3a 100644
--- a/apps/http-proxy/src/icn_receiver.cc
+++ b/apps/http-proxy/src/icn_receiver.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -112,6 +112,7 @@ void AsyncConsumerProducer::doReceive() {
       });
 
   producer_socket_.connect();
+  producer_socket_.start();
 }
 
 void AsyncConsumerProducer::manageIncomingInterest(
@@ -128,9 +129,9 @@ void AsyncConsumerProducer::manageIncomingInterest(
 
     if (seg >= _it->second.first) {
       // TRANSPORT_LOGD(
-      //     "Ignoring interest with name %s for a content object which does not "
-      //     "exist. (Request: %u, max: %u)",
-      //     name.toString().c_str(), (uint32_t)seg, (uint32_t)_it->second.first);
+      //     "Ignoring interest with name %s for a content object which does not
+      //     " "exist. (Request: %u, max: %u)", name.toString().c_str(),
+      //     (uint32_t)seg, (uint32_t)_it->second.first);
       return;
     }
   }
@@ -168,7 +169,8 @@ void AsyncConsumerProducer::publishContent(const uint8_t* data,
       options.getLifetime());
 
   if (TRANSPORT_EXPECT_FALSE(ret != SOCKET_OPTION_SET)) {
-    TRANSPORT_LOG_WARNING << "Warning: content object lifetime has not been set.";
+    TRANSPORT_LOG_WARNING
+        << "Warning: content object lifetime has not been set.";
   }
 
   const interface::Name& name = options.getName();
diff --git a/apps/ping/.clang-format b/apps/ping/.clang-format
index cd21e2017..adc73c6fd 100644
--- a/apps/ping/.clang-format
+++ b/apps/ping/.clang-format
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2021 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/apps/ping/CMakeLists.txt b/apps/ping/CMakeLists.txt
index 42f7f98c1..a094cebe3 100644
--- a/apps/ping/CMakeLists.txt
+++ b/apps/ping/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -12,28 +12,45 @@
 # limitations under the License.
 
 if (NOT DISABLE_EXECUTABLES)
+##############################################################
+# Compiler options
+##############################################################
+set(COMPILER_OPTIONS
+  ${DEFAULT_COMPILER_OPTIONS}
+)
+
+##############################################################
+# Libraries to link
+##############################################################
   list (APPEND PING_LIBRARIES
-    ${LIBTRANSPORT_LIBRARIES}
-    ${CMAKE_THREAD_LIBS_INIT}
-    ${WSOCK32_LIBRARY}
-    ${WS2_32_LIBRARY}
+    PRIVATE ${LIBHICN_LIBRARIES}
+    PRIVATE ${LIBTRANSPORT_LIBRARIES}
+    PRIVATE ${CMAKE_THREAD_LIBS_INIT}
+    PRIVATE ${WSOCK32_LIBRARY}
+    PRIVATE ${WS2_32_LIBRARY}
   )
 
+##############################################################
+# Build ping server
+##############################################################
   build_executable(hicn-ping-server
     SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/ping_server.cc
     LINK_LIBRARIES ${PING_LIBRARIES}
-    INCLUDE_DIRS ${LIBTRANSPORT_INCLUDE_DIRS}
     DEPENDS ${DEPENDENCIES}
     COMPONENT ${HICN_APPS}
     LINK_FLAGS ${LINK_FLAGS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS}
   )
 
+##############################################################
+# Build ping client
+##############################################################
   build_executable(hicn-ping-client
     SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/ping_client.cc
     LINK_LIBRARIES ${PING_LIBRARIES}
-    INCLUDE_DIRS ${LIBTRANSPORT_INCLUDE_DIRS}
     DEPENDS ${DEPENDENCIES}
     COMPONENT ${HICN_APPS}
     LINK_FLAGS ${LINK_FLAGS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS}
   )
 endif ()
\ No newline at end of file
diff --git a/apps/ping/src/ping_client.cc b/apps/ping/src/ping_client.cc
index 24e0bf3ed..0217f2f8c 100644
--- a/apps/ping/src/ping_client.cc
+++ b/apps/ping/src/ping_client.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,7 +16,9 @@
 #include <hicn/transport/auth/verifier.h>
 #include <hicn/transport/core/global_object_pool.h>
 #include <hicn/transport/core/interest.h>
+#include <hicn/transport/interfaces/global_conf_interface.h>
 #include <hicn/transport/interfaces/portal.h>
+#include <hicn/transport/utils/chrono_typedefs.h>
 
 #include <asio/signal_set.hpp>
 #include <asio/steady_timer.hpp>
@@ -32,7 +34,7 @@ namespace core {
 
 namespace ping {
 
-typedef std::map<uint64_t, uint64_t> SendTimeMap;
+typedef std::map<uint64_t, utils::SteadyTime::TimePoint> SendTimeMap;
 typedef auth::AsymmetricVerifier Verifier;
 
 class Configuration {
@@ -77,17 +79,12 @@ class Configuration {
   }
 };
 
-class Client : interface::Portal::ConsumerCallback {
+class Client : interface::Portal::TransportCallback {
  public:
-  Client(Configuration *c)
-      : portal_(), signals_(portal_.getIoService(), SIGINT) {
+  Client(Configuration *c) : portal_(), signals_(io_service_, SIGINT) {
     // Let the main thread to catch SIGINT
-    portal_.connect();
-    portal_.setConsumerCallback(this);
-
     signals_.async_wait(std::bind(&Client::afterSignal, this));
-
-    timer_.reset(new asio::steady_timer(portal_.getIoService()));
+    timer_.reset(new asio::steady_timer(portal_.getThread().getIoService()));
     config_ = c;
     sequence_number_ = config_->first_suffix_;
     last_jump_ = 0;
@@ -105,19 +102,28 @@ class Client : interface::Portal::ConsumerCallback {
 
   void ping() {
     std::cout << "start ping" << std::endl;
-    doPing();
-    portal_.runEventsLoop();
+
+    portal_.getThread().add([this]() {
+      portal_.connect();
+      portal_.registerTransportCallback(this);
+      doPing();
+    });
+
+    io_service_.run();
+  }
+
+  void onInterest(Interest &interest) override {
+    throw errors::RuntimeException("Unexpected interest received.");
   }
 
   void onContentObject(Interest &interest, ContentObject &object) override {
-    uint64_t rtt = 0;
+    double rtt = 0;
 
     if (!config_->certificate_.empty()) {
-      auto t0 = std::chrono::steady_clock::now();
+      auto t0 = utils::SteadyTime::now();
       if (verifier_.verifyPacket(&object)) {
-        auto t1 = std::chrono::steady_clock::now();
-        auto dt =
-            std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0);
+        auto t1 = utils::SteadyTime::now();
+        auto dt = utils::SteadyTime::getDurationUs(t0, t1);
         std::cout << "Verification time: " << dt.count() << std::endl;
         std::cout << "<<< Signature Ok." << std::endl;
       } else {
@@ -127,10 +133,9 @@ class Client : interface::Portal::ConsumerCallback {
 
     auto it = send_timestamps_.find(interest.getName().getSuffix());
     if (it != send_timestamps_.end()) {
-      rtt = std::chrono::duration_cast<std::chrono::microseconds>(
-                std::chrono::steady_clock::now().time_since_epoch())
-                .count() -
-            it->second;
+      rtt =
+          utils::SteadyTime::getDurationUs(it->second, utils::SteadyTime::now())
+              .count();
       send_timestamps_.erase(it);
     }
 
@@ -206,7 +211,11 @@ class Client : interface::Portal::ConsumerCallback {
     }
   }
 
-  void onError(std::error_code ec) override {}
+  void onError(const std::error_code &ec) override {
+    std::cout << "Aborting ping due to internal error: " << ec.message()
+              << std::endl;
+    afterSignal();
+  }
 
   void doPing() {
     const Name interest_name(config_->name_, (uint32_t)sequence_number_);
@@ -254,10 +263,7 @@ class Client : interface::Portal::ConsumerCallback {
 
     if (!config_->quiet_) std::cout << std::endl;
 
-    send_timestamps_[sequence_number_] =
-        std::chrono::duration_cast<std::chrono::microseconds>(
-            std::chrono::steady_clock::now().time_since_epoch())
-            .count();
+    send_timestamps_[sequence_number_] = utils::SteadyTime::now();
 
     portal_.sendInterest(std::move(interest));
 
@@ -267,7 +273,11 @@ class Client : interface::Portal::ConsumerCallback {
     if (sent_ < config_->maxPing_) {
       this->timer_->expires_from_now(
           std::chrono::microseconds(config_->pingInterval_));
-      this->timer_->async_wait([this](const std::error_code e) { doPing(); });
+      this->timer_->async_wait([this](const std::error_code e) {
+        if (!e) {
+          doPing();
+        }
+      });
     }
   }
 
@@ -275,11 +285,11 @@ class Client : interface::Portal::ConsumerCallback {
     std::cout << "Stop ping" << std::endl;
     std::cout << "Sent: " << sent_ << " Received: " << received_
               << " Timeouts: " << timedout_ << std::endl;
-    portal_.stopEventsLoop();
+    io_service_.stop();
   }
 
   void reset() {
-    timer_.reset(new asio::steady_timer(portal_.getIoService()));
+    timer_.reset(new asio::steady_timer(portal_.getThread().getIoService()));
     sequence_number_ = config_->first_suffix_;
     last_jump_ = 0;
     processed_ = 0;
@@ -291,6 +301,7 @@ class Client : interface::Portal::ConsumerCallback {
 
  private:
   SendTimeMap send_timestamps_;
+  asio::io_service io_service_;
   interface::Portal portal_;
   asio::signal_set signals_;
   uint64_t sequence_number_;
@@ -337,6 +348,11 @@ void help() {
             << std::endl;
   std::cout << "-q                quiet, not prints (default false)"
             << std::endl;
+  std::cerr << "-z <io_module>    IO module to use. Default: hicnlightng_module"
+            << std::endl;
+  std::cerr << "-F <conf_file>    Path to optional configuration file for "
+               "libtransport"
+            << std::endl;
   std::cout << "-H                prints this message" << std::endl;
 }
 
@@ -350,7 +366,11 @@ int main(int argc, char *argv[]) {
   int opt;
   std::string producer_certificate = "";
 
-  while ((opt = getopt(argc, argv, "j::t:i:m:s:d:n:l:f:c:SAOqVDH")) != -1) {
+  std::string conf_file;
+  transport::interface::global_config::IoModuleConfiguration io_config;
+  io_config.name = "hicnlightng_module";
+
+  while ((opt = getopt(argc, argv, "j::t:i:m:s:d:n:l:f:c:SAOqVDHz:F:")) != -1) {
     switch (opt) {
       case 't':
         c->ttl_ = (uint8_t)std::stoi(optarg);
@@ -406,6 +426,12 @@ int main(int argc, char *argv[]) {
       case 'c':
         c->certificate_ = std::string(optarg);
         break;
+      case 'z':
+        io_config.name = optarg;
+        break;
+      case 'F':
+        conf_file = optarg;
+        break;
       case 'H':
       default:
         help();
@@ -413,16 +439,24 @@ int main(int argc, char *argv[]) {
     }
   }
 
+  /**
+   * IO module configuration
+   */
+  io_config.set();
+
+  /**
+   * Parse config file
+   */
+  transport::interface::global_config::parseConfigurationFile(conf_file);
+
   auto ping = std::make_unique<Client>(c);
 
   auto t0 = std::chrono::steady_clock::now();
   ping->ping();
   auto t1 = std::chrono::steady_clock::now();
 
-  std::cout
-      << "Elapsed time: "
-      << std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0).count()
-      << std::endl;
+  std::cout << "Elapsed time: "
+            << utils::SteadyTime::getDurationUs(t0, t1).count() << std::endl;
 
 #ifdef _WIN32
   WSACleanup();
diff --git a/apps/ping/src/ping_server.cc b/apps/ping/src/ping_server.cc
index baf9c6698..3ffbc7325 100644
--- a/apps/ping/src/ping_server.cc
+++ b/apps/ping/src/ping_server.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,10 +21,10 @@
 #include <openssl/applink.c>
 #endif
 
-#include <hicn/transport/auth/identity.h>
 #include <hicn/transport/auth/signer.h>
 #include <hicn/transport/core/content_object.h>
 #include <hicn/transport/core/interest.h>
+#include <hicn/transport/interfaces/global_conf_interface.h>
 #include <hicn/transport/utils/string_tokenizer.h>
 
 #include <asio.hpp>
@@ -36,24 +36,13 @@ namespace interface {
 using HashAlgorithm = core::HashAlgorithm;
 using CryptoSuite = auth::CryptoSuite;
 
-auth::Identity setProducerIdentity(std::string keystore_name,
-                                   std::string keystore_password,
-                                   auth::CryptoHashType hash_algorithm) {
-  if (access(keystore_name.c_str(), F_OK) != -1) {
-    return auth::Identity(keystore_name, keystore_password, hash_algorithm);
-  } else {
-    return auth::Identity(keystore_name, keystore_password,
-                          CryptoSuite::RSA_SHA256, 1024, 365, "producer-test");
-  }
-}
-
 class CallbackContainer {
   const std::size_t log2_content_object_buffer_size = 12;
 
  public:
   CallbackContainer(const Name &prefix, uint32_t object_size, bool verbose,
                     bool dump, bool quite, bool flags, bool reset, uint8_t ttl,
-                    auth::Identity *identity, bool sign, uint32_t lifetime)
+                    auth::Signer *signer, bool sign, uint32_t lifetime)
       : buffer_(object_size, 'X'),
         content_objects_((std::uint32_t)(1 << log2_content_object_buffer_size)),
         mask_((std::uint16_t)(1 << log2_content_object_buffer_size) - 1),
@@ -64,7 +53,7 @@ class CallbackContainer {
         flags_(flags),
         reset_(reset),
         ttl_(ttl),
-        identity_(identity),
+        signer_(signer),
         sign_(sign) {
     core::Packet::Format format;
 
@@ -151,8 +140,8 @@ class CallbackContainer {
 
       if (!quite_) std::cout << std::endl;
 
-      if (sign_) {
-        identity_->getSigner()->signPacket(content_object.get());
+      if (sign_ && signer_) {
+        signer_->signPacket(content_object.get());
       }
 
       p.produce(*content_object);
@@ -170,33 +159,43 @@ class CallbackContainer {
   bool flags_;
   bool reset_;
   uint8_t ttl_;
-  auth::Identity *identity_;
+  auth::Signer *signer_;
   bool sign_;
 };
 
 void help() {
   std::cout << "usage: hicn-preoducer-ping [options]" << std::endl;
   std::cout << "PING options" << std::endl;
-  std::cout << "-s <val>  object content size (default 1350B)" << std::endl;
-  std::cout << "-n <val>  hicn name (default b001::/64)" << std::endl;
-  std::cout << "-f        set tcp flags according to the flag received "
-               "(default false)"
+  std::cout << "-s <val>          object content size (default 1350B)"
             << std::endl;
-  std::cout << "-l        data lifetime" << std::endl;
-  std::cout << "-r        always reply with a reset flag (default false)"
+  std::cout << "-n <val>          hicn name (default b001::/64)" << std::endl;
+  std::cout << "-f                set tcp flags according to the flag received "
+               "                  (default false)"
             << std::endl;
-  std::cout << "-t        set ttl (default 64)" << std::endl;
+  std::cout << "-l                data lifetime" << std::endl;
+  std::cout
+      << "-r                always reply with a reset flag (default false)"
+      << std::endl;
+  std::cout << "-t                set ttl (default 64)" << std::endl;
   std::cout << "OUTPUT options" << std::endl;
-  std::cout << "-V        verbose, prints statistics about the messagges sent "
-               "and received (default false)"
+  std::cout << "-V                verbose, prints statistics about the "
+               "messagges sent "
+               "                  and received (default false)"
+            << std::endl;
+  std::cout << "-D                dump, dumps sent and received packets "
+               "(default false)"
             << std::endl;
-  std::cout << "-D        dump, dumps sent and received packets (default false)"
+  std::cout << "-q                quite, not prints (default false)"
+            << std::endl;
+  std::cerr << "-z <io_module>    IO module to use. Default: hicnlightng_module"
+            << std::endl;
+  std::cerr << "-F <conf_file>    Path to optional configuration file for "
+               "libtransport"
             << std::endl;
-  std::cout << "-q        quite, not prints (default false)" << std::endl;
 #ifndef _WIN32
-  std::cout << "-d        daemon mode" << std::endl;
+  std::cout << "-d                daemon mode" << std::endl;
 #endif
-  std::cout << "-H        prints this message" << std::endl;
+  std::cout << "-H                prints this message" << std::endl;
 }
 
 int main(int argc, char **argv) {
@@ -220,11 +219,15 @@ int main(int argc, char **argv) {
   bool sign = false;
   uint32_t data_lifetime = default_values::content_object_expiry_time;
 
+  std::string conf_file;
+  transport::interface::global_config::IoModuleConfiguration io_config;
+  io_config.name = "hicnlightng_module";
+
   int opt;
 #ifndef _WIN32
-  while ((opt = getopt(argc, argv, "s:n:t:l:qfrVDdHk:p:")) != -1) {
+  while ((opt = getopt(argc, argv, "s:n:t:l:qfrVDdHk:p:z:F:")) != -1) {
 #else
-  while ((opt = getopt(argc, argv, "s:n:t:l:qfrVDHk:p:")) != -1) {
+  while ((opt = getopt(argc, argv, "s:n:t:l:qfrVDHk:p:z:F:")) != -1) {
 #endif
     switch (opt) {
       case 's':
@@ -268,6 +271,12 @@ int main(int argc, char **argv) {
       case 'p':
         keystore_password = optarg;
         break;
+      case 'z':
+        io_config.name = optarg;
+        break;
+      case 'F':
+        conf_file = optarg;
+        break;
       case 'H':
       default:
         help();
@@ -281,6 +290,16 @@ int main(int argc, char **argv) {
   }
 #endif
 
+  /**
+   * IO module configuration
+   */
+  io_config.set();
+
+  /**
+   * Parse config file
+   */
+  transport::interface::global_config::parseConfigurationFile(conf_file);
+
   core::Prefix producer_namespace(name_prefix);
 
   utils::StringTokenizer tokenizer(name_prefix, delimiter);
@@ -290,21 +309,24 @@ int main(int argc, char **argv) {
   if (object_size > 1350) object_size = 1350;
 
   CallbackContainer *stubs;
-  auth::Identity identity = setProducerIdentity(
-      keystore_path, keystore_password, auth::CryptoHashType::SHA256);
+  std::unique_ptr<auth::AsymmetricSigner> signer;
 
   if (sign) {
-    stubs = new CallbackContainer(n, object_size, verbose, dump, quite, flags,
-                                  reset, ttl, &identity, sign, data_lifetime);
+    signer = std::make_unique<auth::AsymmetricSigner>(keystore_path,
+                                                      keystore_password);
+    stubs =
+        new CallbackContainer(n, object_size, verbose, dump, quite, flags,
+                              reset, ttl, signer.get(), sign, data_lifetime);
   } else {
-    auth::Identity *identity = nullptr;
+    auth::Signer *signer = nullptr;
     stubs = new CallbackContainer(n, object_size, verbose, dump, quite, flags,
-                                  reset, ttl, identity, sign, data_lifetime);
+                                  reset, ttl, signer, sign, data_lifetime);
   }
 
   ProducerSocket p;
   p.registerPrefix(producer_namespace);
 
+  p.setSocketOption(GeneralTransportOptions::MAKE_MANIFEST, false);
   p.setSocketOption(GeneralTransportOptions::OUTPUT_BUFFER_SIZE, 0U);
   p.setSocketOption(
       ProducerCallbacksOptions::CACHE_MISS,
@@ -313,6 +335,7 @@ int main(int argc, char **argv) {
                                      std::placeholders::_2, data_lifetime));
 
   p.connect();
+  p.start();
 
   asio::io_service io_service;
   asio::signal_set signal_set(io_service, SIGINT);
diff --git a/cmake b/cmake
new file mode 160000
+Subproject 5fc3324dd897a75aa1fca4290a8ec02a8f19386
diff --git a/cmake/Modules/BuildMacros.cmake b/cmake/Modules/BuildMacros.cmake
deleted file mode 100644
index 15e2ff1a8..000000000
--- a/cmake/Modules/BuildMacros.cmake
+++ /dev/null
@@ -1,300 +0,0 @@
-# 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.
-
-##############################
-# Utils for building libraries and executables
-#
-
-include(GNUInstallDirs)
-
-macro(remove_flag_from_target target flag)
-    get_target_property(target_cxx_flags ${target} COMPILE_OPTIONS)
-    if(target_cxx_flags)
-        list(REMOVE_ITEM target_cxx_flags ${flag})
-        set_target_properties(${target} PROPERTIES COMPILE_OPTIONS "${target_cxx_flags}")
-    endif()
-endmacro()
-
-macro(build_executable exec)
-  cmake_parse_arguments(ARG
-    "NO_INSTALL"
-    "COMPONENT"
-    "SOURCES;LINK_LIBRARIES;DEPENDS;INCLUDE_DIRS;DEFINITIONS;COMPILE_OPTIONS;LINK_FLAGS"
-    ${ARGN}
-  )
-
-  add_executable(${exec}-bin ${ARG_SOURCES})
-
-  set(BUILD_ROOT ${CMAKE_BINARY_DIR}/build-root)
-
-  set_target_properties(${exec}-bin
-    PROPERTIES
-    OUTPUT_NAME ${exec}
-    INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}"
-    BUILD_RPATH "${BUILD_ROOT}/lib"
-    INSTALL_RPATH_USE_LINK_PATH TRUE
-    ARCHIVE_OUTPUT_DIRECTORY "${BUILD_ROOT}/lib"
-    LIBRARY_OUTPUT_DIRECTORY "${BUILD_ROOT}/lib"
-    RUNTIME_OUTPUT_DIRECTORY "${BUILD_ROOT}/bin"
-    LINK_FLAGS "${ARG_LINK_FLAGS}"
-  )
-
-  if(ARG_LINK_LIBRARIES)
-    target_link_libraries(${exec}-bin ${ARG_LINK_LIBRARIES})
-  endif()
-
-  if(ARG_DEPENDS)
-    add_dependencies(${exec}-bin ${ARG_DEPENDS})
-  endif()
-
-  if (ARG_COMPILE_OPTIONS)
-    target_compile_options(${exec}-bin PRIVATE -Wall -Werror ${ARG_COMPILE_OPTIONS})
-  endif()
-
-  if(ARG_DEFINITIONS)
-    target_compile_definitions(${exec}-bin PRIVATE ${ARG_DEFINITIONS})
-  endif()
-
-  if(ARG_INCLUDE_DIRS)
-    target_include_directories(${exec}-bin BEFORE PUBLIC
-      ${ARG_INCLUDE_DIRS}
-      ${PROJECT_BINARY_DIR}
-    )
-  endif()
-
-  if(NOT ARG_NO_INSTALL)
-    install(
-      TARGETS ${exec}-bin
-      RUNTIME
-      DESTINATION ${CMAKE_INSTALL_BINDIR}
-      COMPONENT ${ARG_COMPONENT}
-    )
-  endif()
-endmacro()
-
-macro(build_library lib)
-  cmake_parse_arguments(ARG
-    "SHARED;STATIC;NO_DEV"
-    "COMPONENT;"
-    "SOURCES;LINK_LIBRARIES;OBJECT_LIBRARIES;LINK_FLAGS;INSTALL_HEADERS;DEPENDS;INCLUDE_DIRS;DEFINITIONS;HEADER_ROOT_DIR;LIBRARY_ROOT_DIR;INSTALL_FULL_PATH_DIR;EMPTY_PREFIX;COMPILE_OPTIONS;VERSION"
-    ${ARGN}
-  )
-
-  message(STATUS "Building library ${lib}")
-
-  # Clear target_libs
-  unset(TARGET_LIBS)
-
-  if (ARG_SHARED)
-    list(APPEND TARGET_LIBS
-      ${lib}.shared
-    )
-    add_library(${lib}.shared SHARED ${ARG_SOURCES} ${ARG_OBJECT_LIBRARIES})
-  endif()
-
-  if(ARG_STATIC)
-    list(APPEND TARGET_LIBS
-      ${lib}.static
-    )
-    add_library(${lib}.static STATIC ${ARG_SOURCES} ${ARG_OBJECT_LIBRARIES})
-  endif()
-
-  if(NOT ARG_COMPONENT)
-    set(ARG_COMPONENT hicn)
-  endif()
-
-  set(BUILD_ROOT ${CMAKE_BINARY_DIR}/build-root)
-
-  foreach(library ${TARGET_LIBS})
-
-    if(HICN_VERSION)
-      set_target_properties(${library}
-        PROPERTIES
-        SOVERSION ${HICN_VERSION}
-      )
-    endif()
-
-    if (${ARG_EMPTY_PREFIX})
-      set_target_properties(${library}
-        PROPERTIES
-        INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}"
-        BUILD_RPATH "${BUILD_ROOT}/lib"
-        INSTALL_RPATH_USE_LINK_PATH TRUE
-        PREFIX ""
-        ARCHIVE_OUTPUT_DIRECTORY "${BUILD_ROOT}/lib"
-        LIBRARY_OUTPUT_DIRECTORY "${BUILD_ROOT}/lib"
-        RUNTIME_OUTPUT_DIRECTORY "${BUILD_ROOT}/bin"
-        LINK_FLAGS "${ARG_LINK_FLAGS}"
-      )
-    else ()
-      set_target_properties(${library}
-        PROPERTIES
-        INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}"
-        BUILD_RPATH "${BUILD_ROOT}/lib"
-        INSTALL_RPATH_USE_LINK_PATH TRUE
-        ARCHIVE_OUTPUT_DIRECTORY "${BUILD_ROOT}/lib"
-        LIBRARY_OUTPUT_DIRECTORY "${BUILD_ROOT}/lib"
-        RUNTIME_OUTPUT_DIRECTORY "${BUILD_ROOT}/bin"
-        LINK_FLAGS "${ARG_LINK_FLAGS}"
-      )
-    endif()
-
-    if (WIN32)
-      target_compile_options(${library} PRIVATE ${ARG_COMPILE_OPTIONS})
-      set_target_properties(${library}
-        PROPERTIES
-        WINDOWS_EXPORT_ALL_SYMBOLS TRUE
-      )
-    else ()
-      target_compile_options(${library}
-        PRIVATE -Wall -Werror ${ARG_COMPILE_OPTIONS}
-      )
-      set_target_properties(${library}
-        PROPERTIES
-        OUTPUT_NAME ${lib}
-      )
-    endif ()
-
-    # library deps
-    if(ARG_LINK_LIBRARIES)
-      target_link_libraries(${library} PUBLIC ${ARG_LINK_LIBRARIES})
-    endif()
-
-    if(ARG_DEFINITIONS)
-      target_compile_definitions(${library} PRIVATE ${ARG_DEFINITIONS})
-    endif()
-
-    if(ARG_INCLUDE_DIRS)
-      target_include_directories(${library} BEFORE PUBLIC
-        ${ARG_INCLUDE_DIRS}
-        ${PROJECT_BINARY_DIR}
-      )
-    endif()
-
-    if(ARG_VERSION)
-      set_target_properties(${library}
-        PROPERTIES
-        VERSION ${ARG_VERSION}
-      )
-    endif()
-
-    set(INSTALL_LIB_PATH "${CMAKE_INSTALL_LIBDIR}/${ARG_LIBRARY_ROOT_DIR}")
-
-    if (ARG_INSTALL_FULL_PATH_DIR)
-      set(INSTALL_LIB_PATH ${ARG_INSTALL_FULL_PATH_DIR})
-    endif()
-
-    install(
-      TARGETS ${library}
-      COMPONENT ${ARG_COMPONENT}
-      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-      LIBRARY DESTINATION ${INSTALL_LIB_PATH}
-    )
-
-    if(ARG_DEPENDS)
-      add_dependencies(${library} ${ARG_DEPENDS})
-    endif()
-  endforeach()
-
-  # install headers
-  if(ARG_INSTALL_HEADERS)
-    if (NOT ARG_HEADER_ROOT_DIR)
-      set(ARG_HEADER_ROOT_DIR "hicn")
-    endif()
-
-    list(APPEND local_comps
-      ${ARG_COMPONENT}-dev
-    )
-
-    foreach(file ${ARG_INSTALL_HEADERS})
-      get_filename_component(_dir ${file} DIRECTORY)
-
-      if (_dir)
-        get_filename_component(dir ${_dir} NAME)
-        if ("${dir}" STREQUAL src)
-          set(dir "")
-        endif()
-        if ("${dir}" STREQUAL includes)
-          set(dir "")
-        endif()
-        if ("${dir}" STREQUAL ${ARG_HEADER_ROOT_DIR})
-          set(dir "")
-        endif()
-      else()
-        set(dir "")
-      endif()
-
-      set(COMPONENT ${ARG_COMPONENT})
-      if (NOT ARG_NO_DEV)
-        set(COMPONENT ${COMPONENT}-dev)
-      endif()
-      install(
-        FILES ${file}
-        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${ARG_HEADER_ROOT_DIR}/${dir}
-        COMPONENT ${COMPONENT}
-      )
-    endforeach()
-  endif()
-endmacro()
-
-macro (build_module module)
-  cmake_parse_arguments(ARG
-    "SHARED;STATIC;NO_DEV"
-    "COMPONENT;"
-    "SOURCES;LINK_LIBRARIES;INSTALL_HEADERS;DEPENDS;INCLUDE_DIRS;DEFINITIONS;HEADER_ROOT_DIR;LIBRARY_ROOT_DIR;INSTALL_FULL_PATH_DIR;EMPTY_PREFIX;COMPILE_OPTIONS;VERSION"
-    ${ARGN}
-  )
-
-  message(STATUS "Building module ${module}")
-
-  build_library(${module}
-    SHARED
-    SOURCES ${ARG_SOURCES}
-    LINK_LIBRARIES ${ARG_LINK_LIBRARIES}
-    INSTALL_HEADERS ${ARG_INSTALL_HEADERS}
-    DEPENDS ${ARG_DEPENDS}
-    COMPONENT ${ARG_COMPONENT}
-    INCLUDE_DIRS ${ARG_INCLUDE_DIRS}
-    HEADER_ROOT_DIR ${ARG_HEADER_ROOT_DIR}
-    LIBRARY_ROOT_DIR ${ARG_LIBRARY_ROOT_DIR}
-    INSTALL_FULL_PATH_DIR ${ARG_INSTALL_FULL_PATH_DIR}
-    DEFINITIONS ${ARG_DEFINITIONS}
-    EMPTY_PREFIX ${ARG_EMPTY_PREFIX}
-    COMPILE_OPTIONS ${ARG_COMPILE_OPTIONS}
-    VERSION ${ARG_VERSION}
-  )
-
-  if (${CMAKE_SYSTEM_NAME} MATCHES Darwin)
-    set(LINK_FLAGS "-Wl,-undefined,dynamic_lookup")
-  elseif(${CMAKE_SYSTEM_NAME} MATCHES iOS)
-    set(LINK_FLAGS "-Wl,-undefined,dynamic_lookup")
-  elseif(${CMAKE_SYSTEM_NAME} MATCHES Linux)
-    set(LINK_FLAGS "-Wl,-unresolved-symbols=ignore-all")
-  elseif(${CMAKE_SYSTEM_NAME} MATCHES Windows)
-    set(LINK_FLAGS "/wd4275")
-  else()
-    message(FATAL_ERROR "Trying to build module on a not supportd platform. Aborting.")
-  endif()
-
-  set_target_properties(${module}.shared
-    PROPERTIES
-    LINKER_LANGUAGE C
-    PREFIX ""
-    LINK_FLAGS ${LINK_FLAGS}
-  )
-
-endmacro(build_module)
-
-include(IosMacros)
-include(WindowsMacros)
diff --git a/cmake/Modules/FindAsio.cmake b/cmake/Modules/FindAsio.cmake
deleted file mode 100644
index 73888e519..000000000
--- a/cmake/Modules/FindAsio.cmake
+++ /dev/null
@@ -1,41 +0,0 @@
-# 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 the hcin libraries and includes
-# This module sets:
-#  ASIO_FOUND: True if asio was found
-#  ASIO_INCLUDE_DIR:  The asio include dir
-#
-
-set(ASIO_SEARCH_PATH_LIST
-  ${ASIO_HOME}
-  $ENV{ASIO_HOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(ASIO_INCLUDE_DIR asio.hpp
-  HINTS ${ASIO_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the asio includes"
-)
-
-set(ASIO_INCLUDE_DIRS ${ASIO_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Asio
-  REQUIRED_VARS ASIO_INCLUDE_DIRS
-)
\ No newline at end of file
diff --git a/cmake/Modules/FindCURL.cmake b/cmake/Modules/FindCURL.cmake
deleted file mode 100644
index 239b0e505..000000000
--- a/cmake/Modules/FindCURL.cmake
+++ /dev/null
@@ -1,69 +0,0 @@
-#.rst:
-# FindCURL
-# --------
-#
-# Find curl
-#
-# Find the native CURL headers and libraries.
-#
-# ::
-#
-#   CURL_INCLUDE_DIRS   - where to find curl_/curl_.h, etc.
-#   CURL_LIBRARIES      - List of libraries when using curl.
-#   CURL_FOUND          - True if curl found.
-#   CURL_VERSION_STRING - the version of curl found (since CMake 2.8.8)
-
-#=============================================================================
-# Copyright 2006-2009 Kitware, Inc.
-# Copyright 2012 Rolf Eike Beer <eike@sf-mail.de>
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-# Look for the header file.
-find_path(CURL_INCLUDE_DIR NAMES curl/curl.h)
-mark_as_advanced(CURL_INCLUDE_DIR)
-
-# Look for the library (sorted from most current/relevant entry to least).
-find_library(CURL_LIBRARY NAMES
-        curl
-        # Windows MSVC prebuilts:
-        curllib
-        libcurl_imp
-        curllib_static
-        # Windows older "Win32 - MSVC" prebuilts (libcurl.lib, e.g. libcurl-7.15.5-win32-msvc.zip):
-        libcurl
-        )
-mark_as_advanced(CURL_LIBRARY)
-
-if(CURL_INCLUDE_DIR)
-    foreach(_curl_version_header curlver.h curl.h)
-        if(EXISTS "${CURL_INCLUDE_DIR}/curl/${_curl_version_header}")
-            file(STRINGS "${CURL_INCLUDE_DIR}/curl/${_curl_version_header}" curl_version_str REGEX "^#define[\t ]+LIBCURL_VERSION[\t ]+\".*\"")
-
-            string(REGEX REPLACE "^#define[\t ]+LIBCURL_VERSION[\t ]+\"([^\"]*)\".*" "\\1" CURL_VERSION_STRING "${curl_version_str}")
-            unset(curl_version_str)
-            break()
-        endif()
-    endforeach()
-endif()
-
-# handle the QUIETLY and REQUIRED arguments and set CURL_FOUND to TRUE if
-# all listed variables are TRUE
-include(FindPackageHandleStandardArgs)
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(CURL
-        REQUIRED_VARS CURL_LIBRARY CURL_INCLUDE_DIR
-        VERSION_VAR CURL_VERSION_STRING)
-
-if(CURL_FOUND)
-    set(CURL_LIBRARIES ${CURL_LIBRARY})
-    set(CURL_INCLUDE_DIRS ${CURL_INCLUDE_DIR})
-endif()
diff --git a/cmake/Modules/FindCollectd.cmake b/cmake/Modules/FindCollectd.cmake
deleted file mode 100644
index 244fd14e5..000000000
--- a/cmake/Modules/FindCollectd.cmake
+++ /dev/null
@@ -1,41 +0,0 @@
-# Copyright (c) 2020 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.
-
-set(COLLECTD_SEARCH_PATH_LIST
-  ${COLLECTD_HOME}
-  $ENV{COLLECTD_HOME}
-  /usr/local
-  /opt
-  /usr
-  )
-
-find_path(COLLECTD_INCLUDE_DIR collectd.h
-  HINTS ${COLLECTD_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include/collectd/core/daemon/ daemon/
-  DOC "Find the collectd includes"
-)
-
-find_path(COLLECTD_CONFIG_INCLUDE_DIR config.h
-  HINTS ${COLLECTD_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include/collectd/core/
-  DOC "Find the collectd includes"
-)
-
-message(STATUS ${COLLECTD_INCLUDE_DIR} ${COLLECTD_CONFIG_INCLUDE_DIR})
-
-set(COLLECTD_INCLUDE_DIRS ${COLLECTD_INCLUDE_DIR} ${COLLECTD_CONFIG_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Collectd DEFAULT_MSG COLLECTD_INCLUDE_DIRS)
-
-mark_as_advanced(COLLECTD_INCLUDE_DIRS)
diff --git a/cmake/Modules/FindGFlags.cmake b/cmake/Modules/FindGFlags.cmake
deleted file mode 100644
index 804bfebdc..000000000
--- a/cmake/Modules/FindGFlags.cmake
+++ /dev/null
@@ -1,36 +0,0 @@
-# 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 libgflags
-#
-#  LIBGFLAGS_INCLUDE_DIR - where to find gflags/gflags.h, etc.
-#  LIBGFLAGS_LIBRARY     - List of libraries when using libgflags.
-#  LIBGFLAGS_FOUND       - True if libgflags found.
-
-
-IF (LIBGFLAGS_INCLUDE_DIR)
-    # Already in cache, be silent
-    SET(LIBGFLAGS_FIND_QUIETLY TRUE)
-ENDIF ()
-
-FIND_PATH(LIBGFLAGS_INCLUDE_DIR gflags/gflags.h)
-
-FIND_LIBRARY(LIBGFLAGS_LIBRARY NAMES gflags gflags_static)
-
-# handle the QUIETLY and REQUIRED arguments and set LIBGFLAGS_FOUND to TRUE if
-# all listed variables are TRUE
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBGFLAGS DEFAULT_MSG LIBGFLAGS_LIBRARY LIBGFLAGS_INCLUDE_DIR)
-
-MARK_AS_ADVANCED(LIBGFLAGS_LIBRARY LIBGFLAGS_INCLUDE_DIR)
\ No newline at end of file
diff --git a/cmake/Modules/FindGlog.cmake b/cmake/Modules/FindGlog.cmake
deleted file mode 100644
index 10023a187..000000000
--- a/cmake/Modules/FindGlog.cmake
+++ /dev/null
@@ -1,36 +0,0 @@
-# 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 libglog
-#
-#  LIBGLOG_INCLUDE_DIR - where to find glog/logging.h, etc.
-#  LIBGLOG_LIBRARY     - List of libraries when using libglog.
-#  LIBGLOG_FOUND       - True if libglog found.
-
-
-IF (LIBGLOG_INCLUDE_DIR)
-    # Already in cache, be silent
-    SET(LIBGLOG_FIND_QUIETLY TRUE)
-ENDIF ()
-
-FIND_PATH(LIBGLOG_INCLUDE_DIR glog/logging.h)
-
-FIND_LIBRARY(LIBGLOG_LIBRARY glog)
-
-# handle the QUIETLY and REQUIRED arguments and set LIBGLOG_FOUND to TRUE if
-# all listed variables are TRUE
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBGLOG DEFAULT_MSG LIBGLOG_LIBRARY LIBGLOG_INCLUDE_DIR)
-
-MARK_AS_ADVANCED(LIBGLOG_LIBRARY LIBGLOG_INCLUDE_DIR)
\ No newline at end of file
diff --git a/cmake/Modules/FindHicnLight.cmake b/cmake/Modules/FindHicnLight.cmake
deleted file mode 100644
index 6894415e7..000000000
--- a/cmake/Modules/FindHicnLight.cmake
+++ /dev/null
@@ -1,40 +0,0 @@
-# Copyright (c) 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.
-
-set(HICNLIGHT_SEARCH_PATH_LIST
-  ${HICNLIGHT_HOME}
-  $ENV{HICNLIGHT_HOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(HICNLIGHT_INCLUDE_DIR hicn/ctrl/api.h
-	HINTS ${HICNLIGHT_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the hicn plugin includes"
-)
-
-find_library(HICNLIGHT_LIBRARY NAMES libhicnctrl.so
-	HINTS ${HICNLIGHT_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib/x86_64-linux-gnu/
-  DOC "Find the hicn light lib"
-)
-
-set(HICNLIGHT_LIBRARIES ${HICNLIGHT_LIBRARY})
-set(HICNLIGHT_INCLUDE_DIRS ${HICNLIGHT_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Hicnlight HICNLIGHT_LIBRARIES HICNLIGHT_INCLUDE_DIRS)
-
-mark_as_advanced(HICNLIGHT_LIBRARY HICNLIGHT_INCLUDE_DIR)
diff --git a/cmake/Modules/FindHicnPlugin.cmake b/cmake/Modules/FindHicnPlugin.cmake
deleted file mode 100644
index 07e5f9a8c..000000000
--- a/cmake/Modules/FindHicnPlugin.cmake
+++ /dev/null
@@ -1,35 +0,0 @@
-# Copyright (c) 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.
-
-set(HICNPLUGIN_SEARCH_PATH_LIST
-  ${VPP_SEARCH_PATH_LIST}
-  ${HICNPLUGIN_HOME}
-  $ENV{HICNPLUGIN_HOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(HICNPLUGIN_INCLUDE_DIR vapi/hicn.api.vapi.h
-	HINTS ${HICNPLUGIN_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the hicn plugin includes"
-)
-
-
-set(HICNPLUGIN_INCLUDE_DIRS ${HICNPLUGIN_INCLUDE_DIR} ${HICNPLUGIN_INCLUDE_DIR}/vpp_plugins)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(HicnPlugin DEFAULT_MSG HICNPLUGIN_INCLUDE_DIR)
-
-mark_as_advanced(HICNPLUGIN_INCLUDE_DIR)
\ No newline at end of file
diff --git a/cmake/Modules/FindJsoncpp.cmake b/cmake/Modules/FindJsoncpp.cmake
deleted file mode 100644
index acde7b95b..000000000
--- a/cmake/Modules/FindJsoncpp.cmake
+++ /dev/null
@@ -1,47 +0,0 @@
-# Find jsoncpp
-#
-# Find the jsoncpp includes and library
-#
-# if you nee to add a custom library search path, do it via via CMAKE_PREFIX_PATH
-#
-# This module defines
-#  JSONCPP_INCLUDE_DIRS, where to find header, etc.
-#  JSONCPP_LIBRARIES, the libraries needed to use jsoncpp.
-#  JSONCPP_FOUND, If false, do not try to use jsoncpp.
-#  JSONCPP_INCLUDE_PREFIX, include prefix for jsoncpp
-
-# only look in default directories
-find_path(
-        JSONCPP_INCLUDE_DIR
-        NAMES jsoncpp/json/json.h json/json.h
-        DOC "jsoncpp include dir"
-)
-
-find_library(
-        JSONCPP_LIBRARY
-        NAMES jsoncpp
-        DOC "jsoncpp library"
-)
-
-set(JSONCPP_INCLUDE_DIRS ${JSONCPP_INCLUDE_DIR})
-set(JSONCPP_LIBRARIES ${JSONCPP_LIBRARY})
-
-# find JSONCPP_INCLUDE_PREFIX
-find_path(
-        JSONCPP_INCLUDE_PREFIX
-        NAMES json.h
-        PATH_SUFFIXES jsoncpp/json json
-)
-
-if (${JSONCPP_INCLUDE_PREFIX} MATCHES "jsoncpp")
-    set(JSONCPP_INCLUDE_PREFIX "jsoncpp/json")
-else()
-    set(JSONCPP_INCLUDE_PREFIX "json")
-endif()
-
-# handle the QUIETLY and REQUIRED arguments and set JSONCPP_FOUND to TRUE
-# if all listed variables are TRUE, hide their existence from configuration view
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(jsoncpp DEFAULT_MSG
-        JSONCPP_INCLUDE_DIR JSONCPP_LIBRARY)
-mark_as_advanced (JSONCPP_INCLUDE_DIR JSONCPP_LIBRARY)
\ No newline at end of file
diff --git a/cmake/Modules/FindLibEvent.cmake b/cmake/Modules/FindLibEvent.cmake
deleted file mode 100644
index 5e4113716..000000000
--- a/cmake/Modules/FindLibEvent.cmake
+++ /dev/null
@@ -1,55 +0,0 @@
-# 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 the LibEvent libraries and includes
-# This module sets:
-#  LIBEVENT_FOUND: True if LibEvent was found
-#  LIBEVENT_LIBRARY:  The LibEvent library
-#  LIBEVENT_LIBRARIES:  The LibEvent library and dependencies
-#  LIBEVENT_INCLUDE_DIR:  The LibEvent include dir
-#
-# This module will look for the libraries in various locations
-# See the LIBEVENT_SEARCH_PATH_LIST for a full list.
-#
-# The caller can hint at locations using the following variables:
-#
-# LIBEVENT_HOME (passed as -D to cmake)
-# LIBEVENT_HOME (in environment)
-#
-
-set(LIBEVENT_SEARCH_PATH_LIST
-  ${LIBEVENT_HOME}
-  $ENV{DEPENDENCIES}
-  $ENV{LIBEVENT_HOME}
-  /usr/local
-  /opt
-  /usr
-  )
-
-find_path(LIBEVENT_INCLUDE_DIR event2/event.h
-  HINTS ${LIBEVENT_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the LibEvent includes" )
-
-find_library(LIBEVENT_LIBRARY NAMES event
-  HINTS ${LIBEVENT_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib
-  DOC "Find the LibEvent libraries" )
-
-set(LIBEVENT_LIBRARIES ${LIBEVENT_LIBRARY})
-set(LIBEVENT_INCLUDE_DIRS ${LIBEVENT_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(LibEvent  DEFAULT_MSG LIBEVENT_LIBRARY LIBEVENT_INCLUDE_DIR)
diff --git a/cmake/Modules/FindLibconfig++.cmake b/cmake/Modules/FindLibconfig++.cmake
deleted file mode 100644
index 1636ae96a..000000000
--- a/cmake/Modules/FindLibconfig++.cmake
+++ /dev/null
@@ -1,43 +0,0 @@
-set(LIBCONFIG_SEARCH_PATH_LIST
-  ${LIBCONFIG_HOME}
-  $ENV{LIBCONFIG_HOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(LIBCONFIG_INCLUDE_DIR libconfig.h++
-  HINTS ${LIBCONFIG_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the libconfig include"
-)
-
-if (WIN32)
-  if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-    find_library(LIBCONFIG_CPP_LIBRARIES NAMES libconfig++.lib
-      HINTS ${LIBCONFIG_SEARCH_PATH_LIST}
-      PATH_SUFFIXES lib/x64
-      DOC "Find the libconfig libraries"
-    )
-  elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
-    find_library(LIBCONFIG_CPP_LIBRARIES NAMES libconfig++.lib
-      HINTS ${LIBCONFIG_SEARCH_PATH_LIST}
-      PATH_SUFFIXES lib/x32
-      DOC "Find the libconfig libraries"
-    )
-  endif()
-else()
-  find_library(LIBCONFIG_CPP_LIBRARY NAMES config++
-    HINTS ${LIBCONFIG_SEARCH_PATH_LIST}
-    PATH_SUFFIXES lib
-    DOC "Find the libconfig++ libraries"
-  )
-endif()
-
-set(LIBCONFIG_CPP_LIBRARIES ${LIBCONFIG_CPP_LIBRARY})
-set(LIBCONFIG_INCLUDE_DIRS ${LIBCONFIG_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Libconfig++ LIBCONFIG_CPP_LIBRARIES LIBCONFIG_INCLUDE_DIRS)
-
-mark_as_advanced(LIBCONFIG_CPP_LIBRARIES LIBCONFIG_INCLUDE_DIRS)
diff --git a/cmake/Modules/FindLibconfig.cmake b/cmake/Modules/FindLibconfig.cmake
deleted file mode 100644
index 55d2a0fad..000000000
--- a/cmake/Modules/FindLibconfig.cmake
+++ /dev/null
@@ -1,43 +0,0 @@
-set(LIBCONFIG_SEARCH_PATH_LIST
-  ${LIBCONFIG_HOME}
-  $ENV{LIBCONFIG_HOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(LIBCONFIG_INCLUDE_DIR libconfig.h
-  HINTS ${LIBCONFIG_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the libconfig include"
-)
-
-if (WIN32)
-  if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-    find_library(LIBCONFIG_LIBRARY NAMES libconfig.lib
-      HINTS ${LIBCONFIG_SEARCH_PATH_LIST}
-      PATH_SUFFIXES lib/x64
-      DOC "Find the libconfig libraries"
-    )
-  elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
-    find_library(LIBCONFIG_LIBRARY NAMES libconfig.lib
-      HINTS ${LIBCONFIG_SEARCH_PATH_LIST}
-      PATH_SUFFIXES lib/x32
-      DOC "Find the libconfig libraries"
-    )
-  endif()
-else()
-  find_library(LIBCONFIG_LIBRARY NAMES config
-    HINTS ${LIBCONFIG_SEARCH_PATH_LIST}
-    PATH_SUFFIXES lib
-    DOC "Find the libconfig libraries"
-  )
-endif()
-
-set(LIBCONFIG_LIBRARIES ${LIBCONFIG_LIBRARY})
-set(LIBCONFIG_INCLUDE_DIRS ${LIBCONFIG_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Libconfig LIBCONFIG_LIBRARIES LIBCONFIG_INCLUDE_DIRS)
-
-mark_as_advanced(LIBCONFIG_LIBRARIES LIBCONFIG_INCLUDE_DIRS)
diff --git a/cmake/Modules/FindLibhicn.cmake b/cmake/Modules/FindLibhicn.cmake
deleted file mode 100644
index 5f241a6cd..000000000
--- a/cmake/Modules/FindLibhicn.cmake
+++ /dev/null
@@ -1,52 +0,0 @@
-# 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 the hcin libraries and includes
-# This module sets:
-#  HICN_FOUND: True if hicn was found
-#  HICN_LIBRARY:  The hicn library
-#  HICN_LIBRARIES:  The hicn library and dependencies
-#  HCIN_INCLUDE_DIR:  The hicn include dir
-#
-
-set(HICN_SEARCH_PATH_LIST
-  ${HICN_HOME}
-  $ENV{HICN_HOME}
-  $ENV{FOUNDATION_HOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(HICN_INCLUDE_DIR hicn/hicn.h
-  HINTS ${HICN_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the hicn includes"
-)
-
-find_library(HICN_LIBRARY NAMES hicn
-  HINTS ${HICN_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib
-  DOC "Find the hicn libraries"
-)
-
-set(HICN_LIBRARIES ${HICN_LIBRARY})
-if (${CMAKE_SYSTEM_NAME} STREQUAL "Android")
-  set(HICN_LIBRARIES ${HICN_LIBRARIES} log)
-endif()
-set(HICN_INCLUDE_DIRS ${HICN_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(hicn  DEFAULT_MSG HICN_LIBRARY HICN_INCLUDE_DIR)
diff --git a/cmake/Modules/FindLibhicnctrl.cmake b/cmake/Modules/FindLibhicnctrl.cmake
deleted file mode 100755
index 7c20420b4..000000000
--- a/cmake/Modules/FindLibhicnctrl.cmake
+++ /dev/null
@@ -1,45 +0,0 @@
-# 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 the hICN control library and include files
-#
-
-set(HICN_SEARCH_PATH_LIST
-  ${HICN_HOME}
-  $ENV{HICN_HOME}
-  $ENV{FOUNDATION_HOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(LIBHICNCTRL_INCLUDE_DIR hicn/ctrl.h
-  HINTS ${HICN_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the hICN control include"
-)
-
-find_library(LIBHICNCTRL_LIBRARY NAMES hicnctrl
-  HINTS ${HICN_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib
-  DOC "Find the hicn control library"
-)
-
-set(LIBHICNCTRL_LIBRARIES ${LIBHICNCTRL_LIBRARY})
-set(LIBHICNCTRL_INCLUDE_DIRS ${LIBHICNCTRL_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(hicnctrl DEFAULT_MSG
-        LIBHICNCTRL_LIBRARY LIBHICNCTRL_INCLUDE_DIR)
diff --git a/cmake/Modules/FindLibmemif.cmake b/cmake/Modules/FindLibmemif.cmake
deleted file mode 100644
index 48460eecd..000000000
--- a/cmake/Modules/FindLibmemif.cmake
+++ /dev/null
@@ -1,47 +0,0 @@
-# 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 the hcin libraries and includes
-# This module sets:
-#  LIBMEMIF_FOUND: True if core was found
-#  LIBMEMIF_LIBRARY:  The core library
-#  LIBMEMIF_INCLUDE_DIR:  The core include dir
-#
-
-set(LIBMEMIF_SEARCH_PATH_LIST
-  ${LIBMEMIF_HOME}
-  $ENV{LIBMEMIF_HOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(LIBMEMIF_INCLUDE_DIR memif/libmemif.h
-  HINTS ${LIBMEMIF_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the libmemif includes"
-)
-
-find_library(LIBMEMIF_LIBRARY NAMES memif
-  HINTS ${LIBMEMIF_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib
-  DOC "Find the libmemif libraries"
-)
-
-set(LIBMEMIF_LIBRARIES ${LIBMEMIF_LIBRARY})
-set(LIBMEMIF_INCLUDE_DIRS ${LIBMEMIF_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Libmemif DEFAULT_MSG LIBMEMIF_LIBRARY LIBMEMIF_INCLUDE_DIR)
diff --git a/cmake/Modules/FindLibparc.cmake b/cmake/Modules/FindLibparc.cmake
deleted file mode 100644
index c5c99af15..000000000
--- a/cmake/Modules/FindLibparc.cmake
+++ /dev/null
@@ -1,50 +0,0 @@
-# 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 the Libparc libraries and includes
-# This module sets:
-#  LIBPARC_FOUND: True if Libparc was found
-#  LIBPARC_LIBRARY:  The Libparc library
-#  LIBPARC_LIBRARIES:  The Libparc library and dependencies
-#  LIBPARC_INCLUDE_DIR:  The Libparc include dir
-#
-
-set(LIBPARC_SEARCH_PATH_LIST
-  ${LIBPARC_HOME}
-  $ENV{LIBPARC_HOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(LIBPARC_INCLUDE_DIR parc/libparc_About.h
-  HINTS ${LIBPARC_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the Libparc includes"
-)
-
-find_library(LIBPARC_LIBRARY NAMES parc
-  HINTS ${LIBPARC_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib
-  DOC "Find the Libparc libraries"
-)
-
-set(LIBPARC_LIBRARIES ${LIBPARC_LIBRARY})
-set(LIBPARC_INCLUDE_DIRS ${LIBPARC_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Libparc DEFAULT_MSG LIBPARC_LIBRARY LIBPARC_INCLUDE_DIR)
-
-mark_as_advanced(LIBPARC_LIBRARY LIBPARC_INCLUDE_DIR)
diff --git a/cmake/Modules/FindLibtransport.cmake b/cmake/Modules/FindLibtransport.cmake
deleted file mode 100644
index 8a650b98c..000000000
--- a/cmake/Modules/FindLibtransport.cmake
+++ /dev/null
@@ -1,49 +0,0 @@
-# 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 the LibTRANSPORT libraries and includes
-# This module sets:
-#  LIBTRANSPORT_FOUND: True if Libconsumer-producer was found
-#  LIBTRANSPORTR_LIBRARY:  The Libconsumer-producer library
-#  LIBTRANSPORT_LIBRARIES:  The Libconsumer-producer library and dependencies
-#  LIBTRANSPORT_INCLUDE_DIR:  The Libconsumer-producer include dir
-#
-
-set(LIBTRANSPORT_SEARCH_PATH_LIST
-  ${LIBTRANSPORT_HOME}
-  $ENV{LIBTRANSPORTHOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(LIBTRANSPORT_INCLUDE_DIR hicn/transport/config.h
-  HINTS ${LIBTRANSPORT_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the libtransport includes"
-)
-
-find_library(LIBTRANSPORT_LIBRARY
-  NAMES hicntransport hicntransport-memif
-  HINTS ${LIBTRANSPORT_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib
-  DOC "Find the libtransport libraries"
-)
-
-set(LIBTRANSPORT_LIBRARIES ${LIBTRANSPORT_LIBRARY})
-set(LIBTRANSPORT_INCLUDE_DIRS ${LIBTRANSPORT_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Libtransport DEFAULT_MSG LIBTRANSPORT_LIBRARIES LIBTRANSPORT_INCLUDE_DIRS)
\ No newline at end of file
diff --git a/cmake/Modules/FindLongBow.cmake b/cmake/Modules/FindLongBow.cmake
deleted file mode 100644
index 4a05d7fdf..000000000
--- a/cmake/Modules/FindLongBow.cmake
+++ /dev/null
@@ -1,55 +0,0 @@
-# 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 the LongBow libraries and includes
-# This module sets:
-#  LONGBOW_FOUND: True if LongBow was found
-#  LONGBOW_LIBRARY:  The LongBow library
-#  LONGBOW_LIBRARIES:  The LongBow library and dependencies
-#  LONGBOW_INCLUDE_DIR:  The LongBow include dir
-#
-
-set(LONGBOW_SEARCH_PATH_LIST
-  ${LONGBOW_HOME}
-  $ENV{LONGBOW_HOME}
-  $ENV{PARC_HOME}
-  $ENV{FOUNDATION_HOME}
-  /usr/local/parc
-  /usr/local/ccn
-  /usr/local
-  /opt
-  /usr
-  )
-
-find_path(LONGBOW_INCLUDE_DIR LongBow/longBow_About.h
-  HINTS ${LONGBOW_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the LongBow includes" )
-
-find_library(LONGBOW_LIBRARY NAMES longbow
-  HINTS ${LONGBOW_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib
-  DOC "Find the LongBow libraries" )
-
-find_library(LONGBOW_REPORT_LIBRARY NAMES longbow-textplain longbow-ansiterm
-  HINTS ${LONGBOW_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib
-  DOC "Find the LongBow report libraries" )
-
-set(LONGBOW_LIBRARIES ${LONGBOW_LIBRARY} ${LONGBOW_REPORT_LIBRARY})
-set(LONGBOW_INCLUDE_DIRS ${LONGBOW_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(LongBow  DEFAULT_MSG LONGBOW_LIBRARY LONGBOW_INCLUDE_DIR)
diff --git a/cmake/Modules/FindPThread.cmake b/cmake/Modules/FindPThread.cmake
deleted file mode 100644
index 6f0eeb7c0..000000000
--- a/cmake/Modules/FindPThread.cmake
+++ /dev/null
@@ -1,58 +0,0 @@
-# Copyright (c) 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 the PThread libraries and includes

-# This module sets:

-#  PTHREAD_FOUND: True if pthread was found

-#  PTHREADR_LIBRARY:  The pthread library

-#  PTHREAD_LIBRARIES:  The pthread library and dependencies

-#  PTHREAD_INCLUDE_DIR:  The pthread include dir

-#

-

-

-set(PTHREAD_SEARCH_PATH_LIST

-  ${PTHREAD_HOME}

-  $ENV{PTHREAD_HOME}

-  /usr/local

-  /opt

-  /usr

-)

-

-find_path(PTHREAD_INCLUDE_DIR pthread.h

-  HINTS ${PTHREAD_SEARCH_PATH_LIST}

-  PATH_SUFFIXES include

-  DOC "Find the pthreadincludes"

-)

-

-if(CMAKE_SIZEOF_VOID_P EQUAL 8)

-  find_library(PTHREAD_LIBRARY NAMES pthreadVC2.lib

-    HINTS ${PTHREAD_SEARCH_PATH_LIST}

-    PATH_SUFFIXES lib/x64

-    DOC "Find the pthread libraries"

-  )

-elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)

-  find_library(PTHREAD_LIBRARY NAMES pthreadVC2.lib

-    HINTS ${PTHREAD_SEARCH_PATH_LIST}

-    PATH_SUFFIXES lib/x32

-    DOC "Find the pthread libraries"

-  )

-endif()

-

-

-set(PTHREAD_LIBRARIES ${PTHREAD_LIBRARY})

-set(PTHREAD_INCLUDE_DIRS ${PTHREAD_INCLUDE_DIR})

-

-include(FindPackageHandleStandardArgs)

-find_package_handle_standard_args(Pthread DEFAULT_MSG PTHREAD_LIBRARIES PTHREAD_INCLUDE_DIRS)
\ No newline at end of file
diff --git a/cmake/Modules/FindSafeVapi.cmake b/cmake/Modules/FindSafeVapi.cmake
deleted file mode 100644
index a9077ae14..000000000
--- a/cmake/Modules/FindSafeVapi.cmake
+++ /dev/null
@@ -1,40 +0,0 @@
-# Copyright (c) 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.
-
-set(SAFE_VAPI_SEARCH_PATH_LIST
-  ${SAFE_VAPI_HOME}
-  $ENV{SAFE_VAPI_HOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(SAFE_VAPI_INCLUDE_DIR vapi/vapi_safe.h
-	HINTS ${SAFE_VAPI_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the vapi_safe includes"
-)
-
-find_library(SAFE_VAPI_LIBRARY NAMES libsafe_vapi.so
-	HINTS ${SAFE_VAPI_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib/x86_64-linux-gnu/
-  DOC "Find the vapi safe lib"
-)
-
-set(SAFE_VAPI_LIBRARIES ${SAFE_VAPI_LIBRARY})
-set(SAFE_VAPI_INCLUDE_DIRS ${SAFE_VAPI_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Hicnlight SAFE_VAPI_LIBRARIES SAFE_VAPI_INCLUDE_DIRS)
-
-mark_as_advanced(SAFE_VAPI_LIBRARY SAFE_VAPI_INCLUDE_DIR)
diff --git a/cmake/Modules/FindSysrepo.cmake b/cmake/Modules/FindSysrepo.cmake
deleted file mode 100644
index 1c389e480..000000000
--- a/cmake/Modules/FindSysrepo.cmake
+++ /dev/null
@@ -1,46 +0,0 @@
-# Copyright (c) 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.
-
-set(SYSREPO_SEARCH_PATH_LIST
-  ${SYSREPO_HOME}
-  $ENV{SYSREPO_HOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(SYSREPO_INCLUDE_DIR sysrepo/values.h
-	HINTS ${SYSREPO_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the sysrepo includes"
-)
-
-find_path(SYSREPO_INCLUDE_MAIN_DIR sysrepo.h
-	HINTS ${SYSREPO_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the sysrepo includes"
-)
-
-find_library(SYSREPO_LIBRARY NAMES libsysrepo.so
-	HINTS ${SYSREPO_SEARCH_PATH_LIST}
-    PATH_SUFFIXES lib
-  DOC "Find the sysrepo library"
-)
-
-set(SYSREPO_LIBRARIES ${SYSREPO_LIBRARY})
-set(SYSREPO_INCLUDE_DIRS ${SYSREPO_INCLUDE_DIR} ${SYSREPO_INCLUDE_MAIN_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Sysrepo DEFAULT_MSG SYSREPO_LIBRARIES SYSREPO_INCLUDE_DIRS)
-
-mark_as_advanced(SYSREPO_LIBRARY SYSREPO_INCLUDE_DIR SYSREPO_INCLUDE_MAIN_DIR)
diff --git a/cmake/Modules/FindVapiSafe.cmake b/cmake/Modules/FindVapiSafe.cmake
deleted file mode 100644
index c2c9fd762..000000000
--- a/cmake/Modules/FindVapiSafe.cmake
+++ /dev/null
@@ -1,40 +0,0 @@
-# Copyright (c) 2020 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.
-
-set(SAFE_VAPI_SEARCH_PATH_LIST
-  ${SAFE_VAPI_HOME}
-  $ENV{SAFE_VAPI_HOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(SAFE_VAPI_INCLUDE_DIR vapi/vapi_safe.h
-	HINTS ${SAFE_VAPI_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the vapi_safe includes"
-)
-
-find_library(SAFE_VAPI_LIBRARY NAMES libsafe_vapi.so
-	HINTS ${SAFE_VAPI_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib/x86_64-linux-gnu/
-  DOC "Find the vapi safe lib"
-)
-
-set(SAFE_VAPI_LIBRARIES ${SAFE_VAPI_LIBRARY})
-set(SAFE_VAPI_INCLUDE_DIRS ${SAFE_VAPI_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(VapiSafe DEFAULT_MSG SAFE_VAPI_LIBRARIES SAFE_VAPI_INCLUDE_DIRS)
-
-mark_as_advanced(SAFE_VAPI_LIBRARY SAFE_VAPI_INCLUDE_DIR)
diff --git a/cmake/Modules/FindVpp.cmake b/cmake/Modules/FindVpp.cmake
deleted file mode 100644
index 4f8dba17a..000000000
--- a/cmake/Modules/FindVpp.cmake
+++ /dev/null
@@ -1,95 +0,0 @@
-# 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.
-
-set(VPP_SEARCH_PATH_LIST
-  ${VPP_HOME}
-  $ENV{VPP_HOME}
-  /usr/local
-  /opt
-  /usr
-)
-
-find_path(VPP_INCLUDE_DIR vnet/vnet.h
-  HINTS ${VPP_SEARCH_PATH_LIST}
-  PATH_SUFFIXES include
-  DOC "Find the VPP includes"
-)
-
-find_library(VPP_LIBRARY_MEMORYCLIENT
-  NAMES vlibmemoryclient
-  HINTS ${VPP_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib lib64
-  DOC "Find the Vpp Memoryclient library"
-)
-
-find_library(VPP_LIBRARY_SVM
-  NAMES svm
-  HINTS ${VPP_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib lib64
-  DOC "Find the Vpp svm library"
-)
-
-find_library(VPP_LIBRARY_INFRA
-  NAMES vppinfra
-  HINTS ${VPP_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib lib64
-  DOC "Find the Vpp infra library"
-)
-
-find_library(VPP_LIBRARY_VNET
-  NAMES vnet
-  HINTS ${VPP_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib lib64
-  DOC "Find the Vpp vnet library"
-)
-
-find_library(VPP_LIBRARY_VATPLUGIN
-  NAMES vatplugin
-  HINTS ${VPP_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib lib64
-  DOC "Find the Vpp vatplugin library"
-)
-
-find_library(VPP_LIBRARY_VLIB
-  NAMES vlib
-  HINTS ${VPP_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib lib64
-  DOC "Find the Vpp vlib library"
-)
-
-find_library(VPP_LIBRARY_VPPAPICLIENT
-  NAMES vppapiclient
-  HINTS ${VPP_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib lib64
-  DOC "Find the Vpp api library"
-)
-
-find_library(VPP_LIBRARY_VAPICLIENT
-  NAMES vapiclient
-  HINTS ${VPP_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib lib64
-  DOC "Find the Vpp vapi library"
-)
-
-find_library(VPP_LIBRARY_VLIBMEMORY
-  NAMES vlibmemory
-  HINTS ${VPP_SEARCH_PATH_LIST}
-  PATH_SUFFIXES lib lib64
-  DOC "Find the Vpp vlibmemory library"
-)
-
-set(VPP_LIBRARIES ${VPP_LIBRARY_MEMORYCLIENT} ${VPP_LIBRARY_SVM} ${VPP_LIBRARY_INFRA} ${VPP_LIBRARY_VATPLUGIN} ${VPP_LIBRARY_VLIB} ${VPP_LIBRARY_VNET} ${VPP_LIBRARY_VAPICLIENT} ${VPP_LIBRARY_VLIBMEMORY})
-set(VPP_INCLUDE_DIRS ${VPP_INCLUDE_DIR} ${VPP_INCLUDE_DIR}/vpp_plugins)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Vpp DEFAULT_MSG VPP_LIBRARIES VPP_INCLUDE_DIRS)
diff --git a/cmake/Modules/GTestImport.cmake b/cmake/Modules/GTestImport.cmake
deleted file mode 100644
index d9d182578..000000000
--- a/cmake/Modules/GTestImport.cmake
+++ /dev/null
@@ -1,45 +0,0 @@
-# Copyright (c) 2020 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.
-
-##################################
-# Download and install GoogleTest
-
-include(ExternalProject)
-ExternalProject_Add(gtest
-  URL https://github.com/google/googletest/archive/v1.10.x.zip
-  PREFIX ${CMAKE_BINARY_DIR}/gtest
-  BUILD_BYPRODUCTS
-    ${CMAKE_BINARY_DIR}/gtest/src/gtest-build/lib/libgmock_main.a
-    ${CMAKE_BINARY_DIR}/gtest/src/gtest-build/lib/libgmock.a
-    ${CMAKE_BINARY_DIR}/gtest/src/gtest-build/lib/libgtest_main.a
-    ${CMAKE_BINARY_DIR}/gtest/src/gtest-build/lib/libgtest.a
-  INSTALL_COMMAND ""
-)
-
-ExternalProject_Get_Property(gtest source_dir binary_dir)
-
-message (STATUS "GTest include dir: ${source_dir}/googlemock/include ${source_dir}/googletest/include)")
-message (STATUS "GTest libs: ${binary_dir}/lib/libgmock_main.a ${binary_dir}/lib/libgmock.a ${binary_dir}/lib/libgtest_main.a ${binary_dir}/lib/libgtest.a")
-
-set(GTEST_INCLUDE_DIRS ${source_dir}/googlemock/include ${source_dir}/googletest/include)
-set(GTEST_LIBRARIES ${binary_dir}/lib/libgmock_main.a ${binary_dir}/lib/libgmock.a ${binary_dir}/lib/libgtest_main.a ${binary_dir}/lib/libgtest.a)
-
-macro(add_test_internal test)
-  if(${CMAKE_VERSION} VERSION_GREATER "3.10.0")
-    gtest_discover_tests(${test}-bin TEST_PREFIX new:)
-  else()
-    add_test(NAME ${test}-bin COMMAND ${test})
-  endif()
-endmacro(add_test_internal)
-
-enable_testing()
diff --git a/cmake/Modules/License.txt b/cmake/Modules/License.txt
deleted file mode 100644
index 4d84c0dc7..000000000
--- a/cmake/Modules/License.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-Copyright (c) 2017-2021 Cisco and/or its affiliates.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at:
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
\ No newline at end of file
diff --git a/cmake/Modules/Packager.cmake b/cmake/Modules/Packager.cmake
deleted file mode 100644
index 105952662..000000000
--- a/cmake/Modules/Packager.cmake
+++ /dev/null
@@ -1,344 +0,0 @@
-# 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.
-
-#############
-# RPM/DEB/TGZ Packaging utils
-#
-
-set(CONTACT "hicn-dev@lists.fd.io" CACHE STRING "Contact")
-set(PACKAGE_MAINTAINER "ICN Team" CACHE STRING "Maintainer")
-set(PACKAGE_VENDOR "fd.io" CACHE STRING "Vendor")
-
-function(get_next_version VERSION NEXT_VERSION)
-  string(REGEX REPLACE "([0-9]+).([0-9]+)" "\\1;\\2" VER_NUMBERS ${VERSION})
-
-  # Increment version for getting next version value
-  list(GET VER_NUMBERS 0 major)
-  list(GET VER_NUMBERS 1 minor)
-
-  math(EXPR minor "${minor} + 4")
-
-  if (minor GREATER 12)
-    math(EXPR minor "${minor} % 12")
-    math(EXPR major "${major} + 1")
-  endif()
-
-  if (minor LESS 10)
-    set(minor "0${minor}")
-  endif()
-
-  set(${NEXT_VERSION} "${major}.${minor}" PARENT_SCOPE)
-endfunction()
-
-macro(extract_version)
-  # Extract version from git
-  execute_process(
-    COMMAND git describe --long --match v*
-    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-    OUTPUT_VARIABLE VER
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-  )
-
-  if (NOT VER)
-    set(VER "v1.2-0-gcafe")
-  endif()
-  message(STATUS "Git describe output: ${VER}")
-
-  string(REGEX REPLACE "v([0-9]+).([0-9]+)-?(.*)?-([0-9]+)-(g[0-9a-f]+)" "\\1;\\2;\\3;\\4;\\5;" VER ${VER})
-  list(GET VER 0 VERSION_MAJOR)
-  list(GET VER 1 VERSION_MINOR)
-  list(GET VER 2 RELEASE_CANDIDATE)
-  list(GET VER 3 VERSION_REVISION)
-  list(GET VER 4 COMMIT_NAME)
-endmacro(extract_version)
-
-function(make_packages)
-  if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
-    # parse /etc/os-release
-    file(READ "/etc/os-release" os_version)
-    string(REPLACE "\n" ";" os_version ${os_version})
-    foreach(_ver ${os_version})
-      string(REPLACE "=" ";" _ver ${_ver})
-      list(GET _ver 0 _name)
-      list(GET _ver 1 _value)
-      set(OS_${_name} ${_value})
-    endforeach()
-
-    extract_version()
-
-    message(STATUS "Version major: ${VERSION_MAJOR}")
-    message(STATUS "Version minor: ${VERSION_MINOR}")
-    message(STATUS "Release: ${RELEASE_CANDIDATE}")
-    message(STATUS "Revision: ${VERSION_REVISION}")
-    message(STATUS "Commit hash: ${COMMIT_NAME}")
-
-    set(tag "${VERSION_MAJOR}.${VERSION_MINOR}")
-    string(REPLACE "-" "~" tag ${tag})
-    set(commit_num ${VERSION_REVISION})
-    set(commit_name ${COMMIT_NAME})
-
-    if (NOT DEFINED ENV{BUILD_NUMBER})
-      set(bld "b1")
-    else()
-      set(bld "b$ENV{BUILD_NUMBER}")
-    endif()
-    message(STATUS "Build number is: ${bld}")
-
-    #define DEB and RPM version numbers
-    if(NOT RELEASE_CANDIDATE)
-      if (commit_num)
-        set(deb_ver "${tag}.${commit_num}-release")
-        set(rpm_ver "${tag}.${commit_num}")
-      else()
-        set(deb_ver "${tag}-release")
-        set(rpm_ver "${tag}")
-      endif()
-      set(rpm_release "release")
-    else()
-      # TODO To be changed for next release with
-      #   set(deb_ver "${tag}${RELEASE_CANDIDATE}~${commit_num}")
-      #   set(rpm_ver "${tag}")
-      #   set(rpm_release "${RELEASE_CANDIDATE}~${commit_num}")
-      set(deb_ver "${tag}-${commit_num}")
-      set(rpm_ver "${tag}-${commit_num}")
-      set(rpm_release "1")
-    endif()
-
-    message(STATUS "Version: ${deb_ver}")
-
-    get_next_version(${tag} next_version)
-    message(STATUS "Next version: ${next_version}")
-
-    get_cmake_property(components COMPONENTS)
-    list(REMOVE_ITEM components "Unspecified")
-    set(CPACK_COMPONENTS_ALL ${components})
-
-    list(LENGTH components N_COMPONENTS)
-
-    if (NOT N_COMPONENTS)
-      return()
-    endif()
-
-    if(OS_ID MATCHES "debian" OR OS_ID_LIKE MATCHES "debian")
-      set(CPACK_GENERATOR "DEB")
-      set(type "DEBIAN")
-
-      execute_process(
-        COMMAND dpkg --print-architecture
-        OUTPUT_VARIABLE arch
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-      )
-
-      set(CPACK_${type}_PACKAGE_VERSION "${deb_ver}")
-      foreach(lc ${components})
-        if (${lc} MATCHES ".*Unspecified.*")
-          continue()
-        endif()
-
-        string(TOUPPER ${lc} uc)
-        set(CPACK_${type}_${uc}_FILE_NAME "${lc}_${deb_ver}_${arch}.deb")
-
-        set(DEB_DEPS)
-        if (NOT ${${lc}_DEB_DEPENDENCIES} STREQUAL "")
-          string(REPLACE "stable_version" ${tag} DEB_DEPS ${${lc}_DEB_DEPENDENCIES})
-          string(REPLACE "next_version" ${next_version} DEB_DEPS ${DEB_DEPS})
-        endif()
-
-        set(CPACK_${type}_${uc}_PACKAGE_DEPENDS "${DEB_DEPS}")
-        set(CPACK_${type}_${uc}_PACKAGE_NAME "${lc}")
-        set(CPACK_COMPONENT_${uc}_DESCRIPTION "${${lc}_DESCRIPTION}")
-
-        if (${lc}_DEB_PACKAGE_CONTROL_EXTRA)
-          set(CPACK_DEBIAN_${uc}_PACKAGE_CONTROL_EXTRA "${${lc}_DEB_PACKAGE_CONTROL_EXTRA}")
-        endif()
-      endforeach()
-    elseif(OS_ID_LIKE MATCHES "rhel")
-      set(CPACK_GENERATOR "RPM")
-      set(type "RPM")
-
-      execute_process(
-        COMMAND uname -m
-        OUTPUT_VARIABLE arch
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-      )
-
-      set(CPACK_${type}_PACKAGE_VERSION "${rpm_ver}")
-      set(CPACK_${type}_PACKAGE_RELEASE "${rpm_release}")
-      foreach(lc ${components})
-        if (${lc} MATCHES ".*Unspecified.*")
-          continue()
-        endif()
-
-        string(TOUPPER ${lc} uc)
-        set(CPACK_${type}_${uc}_DESCRIPTION "${${lc}_DESCRIPTION}")
-
-        set(RPM_DEPS)
-        if (NOT ${${lc}_RPM_DEPENDENCIES} STREQUAL "")
-          string(REPLACE "stable_version" ${tag} RPM_DEPS ${${lc}_RPM_DEPENDENCIES})
-          string(REPLACE "next_version" ${next_version} RPM_DEPS ${RPM_DEPS})
-        endif()
-
-        set(CPACK_${type}_${uc}_PACKAGE_REQUIRES "${RPM_DEPS}")
-
-        if(${lc} MATCHES ".*-dev")
-          set(package_name ${lc}el)
-        else()
-          set(package_name ${lc})
-        endif()
-
-        set(CPACK_RPM_${uc}_PACKAGE_NAME "${package_name}")
-        set(CPACK_${type}_${uc}_FILE_NAME "${package_name}-${rpm_ver}-${rpm_release}.${arch}.rpm")
-
-        if (NOT ${${lc}_RPM_POST_INSTALL_SCRIPT_FILE} STREQUAL "")
-          set(CPACK_RPM_${uc}_POST_INSTALL_SCRIPT_FILE "${${lc}_RPM_POST_INSTALL_SCRIPT_FILE}")
-        endif()
-
-        if (NOT ${${lc}_RPM_POST_UNINSTALL_SCRIPT_FILE} STREQUAL "")
-          set(CPACK_RPM_${uc}_POST_UNINSTALL_SCRIPT_FILE "${${lc}_RPM_POST_UNINSTALL_SCRIPT_FILE}")
-        endif()
-
-        if (NOT ${${lc}_RPM_PRE_UNINSTALL_SCRIPT_FILE} STREQUAL "")
-          set(CPACK_RPM_${uc}_PRE_UNINSTALL_SCRIPT_FILE "${${lc}_RPM_PRE_UNINSTALL_SCRIPT_FILE}")
-        endif()
-      endforeach()
-    endif()
-
-    if(CPACK_GENERATOR)
-      set(CPACK_PACKAGE_NAME ${ARG_NAME})
-      set(CPACK_STRIP_FILES OFF)
-      set(CPACK_PACKAGE_VENDOR "${PACKAGE_VENDOR}")
-      set(CPACK_COMPONENTS_IGNORE_GROUPS 1)
-      set(CPACK_${CPACK_GENERATOR}_COMPONENT_INSTALL ON)
-      set(CPACK_${type}_PACKAGE_MAINTAINER "HICN Team")
-      set(CPACK_PACKAGE_CONTACT ${CONTACT})
-      include(CPack)
-    endif()
-  elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin" OR ${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-    set(CMAKE_SKIP_BUILD_RPATH FALSE)
-    set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
-    set(CMAKE_INSTALL_RPATH /opt/hicn)
-
-    set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
-
-    set(CPACK_SET_DESTDIR true)
-
-    set(CMAKE_INSTALL_RPATH "\${CPACK_INSTALL_PREFIX}")
-    set(CMAKE_SKIP_INSTALL_RPATH FALSE)
-    set(HICN_DEPENDECIES_INSTALLER "${LIBTRANSPORT_LIBRARIES_LIST};${FACEMGR_LIBRARY_LIST};${APPS_LIBRARY_LIST}")
-    separate_arguments(HICN_DEPENDECIES_INSTALLER)
-    foreach (HICN_DEPENDECY ${HICN_DEPENDECIES_INSTALLER})
-      get_filename_component(DEPENDENCY_NAME "${HICN_DEPENDECY}" NAME)
-      get_filename_component(DEPENDENCY "${HICN_DEPENDECY}" REALPATH)
-      get_filename_component(DEPENDENCY_PATH "${DEPENDENCY}" DIRECTORY)
-      install(FILES ${DEPENDENCY} DESTINATION lib COMPONENT dependencies)
-    endforeach()
-    set(CPACK_PACKAGE_NAME "hicn")
-    extract_version()
-    set(CPACK_PACKAGE_VENDOR "${PACKAGE_VENDOR}")
-    set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "hICN")
-    set(CPACK_PACKAGE_VERSION "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REVISION}")
-    set(CPACK_PACKAGE_VERSION_MAJOR "${VERSION_MAJOR}")
-    set(CPACK_PACKAGE_VERSION_MINOR "${VERSION_MINOR}")
-    set(CPACK_PACKAGE_VERSION_PATCH "${VERSION_REVISION}")
-    set(CPACK_PACKAGE_INSTALL_DIRECTORY "hICN Components")
-
-    set(CPACK_COMPONENTS_ALL dependencies ${HICN_UTILS} ${HICN_LIGHT} ${HICN_APPS} ${FACEMGR} lib${LIBTRANSPORT} ${LIBTRANSPORT}-dev lib${LIBHICN} ${LIBHICN}-dev ${HICN_UTILS}-dev ${HICN_LIGHT}-dev ${HICN_APPS}-dev ${FACEMGR}-dev)
-    set(CPACK_COMPONENT_DEPENDENCIES_DISPLAY_NAME "Dependencies")
-    if (NOT "${HICN_UTILS}" STREQUAL "")
-      string(TOUPPER ${HICN_UTILS} HICN_UTILS_UPPERCASE)
-      string(TOUPPER ${HICN_UTILS}-dev HICN_UTILS_DEV_UPPERCASE)
-      set(CPACK_COMPONENT_${HICN_UTILS_UPPERCASE}_DISPLAY_NAME "hICN utils")
-      set(CPACK_COMPONENT_${HICN_UTILS_DEV_UPPERCASE}_DISPLAY_NAME "hicn utils headers")
-      set(CPACK_COMPONENT_${HICN_UTILS_UPPERCASE}_GROUP "Executables")
-      set(CPACK_COMPONENT_${HICN_UTILS_DEV_UPPERCASE}_GROUP "Headers")
-      set(CPACK_COMPONENT_${HICN_UTILS_UPPERCASE}_INSTALL_TYPES Full)
-      set(CPACK_COMPONENT_${HICN_UTILS_DEV_UPPERCASE}_INSTALL_TYPES Full)
-    endif ()
-
-    if (NOT "${HICN_LIGHT}" STREQUAL "")
-      string(TOUPPER ${HICN_LIGHT} HICN_LIGHT_UPPERCASE)
-      string(TOUPPER ${HICN_LIGHT}-dev HICN_LIGHT_DEV_UPPERCASE)
-      set(CPACK_COMPONENT_${HICN_LIGHT_UPPERCASE}_DISPLAY_NAME "hICN light apps")
-      set(CPACK_COMPONENT_${HICN_LIGHT_DEV_UPPERCASE}_DISPLAY_NAME "hicn-light headers")
-      set(CPACK_COMPONENT_${HICN_LIGHT_UPPERCASE}_GROUP "Executables")
-      set(CPACK_COMPONENT_${HICN_LIGHT_DEV_UPPERCASE}_GROUP "Headers")
-      set(CPACK_COMPONENT_${HICN_LIGHT_UPPERCASE}_INSTALL_TYPES Full)
-      set(CPACK_COMPONENT_${HICN_LIGHT_DEV_UPPERCASE}_INSTALL_TYPES Full)
-    endif ()
-
-    if (NOT "${HICN_APPS}" STREQUAL "")
-      string(TOUPPER ${HICN_APPS} HICN_APPS_UPPERCASE)
-      string(TOUPPER ${HICN_APPS}-dev HICN_APPS_DEV_UPPERCASE)
-      set(CPACK_COMPONENT_${HICN_APPS_UPPERCASE}_DISPLAY_NAME "hICN apps")
-      set(CPACK_COMPONENT_${HICN_APPS_DEV_UPPERCASE}_DISPLAY_NAME "hicn-apps headers")
-      set(CPACK_COMPONENT_${HICN_APPS_UPPERCASE}_GROUP "Executables")
-      set(CPACK_COMPONENT_${HICN_APPS_DEV_UPPERCASE}_GROUP "Headers")
-      set(CPACK_COMPONENT_${HICN_APPS_UPPERCASE}_INSTALL_TYPES Full)
-      set(CPACK_COMPONENT_${HICN_APPS_DEV_UPPERCASE}_INSTALL_TYPES Full)
-    endif ()
-
-    if (NOT "${FACEMGR}" STREQUAL "")
-      string(TOUPPER ${FACEMGR} FACEMGR_UPPERCASE)
-      string(TOUPPER ${FACEMGR}-dev FACEMGR_DEV_UPPERCASE)
-      set(CPACK_COMPONENT_${FACEMGR_UPPERCASE}_DISPLAY_NAME "facemgr")
-      set(CPACK_COMPONENT_${FACEMGR_DEV_UPPERCASE}_DISPLAY_NAME "facemgr headers")
-      set(CPACK_COMPONENT_${FACEMGR_UPPERCASE}_GROUP "Executables")
-      set(CPACK_COMPONENT_${FACEMGR_DEV_UPPERCASE}_GROUP "Headers")
-      set(CPACK_COMPONENT_${FACEMGR_UPPERCASE}_INSTALL_TYPES Full)
-      set(CPACK_COMPONENT_${FACEMGR_DEV_UPPERCASE}_INSTALL_TYPES Full)
-    endif ()
-
-    if (NOT "${LIBTRANSPORT}" STREQUAL "")
-      string(TOUPPER lib${LIBTRANSPORT} LIBTRANSPORT_UPPERCASE)
-      string(TOUPPER ${LIBTRANSPORT}-dev LIBTRANSPORT_DEV_UPPERCASE)
-      set(CPACK_COMPONENT_${LIBTRANSPORT_UPPERCASE}_DISPLAY_NAME "libtransport libs")
-      set(CPACK_COMPONENT_${LIBTRANSPORT_DEV_UPPERCASE}_DISPLAY_NAME "libtransport headers")
-      set(CPACK_COMPONENT_${LIBTRANSPORT_UPPERCASE}_GROUP "Libraries")
-      set(CPACK_COMPONENT_${LIBTRANSPORT_DEV_UPPERCASE}_GROUP "Headers")
-      set(CPACK_COMPONENT_${LIBTRANSPORT_UPPERCASE}_INSTALL_TYPES Full)
-      set(CPACK_COMPONENT_${LIBTRANSPORT_DEV_UPPERCASE}_INSTALL_TYPES Full)
-    endif ()
-
-    if (NOT "${LIBHICN}" STREQUAL "")
-      string(TOUPPER lib${LIBHICN} LIBHICN_UPPERCASE)
-      string(TOUPPER ${LIBHICN}-dev LIBHICN_DEV_UPPERCASE)
-      set(CPACK_COMPONENT_${LIBHICN_UPPERCASE}_DISPLAY_NAME "hicn libs")
-      set(CPACK_COMPONENT_${LIBHICN_DEV_UPPERCASE}_DISPLAY_NAME "hicn headers")
-      set(CPACK_COMPONENT_${LIBHICN_UPPERCASE}_GROUP "Libraries")
-      set(CPACK_COMPONENT_${LIBHICN_DEV_UPPERCASE}_GROUP "Headers")
-      set(CPACK_COMPONENT_${LIBHICN_UPPERCASE}_INSTALL_TYPES Full)
-      set(CPACK_COMPONENT_${LIBHICN_DEV_UPPERCASE}_INSTALL_TYPES Full)
-    endif ()
-
-    set (CPACK_RESOURCE_FILE_LICENSE
-        "${PROJECT_SOURCE_DIR}/cmake/Modules/License.txt")
-    set(CPACK_COMPONENT_DEPENDENCIES_DESCRIPTION
-      "All dependency libreries")
-    set(CPACK_COMPONENT_DEPENDENCIES_GROUP "Dependencies")
-    set(CPACK_COMPONENT_GROUP_DEVELOPMENT_EXPANDED ON)
-    set(CPACK_COMPONENT_GROUP_DEPENDENCIES_DESCRIPTION
-      "All dependency libreries")
-    set(CPACK_ALL_INSTALL_TYPES Full Developer)
-    set(CPACK_INSTALL_TYPE_FULL_DISPLAY_NAME "Everything")
-    if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-      set(CMAKE_INSTALL_RPATH /opt/hicn)
-
-      set(CPACK_INSTALL_PREFIX "/opt/hicn")
-      set(CPACK_GENERATOR productbuild)
-      set( CPACK_PRE_BUILD_SCRIPTS "${PROJECT_SOURCE_DIR}/cmake/Modules/PostInstall.cmake")
-    else()
-      set(CPACK_INSTALL_PREFIX "c:/Program Files/hicn")
-    endif()
-    include(CPack)
-  endif()
-endfunction()
diff --git a/cmake/Modules/PostInstall.cmake b/cmake/Modules/PostInstall.cmake
deleted file mode 100644
index 89c7b9f68..000000000
--- a/cmake/Modules/PostInstall.cmake
+++ /dev/null
@@ -1,83 +0,0 @@
-function(change_rpath LIB_PATH TYPE)
-    execute_process (
-        COMMAND bash -c "ls ${LIB_PATH}"
-        OUTPUT_VARIABLE ITEMS
-    )
-    string(REPLACE "\n" ";" ITEMS ${ITEMS})
-
-    separate_arguments(ITEMS)
-    foreach (ITEM ${ITEMS})
-        if (NOT ITEM MATCHES ".a$")
-            if (TYPE STREQUAL "LIB")
-                execute_process (
-                    COMMAND bash -c "otool -L ${LIB_PATH}/${ITEM} | head -2 | tail -1| sed -e 's/^[[:space:]]*//'|awk '{print $1;}'"
-                    OUTPUT_VARIABLE OTOOL_OUTPUT
-                )
-                string(REPLACE "\n" "" OTOOL_OUTPUT ${OTOOL_OUTPUT})
-
-                execute_process (
-                    COMMAND bash -c "basename ${OTOOL_OUTPUT}| sed -e 's/^[[:space:]]*//'"
-                    OUTPUT_VARIABLE BASENAME
-                )
-                string(REPLACE "\n" "" BASENAME ${BASENAME})
-                execute_process (
-                        COMMAND bash -c "install_name_tool -id ${CPACK_INSTALL_PREFIX}/${BASENAME} ${LIB_PATH}/${ITEM}"
-                        OUTPUT_VARIABLE OUTPUT_INSTALL_NAME_TOOL
-                    )
-                #change rpath
-                execute_process (
-                    COMMAND bash -c "otool -L ${LIB_PATH}/${ITEM} | tail -n +3| sed -e 's/^[[:space:]]*//'|awk '{print $1;}'"
-                    OUTPUT_VARIABLE OTOOL_OUTPUTS
-                )
-            else ()
-                #change rpath
-                execute_process (
-                    COMMAND bash -c "otool -L ${LIB_PATH}/${ITEM} | tail -n +2| sed -e 's/^[[:space:]]*//'|awk '{print $1;}'"
-                    OUTPUT_VARIABLE OTOOL_OUTPUTS
-                )
-            endif ()
-            string(REPLACE "\n" ";" OTOOL_OUTPUTS ${OTOOL_OUTPUTS})
-            separate_arguments(OTOOL_OUTPUTS)
-            foreach (OTOOL_OUTPUT ${OTOOL_OUTPUTS})
-                execute_process (
-                    COMMAND bash -c "basename ${OTOOL_OUTPUT}| sed -e 's/^[[:space:]]*//'"
-                    OUTPUT_VARIABLE BASENAME
-                )
-                string(REPLACE "\n" "" BASENAME ${BASENAME})
-                execute_process (
-                    COMMAND bash -c "dirname ${OTOOL_OUTPUT}| sed -e 's/^[[:space:]]*//'"
-                    OUTPUT_VARIABLE DIRNAME
-                )
-                string(REPLACE "\n" "" DIRNAME ${DIRNAME})
-                if(NOT DIRNAME MATCHES "/usr/lib")
-                    execute_process (
-                        COMMAND bash -c "install_name_tool -change ${OTOOL_OUTPUT} ${CPACK_INSTALL_PREFIX}/${BASENAME} ${LIB_PATH}/${ITEM}"
-                        OUTPUT_VARIABLE OUTPUT_INSTALL_NAME_TOOL
-                    )
-                endif()
-
-            endforeach()
-        endif()
-    endforeach()
-endfunction()
-string(TOLOWER ${CPACK_COMPONENT_DEPENDENCIES_GROUP} CPACK_COMPONENT_DEPENDENCIES_GROUP )
-set(LIB_PATH "${CPACK_TEMPORARY_DIRECTORY}/${CPACK_COMPONENT_DEPENDENCIES_GROUP}${CPACK_INSTALL_PREFIX}/lib")
-change_rpath(${LIB_PATH} LIB)
-
-set(LIB_PATH "${CPACK_TEMPORARY_DIRECTORY}/facemgr${CPACK_INSTALL_PREFIX}/lib")
-change_rpath(${LIB_PATH} LIB)
-set(LIB_PATH "${CPACK_TEMPORARY_DIRECTORY}/libhicntransport${CPACK_INSTALL_PREFIX}/lib")
-change_rpath(${LIB_PATH} LIB)
-set(LIB_PATH "${CPACK_TEMPORARY_DIRECTORY}/libhicn${CPACK_INSTALL_PREFIX}/lib")
-change_rpath(${LIB_PATH} LIB)
-
-set(EXE_PATH "${CPACK_TEMPORARY_DIRECTORY}/hicn-utils${CPACK_INSTALL_PREFIX}/bin")
-change_rpath(${EXE_PATH} EXE)
-set(EXE_PATH "${CPACK_TEMPORARY_DIRECTORY}/hicn-light${CPACK_INSTALL_PREFIX}/bin")
-change_rpath(${EXE_PATH} EXE)
-set(EXE_PATH "${CPACK_TEMPORARY_DIRECTORY}/hicn-apps${CPACK_INSTALL_PREFIX}/bin")
-change_rpath(${EXE_PATH} EXE)
-set(EXE_PATH "${CPACK_TEMPORARY_DIRECTORY}/facemgr${CPACK_INSTALL_PREFIX}/bin")
-change_rpath(${EXE_PATH} EXE)
-#set(EXE_PATH "${CPACK_TEMPORARY_DIRECTORY}/hicnctrl${CPACK_INSTALL_PREFIX}/bin")
-#change_rpath(${EXE_PATH} EXE)
diff --git a/cmake/Modules/ServiceScript.cmake b/cmake/Modules/ServiceScript.cmake
deleted file mode 100644
index 8e7056a5a..000000000
--- a/cmake/Modules/ServiceScript.cmake
+++ /dev/null
@@ -1,42 +0,0 @@
-# Copyright (c) 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 the LongBow libraries and includes
-# This module sets:
-#  SYSTEMD_FOUND: True if Systemd was found
-#  SYSTEMD_SERVICES_INSTALL_DIR:  The Systemd install directory
-
-set(SYSTEMD_SERVICE_FOLDER "/lib/systemd/system")
-
-macro(install_service_script script)
-cmake_parse_arguments(ARG
-  ""
-  "COMPONENT"
-  ""
-  ${ARGN}
-)
-
-  # Install service file only if
-  # 1) We are on a linux system
-  # 2) The installation prefix is /usr
-
-  if (NOT ARG_COMPONENT)
-    set(ARG_COMPONENT hicn)
-  endif()
-
-  if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux" AND ${CMAKE_INSTALL_PREFIX} STREQUAL "/usr")
-    install (FILES ${script} DESTINATION ${SYSTEMD_SERVICE_FOLDER} COMPONENT ${ARG_COMPONENT})
-  endif()
-endmacro(install_service_script)
diff --git a/cmake/Modules/WindowsMacros.cmake b/cmake/Modules/WindowsMacros.cmake
deleted file mode 100644
index 0b34cde19..000000000
--- a/cmake/Modules/WindowsMacros.cmake
+++ /dev/null
@@ -1,33 +0,0 @@
-# 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(WIN32)
-  find_package(LibEvent REQUIRED)
-  find_package(OpenSSL REQUIRED)
-  find_package(PThread REQUIRED)
-  find_library(WSOCK32_LIBRARY wsock32 required)
-  find_library(WS2_32_LIBRARY ws2_32 required)
-  list(APPEND WINDOWS_LIBRARIES
-    ${LIBEVENT_LIBRARIES}
-    ${OPENSSL_LIBRARIES}
-    ${PTHREAD_LIBRARIES}
-    ${WSOCK32_LIBRARY}
-    ${WS2_32_LIBRARY}
-  )
-
-  list(APPEND WINDOWS_INCLUDE_DIRS
-    ${LIBEVENT_INCLUDE_DIRS}
-    ${OPENSSL_INCLUDE_DIR}
-    ${PTHREAD_INCLUDE_DIRS}
-  )
-endif()
\ No newline at end of file
diff --git a/cmake/Modules/detectCacheSize.cmake b/cmake/Modules/detectCacheSize.cmake
deleted file mode 100644
index a8209bb27..000000000
--- a/cmake/Modules/detectCacheSize.cmake
+++ /dev/null
@@ -1,21 +0,0 @@
-# Detect the cache size
-#
-# XXX: TODO: This is a bug when cross compiling. We are detecting the local
-# Cache Line size and not the target cache line size.  We should provide some
-# way to define this
-
-set(LEVEL1_DCACHE_LINESIZE 32)
-
-if( APPLE )
-  execute_process(COMMAND sysctl -n hw.cachelinesize
-	OUTPUT_VARIABLE LEVEL1_DCACHE_LINESIZE
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
-endif( APPLE )
-
-if( ${CMAKE_SYSTEM_NAME} STREQUAL "Linux" )
-  execute_process(COMMAND getconf LEVEL1_DCACHE_LINESIZE
-	OUTPUT_VARIABLE LEVEL1_DCACHE_LINESIZE
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
-endif()
-
-message(STATUS "Cache line size: ${LEVEL1_DCACHE_LINESIZE}")
diff --git a/libtransport/cmake/Modules/TestMacros.cmake b/ctrl/.clang-format
index 680b5585f..2f629734d 100644
--- a/libtransport/cmake/Modules/TestMacros.cmake
+++ b/ctrl/.clang-format
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,5 +11,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-include(CTest)
-
+BasedOnStyle: Google
+SortIncludes: false
diff --git a/ctrl/CMakeLists.txt b/ctrl/CMakeLists.txt
index 331ae9078..d6fe72d3e 100644
--- a/ctrl/CMakeLists.txt
+++ b/ctrl/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -10,13 +10,17 @@
 # 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.
-
+##############################################################
+# Project and cmake version
+##############################################################
 cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
-
 project(ctrl)
 
-add_subdirectory(libhicnctrl)
 
-if (NOT (BUILD_HICNPLUGIN AND "${CMAKE_SYSTEM_NAME}" STREQUAL "Linux"))
-    add_subdirectory(facemgr)
+##############################################################
+# Subdirectories
+##############################################################
+add_subdirectory(libhicnctrl)
+if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" OR "${CMAKE_SYSTEM_NAME}" STREQUAL "Android")
+  add_subdirectory(facemgr)
 endif ()
\ No newline at end of file
diff --git a/ctrl/facemgr/CMakeLists.txt b/ctrl/facemgr/CMakeLists.txt
index 2fad5d839..9d549bddf 100644
--- a/ctrl/facemgr/CMakeLists.txt
+++ b/ctrl/facemgr/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,62 +11,98 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+##############################################################
+# Project and cmake version
+##############################################################
+project(facemgr)
+
 if (APPLE)
-    # >= 3.13 - CMP0079 (only needed on Apple platform for conditionally linking Network.framwork to libfacemgr)
-    cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
+  # >= 3.13 - CMP0079 (only needed on Apple platform for conditionally linking Network.framwork to libfacemgr)
+  cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
 else()
-    cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
+  cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
 endif()
 
-project(facemgr)
 
+##############################################################
+# C Standard
+##############################################################
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+##############################################################
+# CMAKE Options
+##############################################################
 option(WITH_THREAD "Run library as thread" OFF)
 option(WITH_EXAMPLE_DUMMY "Compile dummy example interface" OFF)
 option(WITH_EXAMPLE_UPDOWN "Compile updown example interface" OFF)
 
 if(WITH_THREAD)
-    message("Building with thread support")
+  message(STATUS "Building with thread support")
 endif()
 
 if(WITH_EXAMPLE_DUMMY)
-    message("Building with 'dummy' example interface")
+  message(STATUS "Building with 'dummy' example interface")
 endif()
 
 if(WITH_EXAMPLE_UPDOWN)
-    message("Building with 'updown' example interface")
-endif()
-
-if (NOT CMAKE_BUILD_TYPE)
-    message(STATUS "${PROJECT_NAME}: No build type selected, default to Release")
-    set(CMAKE_BUILD_TYPE "Release")
+  message(STATUS "Building with 'updown' example interface")
 endif()
 
 if(CMAKE_BUILD_TYPE MATCHES Debug)
   set(CMAKE_C_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -ggdb3")
 endif()
 
+
+##############################################################
+# Cmake modules
+##############################################################
 set(CMAKE_MODULE_PATH
   ${CMAKE_MODULE_PATH}
   "${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/Modules"
-  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
 )
 
-include(BuildMacros)
 
-set(CMAKE_C_STANDARD 11)
-set(CMAKE_C_STANDARD_REQUIRED ON)
+##############################################################
+# Libs and Bins names
+##############################################################
+set(FACEMGR facemgr CACHE INTERNAL "" FORCE)
+set(LIBFACEMGR facemgr CACHE INTERNAL "" FORCE)
+
+
+##############################################################
+# Packaging and versioning
+##############################################################
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../versions.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/packaging.cmake)
 
 set(CMAKE_INSTALL_RPATH_USE_LINK_PATH ON)
 
-find_package_wrapper(Libconfig REQUIRED)
-find_package_wrapper(LibEvent REQUIRED)
 
-set(FACEMGR facemgr CACHE INTERNAL "" FORCE)
-set(LIBFACEMGR facemgr CACHE INTERNAL "" FORCE)
+##############################################################
+# Dependencies and third party libs
+##############################################################
+find_package(Libconfig ${LIBCONFIG_DEFAULT_VERSION} REQUIRED)
+find_package(LibEvent ${LIBEVENT_DEFAULT_VERSION} REQUIRED)
+
 
+##############################################################
+# Check if building as subproject or as root project
+##############################################################
 if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-  find_package_wrapper(Libhicn REQUIRED)
-  find_package_wrapper(Libhicnctrl REQUIRED)
+  include(CommonSetup)
+
+  find_package(Libhicn ${CURRENT_VERSION} REQUIRED NO_MODULE)
+  find_package(Libhicnctrl ${CURRENT_VERSION} REQUIRED NO_MODULE)
+
+  if (DISABLE_SHARED_LIBRARIES)
+    set(LIBTYPE static)
+  else()
+    set(LIBTYPE shared)
+  endif()
+
+  list(APPEND HICN_LIBRARIES hicn::hicn.${LIBTYPE})
+  list(APPEND LIBHICNCTRL_LIBRARIES hicn::hicnctrl.${LIBTYPE})
 else()
   if (DISABLE_SHARED_LIBRARIES)
     if (WIN32)
@@ -89,11 +125,18 @@ else()
   endif ()
 endif()
 
+
+##############################################################
+# Subdirectories
+##############################################################
 add_subdirectory(includes)
 add_subdirectory(src)
 
-include(Packaging)
 
+
+##############################################################
+# Service file
+##############################################################
 # Install service file in linux systems
 include(ServiceScript)
 install_service_script(
@@ -101,14 +144,23 @@ install_service_script(
   COMPONENT ${FACEMGR}
 )
 
+
+##############################################################
 # Configuration file
+##############################################################
 set(FACEMGR_CONF_FILE ${CMAKE_CURRENT_SOURCE_DIR}/config/facemgr.conf)
-set(FACEMGR_CONF_FOLDER "/etc/facemgr")
-if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-  install (FILES ${FACEMGR_CONF_FILE} DESTINATION ${FACEMGR_CONF_FOLDER} COMPONENT ${FACEMGR})
+if (${CMAKE_SYSTEM_NAME} MATCHES Darwin OR ${CMAKE_SYSTEM_NAME} MATCHES Linux)
+  set(FACEMGR_CONF_FOLDER "${CMAKE_INSTALL_FULL_SYSCONFDIR}/facemgr")
+else ()
+  set(FACEMGR_CONF_FOLDER "${CMAKE_INSTALL_PREFIX}/etc/hicn")
 endif()
 
+install (FILES
+  ${FACEMGR_CONF_FILE}
+  DESTINATION ${FACEMGR_CONF_FOLDER}
+  COMPONENT ${FACEMGR}
+)
+
 if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-    include(Packager)
-    make_packages()
+  make_packages()
 endif()
diff --git a/ctrl/facemgr/cmake/Modules/Packaging.cmake b/ctrl/facemgr/cmake/packaging.cmake
index bb4fa42fa..62b14b202 100644
--- a/ctrl/facemgr/cmake/Modules/Packaging.cmake
+++ b/ctrl/facemgr/cmake/packaging.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -20,27 +20,37 @@ set(${FACEMGR}_DESCRIPTION
   CACHE STRING "Description for deb/rpm package."
 )
 
+set(${FACEMGR}-dev_DEB_DEPENDENCIES
+  "libconfig9, libevent-dev, lib${LIBHICNCTRL}-dev (= stable_version)"
+  CACHE STRING "Dependencies for deb/rpm package."
+)
+
 set(${FACEMGR}_DEB_DEPENDENCIES
-  "libconfig9, libevent-dev, lib${LIBHICNCTRL} (>= stable_version)"
+  "libconfig9, libevent-2.1-7, lib${LIBHICNCTRL} (= stable_version)"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
-set(${HICN_LIGHT}_DEB_PACKAGE_CONTROL_EXTRA
+set(${FACEMGR}_DEB_PACKAGE_CONTROL_EXTRA
   "${CMAKE_CURRENT_SOURCE_DIR}/config/postinst;${CMAKE_CURRENT_SOURCE_DIR}/config/prerm"
   CACHE STRING "Control scripts conffiles, postinst, postrm, prerm."
 )
 
 set(${FACEMGR}_RPM_DEPENDENCIES
-  "libconfig, libevent-devel, lib${LIBHICNCTRL} >= stable_version"
+  "libconfig, libevent, lib${LIBHICNCTRL} = stable_version"
+  CACHE STRING "Dependencies for deb/rpm package."
+)
+
+set(${FACEMGR}-dev_RPM_DEPENDENCIES
+  "libconfig, libevent-devel, lib${LIBHICNCTRL}-dev = stable_version"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
-set(${HICN_LIGHT}_RPM_POST_INSTALL_SCRIPT_FILE
+set(${FACEMGR}_RPM_POST_INSTALL_SCRIPT_FILE
   "${CMAKE_CURRENT_SOURCE_DIR}/config/post"
   CACHE STRING "Install script that will be copied in the %post section"
 )
 
-set(${HICN_LIGHT}_RPM_PRE_UNINSTALL_SCRIPT_FILE
+set(${FACEMGR}_RPM_PRE_UNINSTALL_SCRIPT_FILE
   "${CMAKE_CURRENT_SOURCE_DIR}/config/preun"
   CACHE STRING "Install script that will be copied in the %post section"
 )
diff --git a/ctrl/facemgr/config/facemgr.service b/ctrl/facemgr/config/facemgr.service
index 0f9e818ea..89d4f9283 100644
--- a/ctrl/facemgr/config/facemgr.service
+++ b/ctrl/facemgr/config/facemgr.service
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/ctrl/facemgr/config/postinst b/ctrl/facemgr/config/postinst
index 4113b0eca..7b2fd57fe 100755
--- a/ctrl/facemgr/config/postinst
+++ b/ctrl/facemgr/config/postinst
@@ -1,3 +1,5 @@
 #!/bin/bash
 
-systemctl enable facemgr
+if pidof systemd; then
+  systemctl enable facemgr
+fi
diff --git a/ctrl/facemgr/config/prerm b/ctrl/facemgr/config/prerm
index b5c486ea5..8c0eadf0d 100755
--- a/ctrl/facemgr/config/prerm
+++ b/ctrl/facemgr/config/prerm
@@ -1,3 +1,5 @@
 #!/bin/bash
 
-systemctl disable facemgr
+if pidof systemd; then
+  systemctl disable facemgr
+fi
diff --git a/ctrl/facemgr/config/preun b/ctrl/facemgr/config/preun
index b5c486ea5..8c0eadf0d 100755
--- a/ctrl/facemgr/config/preun
+++ b/ctrl/facemgr/config/preun
@@ -1,3 +1,5 @@
 #!/bin/bash
 
-systemctl disable facemgr
+if pidof systemd; then
+  systemctl disable facemgr
+fi
diff --git a/ctrl/facemgr/examples/mobility/mobility.c b/ctrl/facemgr/examples/mobility/mobility.c
index 528951446..ae1d6dee3 100644
--- a/ctrl/facemgr/examples/mobility/mobility.c
+++ b/ctrl/facemgr/examples/mobility/mobility.c
@@ -7,82 +7,81 @@
  * Test server using nc: nc -4kvul localhost 9533
  */
 
-#include <arpa/inet.h> // inet_ntop
-#include <errno.h> // EINTR,. ..
-#include <netinet/in.h> // INET_ADDRSTRLEN, INET6_ADDRSTRLEN
+#include <arpa/inet.h>   // inet_ntop
+#include <errno.h>       // EINTR,. ..
+#include <netinet/in.h>  // INET_ADDRSTRLEN, INET6_ADDRSTRLEN
 #include <stdio.h>
 #include <inttypes.h>
 
 #include <stdlib.h>
 #include <sys/socket.h>
 #include <sys/timerfd.h>
-#include <sys/un.h> // sockaddr_un
-#include <unistd.h> // fcntl
-#include <fcntl.h> // fcntl
+#include <sys/un.h>  // sockaddr_un
+#include <unistd.h>  // fcntl
+#include <fcntl.h>   // fcntl
 
 #define MS2US(x) (x * 1000)
 
 /**
  * \brief Main function
  */
-int main(int argc, char **argv)
-{
-    int rc;
+int main(int argc, char **argv) {
+  int rc;
 
-    if (argc != 4) {
-        fprintf(stderr, "Usage: %s IP PORT INTERVAL\n", argv[0]);
-        fprintf(stderr, "\n");
-        fprintf(stderr, "    IP       Target hostname\n");
-        fprintf(stderr, "    PORT     Target port\n");
-        fprintf(stderr, "    INTERVAL Interval between mobility events (in ms)\n");
-        fprintf(stderr, "\n");
-        exit(EXIT_FAILURE);
-    }
+  if (argc != 4) {
+    fprintf(stderr, "Usage: %s IP PORT INTERVAL\n", argv[0]);
+    fprintf(stderr, "\n");
+    fprintf(stderr, "    IP       Target hostname\n");
+    fprintf(stderr, "    PORT     Target port\n");
+    fprintf(stderr, "    INTERVAL Interval between mobility events (in ms)\n");
+    fprintf(stderr, "\n");
+    exit(EXIT_FAILURE);
+  }
 
-    int interval = atoi(argv[3]);
+  int interval = atoi(argv[3]);
 
-    int fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-    if (fd < 0) {
-        perror("socket");
-        goto ERR_SOCKET;
-    }
+  int fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+  if (fd < 0) {
+    perror("socket");
+    goto ERR_SOCKET;
+  }
 
-    struct sockaddr_in addr;
-    memset(&addr, 0, sizeof(addr));
-    addr.sin_family = AF_INET;
-    addr.sin_addr.s_addr = inet_addr(argv[1]);
-    addr.sin_port = htons(atoi(argv[2]));
+  struct sockaddr_in addr;
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+  addr.sin_addr.s_addr = inet_addr(argv[1]);
+  addr.sin_port = htons(atoi(argv[2]));
 
-    if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
-        perror("connect");
-        goto ERR_CONNECT;
-    }
+  if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+    perror("connect");
+    goto ERR_CONNECT;
+  }
 
-    unsigned state = 0;
-    char buf[1];
-    for(;;) {
-        usleep(MS2US(interval));
+  unsigned state = 0;
+  char buf[1];
+  for (;;) {
+    usleep(MS2US(interval));
 
-        buf[0] = state;
-        rc = send(fd, buf, 1, 0);
-        if (rc < 0) {
-            if (errno == ECONNREFUSED) {
-                continue;
-            }
-            perror("send");
-            goto ERR_SEND;
-        }
-
-        state = 1 - state;
+    buf[0] = state;
+    rc = send(fd, buf, 1, 0);
+    if (rc < 0) {
+      if (errno == ECONNREFUSED) {
+        continue;
+      }
+      perror("send");
+      goto ERR_SEND;
     }
 
-    close(fd);
+    state = 1 - state;
+  }
+
+  close(fd);
 
-    exit(EXIT_SUCCESS);
+  exit(EXIT_SUCCESS);
 
 ERR_SEND:
 ERR_CONNECT:
-    close(fd);
+  close(fd);
 ERR_SOCKET:
-    exit(EXIT_FAILURE);
+  exit(EXIT_FAILURE);
 }
diff --git a/ctrl/facemgr/examples/updowncli/updowncli.c b/ctrl/facemgr/examples/updowncli/updowncli.c
index 4f5a14165..34ec3fb97 100644
--- a/ctrl/facemgr/examples/updowncli/updowncli.c
+++ b/ctrl/facemgr/examples/updowncli/updowncli.c
@@ -5,6 +5,8 @@
 #include <stdlib.h>
 #include <unistd.h>
 
+#include <hicn/util/sstrncpy.h>
+
 /**
  * \brief Default unix socket path (the leading \0 means using the abstract
  * namespace instead of the filesystem).
@@ -12,46 +14,46 @@
 #define UNIX_PATH "\0updownsrv"
 
 int main() {
-    struct sockaddr_un addr;
-    char buf[100];
-    int fd,rc;
-
-    char * socket_path = UNIX_PATH;
-
-    if ( (fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
-        perror("socket error");
-        exit(-1);
-    }
-
-    memset(&addr, 0, sizeof(addr));
-    addr.sun_family = AF_UNIX;
-    if (*socket_path == '\0') {
-        *addr.sun_path = '\0';
-        strncpy(addr.sun_path+1, socket_path+1, sizeof(addr.sun_path)-2);
-    } else {
-        strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path)-1);
-    }
-
-    if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
-        perror("connect error");
-        exit(-1);
-    }
-
-    printf("Waiting for server data...\n");
-    while( (rc=read(fd, buf, sizeof(buf))) > 0) {
-        assert(rc == 1);
-        switch(buf[0]) {
-            case '\0':
-                printf("WiFi\n");
-                break;
-            case '\1':
-                printf("LTE\n");
-                break;
-            default:
-                printf("Unknown\n");
-                break;
-        }
+  struct sockaddr_un addr;
+  char buf[100];
+  int fd, rc;
+
+  char* socket_path = UNIX_PATH;
+
+  if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+    perror("socket error");
+    exit(-1);
+  }
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sun_family = AF_UNIX;
+  if (*socket_path == '\0') {
+    *addr.sun_path = '\0';
+    strcpy_s(addr.sun_path + 1, sizeof(addr.sun_path) - 2, socket_path + 1);
+  } else {
+    strcpy_s(addr.sun_path, sizeof(addr.sun_path) - 1, socket_path);
+  }
+
+  if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
+    perror("connect error");
+    exit(-1);
+  }
+
+  printf("Waiting for server data...\n");
+  while ((rc = read(fd, buf, sizeof(buf))) > 0) {
+    assert(rc == 1);
+    switch (buf[0]) {
+      case '\0':
+        printf("WiFi\n");
+        break;
+      case '\1':
+        printf("LTE\n");
+        break;
+      default:
+        printf("Unknown\n");
+        break;
     }
+  }
 
-    return 0;
+  return 0;
 }
diff --git a/ctrl/facemgr/examples/updownsrv/updownsrv.c b/ctrl/facemgr/examples/updownsrv/updownsrv.c
index 3aba3cfd0..57661d427 100644
--- a/ctrl/facemgr/examples/updownsrv/updownsrv.c
+++ b/ctrl/facemgr/examples/updownsrv/updownsrv.c
@@ -5,19 +5,20 @@
  * using unix domains that sets a face up and down.
  */
 
-#include <arpa/inet.h> // inet_ntop
-#include <errno.h> // EINTR,. ..
-#include <netinet/in.h> // INET_ADDRSTRLEN, INET6_ADDRSTRLEN
+#include <arpa/inet.h>   // inet_ntop
+#include <errno.h>       // EINTR,. ..
+#include <netinet/in.h>  // INET_ADDRSTRLEN, INET6_ADDRSTRLEN
 #include <stdio.h>
 #include <inttypes.h>
 
 #include <stdlib.h>
 #include <sys/socket.h>
 #include <sys/timerfd.h>
-#include <sys/un.h> // sockaddr_un
-#include <unistd.h> // fcntl
-#include <fcntl.h> // fcntl
+#include <sys/un.h>  // sockaddr_un
+#include <unistd.h>  // fcntl
+#include <fcntl.h>   // fcntl
 
+#include <hicn/util/sstrncpy.h>
 
 /**
  * \brief Default unix socket path (the leading \0 means using the abstract
@@ -40,199 +41,190 @@
  */
 #define LISTEN_BACKLOG MAX_CLIENTS
 
-
 /**
  * \brief Creates a unix server socket
  * \param [in] path - string representing the path on which to listen for
  *      connections
  * \return int - fd associated to the socket
  */
-int
-create_unix_server(char * path)
-{
-    struct sockaddr_un addr;
-    int fd;
-
-    fd = socket(AF_UNIX, SOCK_STREAM, 0);
-    if (fd == -1) {
-        perror("socket error");
-        return -1;
-    }
-
-    if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
-        perror("fcntl");
-        return -1;
-    }
-
-    memset(&addr, 0, sizeof(addr));
-    addr.sun_family = AF_UNIX;
-    if (*path == '\0') {
-        *addr.sun_path = '\0';
-        strncpy(addr.sun_path+1, path+1, sizeof(addr.sun_path)-2);
-    } else {
-        strncpy(addr.sun_path, path, sizeof(addr.sun_path)-1);
-        unlink(path);
-    }
-
-    if (bind(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
-        perror("bind error");
-        return -1;
-    }
-
-    if (listen(fd, LISTEN_BACKLOG) == -1) {
-        perror("listen error");
-        return -1;
-    }
-
-    return fd;
+int create_unix_server(char* path) {
+  struct sockaddr_un addr;
+  int fd;
+
+  fd = socket(AF_UNIX, SOCK_STREAM, 0);
+  if (fd == -1) {
+    perror("socket error");
+    return -1;
+  }
+
+  if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
+    perror("fcntl");
+    return -1;
+  }
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sun_family = AF_UNIX;
+  if (*path == '\0') {
+    *addr.sun_path = '\0';
+    strcpy_s(addr.sun_path + 1, sizeof(addr.sun_path) - 2, path + 1);
+  } else {
+    strcpy_s(addr.sun_path, sizeof(addr.sun_path) - 1, path);
+    unlink(path);
+  }
+
+  if (bind(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
+    perror("bind error");
+    return -1;
+  }
+
+  if (listen(fd, LISTEN_BACKLOG) == -1) {
+    perror("listen error");
+    return -1;
+  }
+
+  return fd;
 }
 
-
 /**
  * \brief Main function
  */
 int main() {
-    int fd, tfd;
-    int rc;
-
-    /* Alternating state of the server : 0 / 1 */
-    unsigned state = 0;
-
-    /*
-     * This server has to send a signal to all connected clients at periodic
-     * intervals. Since we don't expect a large number of connected clients for
-     * such a simple program, we simply use a statically allocated array.
-     */
-    int clients[MAX_CLIENTS];
-    size_t num_clients = 0;
-
-    fd_set active_fd_set, read_fd_set;
-    FD_ZERO (&active_fd_set);
-
-    /* Create listening unix socket */
-    fd = create_unix_server(UNIX_PATH);
-    if (fd < 0)
-        exit(EXIT_FAILURE);
-
-    if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
-        perror("fcntl");
-        exit(EXIT_FAILURE);
-    }
-
-    FD_SET (fd, &active_fd_set);
-
-    /* Create timer */
-    tfd = timerfd_create(CLOCK_MONOTONIC, 0);
-    if (tfd == -1) {
-        perror("timer error");
-        exit(EXIT_FAILURE);
+  int fd, tfd;
+  int rc;
+
+  /* Alternating state of the server : 0 / 1 */
+  unsigned state = 0;
+
+  /*
+   * This server has to send a signal to all connected clients at periodic
+   * intervals. Since we don't expect a large number of connected clients for
+   * such a simple program, we simply use a statically allocated array.
+   */
+  int clients[MAX_CLIENTS];
+  size_t num_clients = 0;
+
+  fd_set active_fd_set, read_fd_set;
+  FD_ZERO(&active_fd_set);
+
+  /* Create listening unix socket */
+  fd = create_unix_server(UNIX_PATH);
+  if (fd < 0) exit(EXIT_FAILURE);
+
+  if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
+    perror("fcntl");
+    exit(EXIT_FAILURE);
+  }
+
+  FD_SET(fd, &active_fd_set);
+
+  /* Create timer */
+  tfd = timerfd_create(CLOCK_MONOTONIC, 0);
+  if (tfd == -1) {
+    perror("timer error");
+    exit(EXIT_FAILURE);
+  }
+
+  if (fcntl(tfd, F_SETFL, O_NONBLOCK) < 0) {
+    perror("fcntl");
+    exit(EXIT_FAILURE);
+  }
+
+  FD_SET(tfd, &active_fd_set);
+
+  struct itimerspec ts = {.it_interval =
+                              {
+                                  .tv_sec = DEFAULT_INTERVAL_SEC,
+                                  .tv_nsec = DEFAULT_INTERVAL_NSEC,
+                              },
+                          .it_value = {
+                              .tv_sec = DEFAULT_INTERVAL_SEC,
+                              .tv_nsec = DEFAULT_INTERVAL_NSEC,
+                          }};
+  rc = timerfd_settime(tfd, 0, &ts, NULL);
+  if (rc == -1) {
+    perror("timerfd_settime");
+    exit(EXIT_FAILURE);
+  }
+
+  printf("Waiting for clients...\n");
+
+  for (;;) {
+    /* Block until input arrives on one or more active sockets. */
+    read_fd_set = active_fd_set;
+    rc = select(FD_SETSIZE, &read_fd_set, NULL, NULL, NULL);
+    if (rc < 0) {
+      if (rc == EINTR) break;
+      perror("select");
+      exit(EXIT_FAILURE);
     }
 
-    if (fcntl(tfd, F_SETFL, O_NONBLOCK) < 0) {
-        perror("fcntl");
-        exit(EXIT_FAILURE);
-    }
-
-    FD_SET (tfd, &active_fd_set);
-
-    struct itimerspec ts = {
-        .it_interval = {
-            .tv_sec = DEFAULT_INTERVAL_SEC,
-            .tv_nsec = DEFAULT_INTERVAL_NSEC,
-        },
-        .it_value = {
-            .tv_sec = DEFAULT_INTERVAL_SEC,
-            .tv_nsec = DEFAULT_INTERVAL_NSEC,
-        }
-    };
-    rc = timerfd_settime(tfd, 0, &ts, NULL);
-    if (rc == -1) {
-        perror("timerfd_settime");
-        exit(EXIT_FAILURE);
-    }
-
-    printf("Waiting for clients...\n");
-
-    for(;;) {
-        /* Block until input arrives on one or more active sockets. */
-        read_fd_set = active_fd_set;
-        rc = select (FD_SETSIZE, &read_fd_set, NULL, NULL, NULL);
-        if (rc < 0) {
-            if (rc == EINTR)
-                break;
-            perror("select");
-            exit (EXIT_FAILURE);
+    /* Service all the sockets with input pending. */
+    for (int i = 0; i < FD_SETSIZE; ++i) {
+      if (!FD_ISSET(i, &read_fd_set)) continue;
+      if (i == fd) {
+        /* Connection request on original socket. */
+        int client_fd = accept(fd, NULL, NULL);
+        if (client_fd < 0) {
+          perror("accept");
+          continue;
         }
 
-        /* Service all the sockets with input pending. */
-        for (int i = 0; i < FD_SETSIZE; ++i) {
-            if (!FD_ISSET (i, &read_fd_set))
-                continue;
-            if (i == fd) {
-                /* Connection request on original socket. */
-                int client_fd = accept(fd, NULL, NULL);
-                if (client_fd < 0) {
-                    perror("accept");
-                    continue;
-                }
-
-                fprintf(stderr, "Server: connect from new client\n");
-                clients[num_clients++] = client_fd;
-                FD_SET(client_fd, &active_fd_set);
-            } else if (i == tfd) {
-                /* Timer event */
-                uint64_t res;
-
-                read(tfd, &res, sizeof(res));
-//                while (read(fd, &missed, sizeof(missed)) > 0)
-//                    ;
-                for (unsigned j = 0; j < num_clients; j++) {
-                    write(clients[j], state ? "\1" : "\0", 1);
-                }
-                printf("STATE=%d\n", state);
-                state = 1 - state;
-            } else {
-                char buf[1024];
-                rc = read(i, buf, sizeof(buf));
-                /* Client event : we close the connection on any event... */
-                for (unsigned j = 0; j < num_clients; j++) {
-                    if (i == clients[j]) {
-                        clients[j] = clients[num_clients--];
-                        break;
-                    }
-                }
-                close(i);
-                FD_CLR(i, &active_fd_set);
-            }
+        fprintf(stderr, "Server: connect from new client\n");
+        clients[num_clients++] = client_fd;
+        FD_SET(client_fd, &active_fd_set);
+      } else if (i == tfd) {
+        /* Timer event */
+        uint64_t res;
+
+        read(tfd, &res, sizeof(res));
+        //                while (read(fd, &missed, sizeof(missed)) > 0)
+        //                    ;
+        for (unsigned j = 0; j < num_clients; j++) {
+          write(clients[j], state ? "\1" : "\0", 1);
         }
-
-    }
-
-    int ret = EXIT_SUCCESS;
-
-    /* Close all active client connections */
-    for (unsigned i = 0; i < num_clients; i++) {
-        rc = close(clients[i]);
-        if (rc == -1) {
-            perror("close");
-            ret = EXIT_FAILURE;
+        printf("STATE=%d\n", state);
+        state = 1 - state;
+      } else {
+        char buf[1024];
+        rc = read(i, buf, sizeof(buf));
+        /* Client event : we close the connection on any event... */
+        for (unsigned j = 0; j < num_clients; j++) {
+          if (i == clients[j]) {
+            clients[j] = clients[num_clients--];
+            break;
+          }
         }
+        close(i);
+        FD_CLR(i, &active_fd_set);
+      }
     }
+  }
 
-    /* Close server */
-    rc = close(fd);
-    if (rc == -1) {
-        perror("close");
-        ret = EXIT_FAILURE;
-    }
+  int ret = EXIT_SUCCESS;
 
-    /* Terminate timer */
-    ts.it_value.tv_sec = 0;
-    rc = timerfd_settime(tfd, 0, &ts, NULL);
+  /* Close all active client connections */
+  for (unsigned i = 0; i < num_clients; i++) {
+    rc = close(clients[i]);
     if (rc == -1) {
-        perror("timerfd_settime");
-        exit(EXIT_FAILURE);
+      perror("close");
+      ret = EXIT_FAILURE;
     }
-
-    exit(ret);
+  }
+
+  /* Close server */
+  rc = close(fd);
+  if (rc == -1) {
+    perror("close");
+    ret = EXIT_FAILURE;
+  }
+
+  /* Terminate timer */
+  ts.it_value.tv_sec = 0;
+  rc = timerfd_settime(tfd, 0, &ts, NULL);
+  if (rc == -1) {
+    perror("timerfd_settime");
+    exit(EXIT_FAILURE);
+  }
+
+  exit(ret);
 }
diff --git a/ctrl/facemgr/includes/CMakeLists.txt b/ctrl/facemgr/includes/CMakeLists.txt
index 065a9022f..bfbf65717 100644
--- a/ctrl/facemgr/includes/CMakeLists.txt
+++ b/ctrl/facemgr/includes/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,15 +11,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# XXX
-
+##############################################################
+# Public headers directory
+##############################################################
 set(LIBFACEMGR_INCLUDE_DIRS
-  ${CMAKE_CURRENT_SOURCE_DIR} ""
+  ${CMAKE_CURRENT_SOURCE_DIR}
   CACHE INTERNAL
   "" FORCE
 )
-if (${CMAKE_SYSTEM_NAME} STREQUAL "Android")
 
+
+##############################################################
+# To install header files
+##############################################################
+if (${CMAKE_SYSTEM_NAME} STREQUAL "Android")
   set(TO_INSTALL_HEADER_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/facemgr.h
     ${CMAKE_CURRENT_SOURCE_DIR}/hicn/facemgr/api.h
@@ -28,9 +33,7 @@ if (${CMAKE_SYSTEM_NAME} STREQUAL "Android")
     ${CMAKE_CURRENT_SOURCE_DIR}/hicn/facemgr/loop.h
     PARENT_SCOPE
   )
-
 else ()
-
   set(TO_INSTALL_HEADER_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/facemgr.h
     ${CMAKE_CURRENT_SOURCE_DIR}/hicn/facemgr/api.h
@@ -39,7 +42,4 @@ else ()
     ${CMAKE_CURRENT_SOURCE_DIR}/hicn/facemgr/loop.h
     PARENT_SCOPE
   )
-
 endif ()
-
-
diff --git a/ctrl/facemgr/includes/facemgr.h b/ctrl/facemgr/includes/facemgr.h
index b3b482ccc..b62bb88ce 100644
--- a/ctrl/facemgr/includes/facemgr.h
+++ b/ctrl/facemgr/includes/facemgr.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -26,4 +26,3 @@
 #include <hicn/facemgr/loop.h>
 
 #endif /* HICN_FACEMGR_H */
-
diff --git a/ctrl/facemgr/includes/hicn/facemgr.h b/ctrl/facemgr/includes/hicn/facemgr.h
index 4165a8fc4..83a76cc08 100644
--- a/ctrl/facemgr/includes/hicn/facemgr.h
+++ b/ctrl/facemgr/includes/hicn/facemgr.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -24,4 +24,3 @@
 #include <hicn/facemgr/api.h>
 
 #endif /* HICN_FACEMGR_H */
-
diff --git a/ctrl/facemgr/includes/hicn/facemgr/api.h b/ctrl/facemgr/includes/hicn/facemgr/api.h
index e9d25f132..3fe049c06 100644
--- a/ctrl/facemgr/includes/hicn/facemgr/api.h
+++ b/ctrl/facemgr/includes/hicn/facemgr/api.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -30,40 +30,38 @@
 /* facemgr callbacks */
 
 typedef enum {
-    FACEMGR_CB_TYPE_REGISTER_FD,
-    FACEMGR_CB_TYPE_UNREGISTER_FD,
-    FACEMGR_CB_TYPE_REGISTER_TIMER,
-    FACEMGR_CB_TYPE_UNREGISTER_TIMER,
+  FACEMGR_CB_TYPE_REGISTER_FD,
+  FACEMGR_CB_TYPE_UNREGISTER_FD,
+  FACEMGR_CB_TYPE_REGISTER_TIMER,
+  FACEMGR_CB_TYPE_UNREGISTER_TIMER,
 } facemgr_cb_type_t;
 
-typedef int (*facemgr_cb_t)(void * loop, facemgr_cb_type_t type, void * data);
-
+typedef int (*facemgr_cb_t)(void *loop, facemgr_cb_type_t type, void *data);
 
 /*
  * \brief Manual overlay settings (alternative to service discovery)
  */
 
 typedef struct {
-    uint16_t local_port;
-    ip_address_t remote_addr;
-    uint16_t remote_port;
+  uint16_t local_port;
+  ip_address_t remote_addr;
+  uint16_t remote_port;
 } facemgr_overlay_setting_t;
 
-#define FACEMGR_OVERLAY_SETTING_EMPTY (facemgr_overlay_setting_t) {     \
-    .local_port = 0,                                                    \
-    .remote_addr = IP_ADDRESS_EMPTY,                                    \
-    .remote_port = 0,                                                   \
-}
+#define FACEMGR_OVERLAY_SETTING_EMPTY                                   \
+  (facemgr_overlay_setting_t) {                                         \
+    .local_port = 0, .remote_addr = IP_ADDRESS_EMPTY, .remote_port = 0, \
+  }
 
 typedef struct {
-    facemgr_overlay_setting_t v4;
-    facemgr_overlay_setting_t v6;
+  facemgr_overlay_setting_t v4;
+  facemgr_overlay_setting_t v6;
 } facemgr_overlay_t;
 
-#define FACEMGR_OVERLAY_EMPTY (facemgr_overlay_t) {     \
-    .v4 = FACEMGR_OVERLAY_SETTING_EMPTY,                \
-    .v6 = FACEMGR_OVERLAY_SETTING_EMPTY,                \
-}
+#define FACEMGR_OVERLAY_EMPTY                                                 \
+  (facemgr_overlay_t) {                                                       \
+    .v4 = FACEMGR_OVERLAY_SETTING_EMPTY, .v6 = FACEMGR_OVERLAY_SETTING_EMPTY, \
+  }
 
 /*
  * \brief Face manager context
@@ -72,24 +70,30 @@ typedef struct facemgr_s facemgr_t;
 
 int facemgr_initialize(facemgr_t *);
 int facemgr_finalize(facemgr_t *);
-facemgr_t * facemgr_create();
-facemgr_t * facemgr_create_with_config(facemgr_cfg_t * cfg);
+facemgr_t *facemgr_create();
+facemgr_t *facemgr_create_with_config(facemgr_cfg_t *cfg);
 void facemgr_stop(facemgr_t *);
 void facemgr_free(facemgr_t *);
 
+void facemgr_set_callback(facemgr_t *facemgr, void *callback_owner,
+                          facemgr_cb_t callback);
 
-void facemgr_set_callback(facemgr_t * facemgr, void * callback_owner, facemgr_cb_t callback);
-
-int facemgr_set_config(facemgr_t * facemgr, facemgr_cfg_t * cfg);
-int facemgr_reset_config(facemgr_t * facemgr);
-int facemgr_bootstrap(facemgr_t * facemgr);
+int facemgr_set_config(facemgr_t *facemgr, facemgr_cfg_t *cfg);
+int facemgr_reset_config(facemgr_t *facemgr);
+int facemgr_bootstrap(facemgr_t *facemgr);
 #ifdef __ANDROID__
-void facemgr_set_jvm(facemgr_t * facemgr, JavaVM *jvm);
+void facemgr_set_jvm(facemgr_t *facemgr, JavaVM *jvm);
+void facemgr_on_android_callback(facemgr_t *facemgr, const char *interface_name,
+                                 netdevice_type_t netdevice_type, bool up,
+                                 int family, const char *ip_address);
 #endif /* __ANDROID__ */
 
-typedef int (*facemgr_list_facelets_cb_t)(const facemgr_t * facemgr, const facelet_t * facelet, void * user_data);
+typedef int (*facemgr_list_facelets_cb_t)(const facemgr_t *facemgr,
+                                          const facelet_t *facelet,
+                                          void *user_data);
 
-void facemgr_list_facelets(const facemgr_t * facemgr, facemgr_list_facelets_cb_t cb, void * user_data);
-int facemgr_list_facelets_json(const facemgr_t * facemgr, char ** buffer);
+void facemgr_list_facelets(const facemgr_t *facemgr,
+                           facemgr_list_facelets_cb_t cb, void *user_data);
+int facemgr_list_facelets_json(const facemgr_t *facemgr, char **buffer);
 
 #endif /* FACEMGR_H */
diff --git a/ctrl/facemgr/includes/hicn/facemgr/cfg.h b/ctrl/facemgr/includes/hicn/facemgr/cfg.h
index 84d63fe73..fee38daf1 100644
--- a/ctrl/facemgr/includes/hicn/facemgr/cfg.h
+++ b/ctrl/facemgr/includes/hicn/facemgr/cfg.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -20,7 +20,7 @@
 #ifndef FACEMGR_CFG_H
 #define FACEMGR_CFG_H
 
-#include <hicn/ctrl/face.h>
+#include <hicn/face.h>
 #include <hicn/facemgr/facelet.h>
 #include <hicn/util/log.h>
 
@@ -38,68 +38,70 @@
 #define FACEMGR_CFG_DEFAULT_IPV4 true
 #define FACEMGR_CFG_DEFAULT_IPV6 false
 
-
-
 typedef struct facemgr_cfg_s facemgr_cfg_t;
 
-facemgr_cfg_t * facemgr_cfg_create();
-void facemgr_cfg_free(facemgr_cfg_t * cfg);
-int facemgr_cfg_initialize(facemgr_cfg_t * cfg);
-int facemgr_cfg_finalize(facemgr_cfg_t * cfg);
-void facemgr_cfg_dump(facemgr_cfg_t * cfg);
+facemgr_cfg_t* facemgr_cfg_create();
+void facemgr_cfg_free(facemgr_cfg_t* cfg);
+int facemgr_cfg_initialize(facemgr_cfg_t* cfg);
+int facemgr_cfg_finalize(facemgr_cfg_t* cfg);
+void facemgr_cfg_dump(facemgr_cfg_t* cfg);
 
 /* Rules */
 
 typedef struct facemgr_cfg_rule_s facemgr_cfg_rule_t;
 
-facemgr_cfg_rule_t * facemgr_cfg_rule_create();
-void facemgr_cfg_rule_free(facemgr_cfg_rule_t * rule);
-int facemgr_cfg_rule_initialize(facemgr_cfg_rule_t * rule);
-int facemgr_cfg_rule_finalize(facemgr_cfg_rule_t * rule);
+facemgr_cfg_rule_t* facemgr_cfg_rule_create();
+void facemgr_cfg_rule_free(facemgr_cfg_rule_t* rule);
+int facemgr_cfg_rule_initialize(facemgr_cfg_rule_t* rule);
+int facemgr_cfg_rule_finalize(facemgr_cfg_rule_t* rule);
 
-int facemgr_cfg_rule_set_match(facemgr_cfg_rule_t * rule,
-        const char * interface_name, netdevice_type_t interface_type);
+int facemgr_cfg_rule_set_match(facemgr_cfg_rule_t* rule,
+                               const char* interface_name,
+                               netdevice_type_t interface_type);
 
-int facemgr_cfg_rule_set_face_type(facemgr_cfg_rule_t * cfg_rule, facemgr_face_type_t * face_type);
-int facemgr_cfg_rule_unset_face_type(facemgr_cfg_rule_t * cfg_rule);
+int facemgr_cfg_rule_set_face_type(facemgr_cfg_rule_t* cfg_rule,
+                                   facemgr_face_type_t* face_type);
+int facemgr_cfg_rule_unset_face_type(facemgr_cfg_rule_t* cfg_rule);
 
-int facemgr_cfg_rule_set_discovery(facemgr_cfg_rule_t * cfg_rule, bool status);
-int facemgr_cfg_rule_unset_discovery(facemgr_cfg_rule_t * cfg_rule);
+int facemgr_cfg_rule_set_discovery(facemgr_cfg_rule_t* cfg_rule, bool status);
+int facemgr_cfg_rule_unset_discovery(facemgr_cfg_rule_t* cfg_rule);
 
-int facemgr_cfg_rule_set_ignore(facemgr_cfg_rule_t * cfg_rule, bool status);
-int facemgr_cfg_rule_unset_ignore(facemgr_cfg_rule_t * cfg_rule);
+int facemgr_cfg_rule_set_ignore(facemgr_cfg_rule_t* cfg_rule, bool status);
+int facemgr_cfg_rule_unset_ignore(facemgr_cfg_rule_t* cfg_rule);
 
-int facemgr_cfg_rule_set_ipv4(facemgr_cfg_rule_t * cfg_rule, bool status);
-int facemgr_cfg_rule_unset_ipv4(facemgr_cfg_rule_t * cfg_rule);
+int facemgr_cfg_rule_set_ipv4(facemgr_cfg_rule_t* cfg_rule, bool status);
+int facemgr_cfg_rule_unset_ipv4(facemgr_cfg_rule_t* cfg_rule);
 
-int facemgr_cfg_rule_set_ipv6(facemgr_cfg_rule_t * cfg_rule, bool status);
-int facemgr_cfg_rule_unset_ipv6(facemgr_cfg_rule_t * cfg_rule);
+int facemgr_cfg_rule_set_ipv6(facemgr_cfg_rule_t* cfg_rule, bool status);
+int facemgr_cfg_rule_unset_ipv6(facemgr_cfg_rule_t* cfg_rule);
 
-int facemgr_cfg_rule_set_overlay(facemgr_cfg_rule_t * rule, int family,
-    ip_address_t * local_addr, uint16_t local_port,
-    ip_address_t * remote_addr, uint16_t remote_port);
-int facemgr_rule_unset_overlay(facemgr_cfg_rule_t * rule, int family);
+int facemgr_cfg_rule_set_overlay(facemgr_cfg_rule_t* rule, int family,
+                                 ip_address_t* local_addr, uint16_t local_port,
+                                 ip_address_t* remote_addr,
+                                 uint16_t remote_port);
+int facemgr_rule_unset_overlay(facemgr_cfg_rule_t* rule, int family);
 
 /* General */
-int facemgr_cfg_set_face_type(facemgr_cfg_t * cfg, facemgr_face_type_t * face_type);
-int facemgr_cfg_unset_face_type(facemgr_cfg_t * cfg);
-int facemgr_cfg_set_discovery(facemgr_cfg_t * cfg, bool status);
-int facemgr_cfg_unset_discovery(facemgr_cfg_t * cfg);
-int facemgr_cfg_set_ipv4(facemgr_cfg_t * cfg, bool status);
-int facemgr_cfg_unset_ipv4(facemgr_cfg_t * cfg);
-int facemgr_cfg_set_ipv6(facemgr_cfg_t * cfg, bool status);
-int facemgr_cfg_unset_ipv6(facemgr_cfg_t * cfg);
-
-int facemgr_cfg_set_overlay(facemgr_cfg_t * cfg, int family,
-    ip_address_t * local_addr, uint16_t local_port,
-    ip_address_t * remote_addr, uint16_t remote_port);
-int facemgr_cfg_unset_overlay(facemgr_cfg_t * cfg, int family);
-
-
-int facemgr_cfg_add_rule(facemgr_cfg_t * cfg, facemgr_cfg_rule_t * rule);
-int facemgr_cfg_del_rule(facemgr_cfg_t * cfg, facemgr_cfg_rule_t * rule);
-int facemgr_cfg_get_rule(const facemgr_cfg_t * cfg, const char * interface_name,
-        netdevice_type_t interface_type, facemgr_cfg_rule_t ** rule);
+int facemgr_cfg_set_face_type(facemgr_cfg_t* cfg,
+                              facemgr_face_type_t* face_type);
+int facemgr_cfg_unset_face_type(facemgr_cfg_t* cfg);
+int facemgr_cfg_set_discovery(facemgr_cfg_t* cfg, bool status);
+int facemgr_cfg_unset_discovery(facemgr_cfg_t* cfg);
+int facemgr_cfg_set_ipv4(facemgr_cfg_t* cfg, bool status);
+int facemgr_cfg_unset_ipv4(facemgr_cfg_t* cfg);
+int facemgr_cfg_set_ipv6(facemgr_cfg_t* cfg, bool status);
+int facemgr_cfg_unset_ipv6(facemgr_cfg_t* cfg);
+
+int facemgr_cfg_set_overlay(facemgr_cfg_t* cfg, int family,
+                            ip_address_t* local_addr, uint16_t local_port,
+                            ip_address_t* remote_addr, uint16_t remote_port);
+int facemgr_cfg_unset_overlay(facemgr_cfg_t* cfg, int family);
+
+int facemgr_cfg_add_rule(facemgr_cfg_t* cfg, facemgr_cfg_rule_t* rule);
+int facemgr_cfg_del_rule(facemgr_cfg_t* cfg, facemgr_cfg_rule_t* rule);
+int facemgr_cfg_get_rule(const facemgr_cfg_t* cfg, const char* interface_name,
+                         netdevice_type_t interface_type,
+                         facemgr_cfg_rule_t** rule);
 
 /* Log */
 
@@ -107,57 +109,63 @@ int facemgr_cfg_get_rule(const facemgr_cfg_t * cfg, const char * interface_name,
  * Query API
  *
  * Takes the overrides into account
- *
- * TODO : interface_types are currently not taken into account by this API
  */
 
-int facemgr_cfg_get_face_type(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        facemgr_face_type_t * face_type);
-int facemgr_cfg_get_discovery(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        bool * discovery);
-int facemgr_cfg_get_ignore(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        bool * ignore);
-int facemgr_cfg_get_ipv4(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        bool * ipv4);
-int facemgr_cfg_get_ipv6(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        bool * ipv6);
-int facemgr_cfg_get_overlay_local_addr(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        int family, ip_address_t * addr);
-int facemgr_cfg_get_overlay_local_port(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        int family, u16 * port);
-int facemgr_cfg_get_overlay_remote_addr(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        int family, ip_address_t * addr);
-int facemgr_cfg_get_overlay_remote_port(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        int family, u16 * port);
-
-int facemgr_cfg_rule_get(const facemgr_cfg_t * cfg, const netdevice_t netdevice,
-        netdevice_type_t netdevice_type, facemgr_cfg_rule_t ** rule);
-int facemgr_cfg_rule_get_face_type(const facemgr_cfg_rule_t * cfg_rule, facemgr_face_type_t * face_type);
-int facemgr_cfg_rule_get_discovery(const facemgr_cfg_rule_t * cfg_rule, bool * status);
-int facemgr_cfg_rule_get_ignore(const facemgr_cfg_rule_t * cfg_rule, bool * status);
-int facemgr_cfg_rule_get_ipv4(const facemgr_cfg_rule_t * cfg_rule, bool * status);
-int facemgr_cfg_rule_get_ipv6(const facemgr_cfg_rule_t * cfg_rule, bool * status);
-int facemgr_cfg_rule_get_overlay_local_addr(const facemgr_cfg_rule_t * rule, int family,
-        ip_address_t * addr);
-int facemgr_cfg_rule_get_overlay_local_port(const facemgr_cfg_rule_t * rule, int family,
-        uint16_t * port);
-int facemgr_cfg_rule_get_overlay_remote_addr(const facemgr_cfg_rule_t * rule, int family,
-        ip_address_t * addr);
-int facemgr_cfg_rule_get_overlay_remote_port(const facemgr_cfg_rule_t * rule, int family,
-        uint16_t * port);
-
-int facemgr_cfg_add_static_facelet(facemgr_cfg_t * cfg, facelet_t * facelet);
-int facemgr_cfg_remove_static_facelet(facemgr_cfg_t * cfg, facelet_t * facelet,
-        facelet_t ** removed_facelet);
-int facemgr_cfg_get_static_facelet_array(const facemgr_cfg_t * cfg, facelet_t *** array);
+int facemgr_cfg_get_face_type(const facemgr_cfg_t* cfg,
+                              const netdevice_t* netdevice,
+                              netdevice_type_t netdevice_type,
+                              facemgr_face_type_t* face_type);
+int facemgr_cfg_get_discovery(const facemgr_cfg_t* cfg,
+                              const netdevice_t* netdevice,
+                              netdevice_type_t netdevice_type, bool* discovery);
+int facemgr_cfg_get_ignore(const facemgr_cfg_t* cfg,
+                           const netdevice_t* netdevice,
+                           netdevice_type_t netdevice_type, bool* ignore);
+int facemgr_cfg_get_ipv4(const facemgr_cfg_t* cfg, const netdevice_t* netdevice,
+                         netdevice_type_t netdevice_type, bool* ipv4);
+int facemgr_cfg_get_ipv6(const facemgr_cfg_t* cfg, const netdevice_t* netdevice,
+                         netdevice_type_t netdevice_type, bool* ipv6);
+int facemgr_cfg_get_overlay_local_addr(const facemgr_cfg_t* cfg,
+                                       const netdevice_t* netdevice,
+                                       netdevice_type_t netdevice_type,
+                                       int family, ip_address_t* addr);
+int facemgr_cfg_get_overlay_local_port(const facemgr_cfg_t* cfg,
+                                       const netdevice_t* netdevice,
+                                       netdevice_type_t netdevice_type,
+                                       int family, u16* port);
+int facemgr_cfg_get_overlay_remote_addr(const facemgr_cfg_t* cfg,
+                                        const netdevice_t* netdevice,
+                                        netdevice_type_t netdevice_type,
+                                        int family, ip_address_t* addr);
+int facemgr_cfg_get_overlay_remote_port(const facemgr_cfg_t* cfg,
+                                        const netdevice_t* netdevice,
+                                        netdevice_type_t netdevice_type,
+                                        int family, u16* port);
+
+int facemgr_cfg_rule_get(const facemgr_cfg_t* cfg, const netdevice_t netdevice,
+                         netdevice_type_t netdevice_type,
+                         facemgr_cfg_rule_t** rule);
+int facemgr_cfg_rule_get_face_type(const facemgr_cfg_rule_t* cfg_rule,
+                                   facemgr_face_type_t* face_type);
+int facemgr_cfg_rule_get_discovery(const facemgr_cfg_rule_t* cfg_rule,
+                                   bool* status);
+int facemgr_cfg_rule_get_ignore(const facemgr_cfg_rule_t* cfg_rule,
+                                bool* status);
+int facemgr_cfg_rule_get_ipv4(const facemgr_cfg_rule_t* cfg_rule, bool* status);
+int facemgr_cfg_rule_get_ipv6(const facemgr_cfg_rule_t* cfg_rule, bool* status);
+int facemgr_cfg_rule_get_overlay_local_addr(const facemgr_cfg_rule_t* rule,
+                                            int family, ip_address_t* addr);
+int facemgr_cfg_rule_get_overlay_local_port(const facemgr_cfg_rule_t* rule,
+                                            int family, uint16_t* port);
+int facemgr_cfg_rule_get_overlay_remote_addr(const facemgr_cfg_rule_t* rule,
+                                             int family, ip_address_t* addr);
+int facemgr_cfg_rule_get_overlay_remote_port(const facemgr_cfg_rule_t* rule,
+                                             int family, uint16_t* port);
+
+int facemgr_cfg_add_static_facelet(facemgr_cfg_t* cfg, facelet_t* facelet);
+int facemgr_cfg_remove_static_facelet(facemgr_cfg_t* cfg, facelet_t* facelet,
+                                      facelet_t** removed_facelet);
+int facemgr_cfg_get_static_facelet_array(const facemgr_cfg_t* cfg,
+                                         facelet_t*** array);
 
 #endif /* FACEMGR_CFG_H */
diff --git a/ctrl/facemgr/includes/hicn/facemgr/facelet.h b/ctrl/facemgr/includes/hicn/facemgr/facelet.h
index cfdc5540e..d9c986731 100644
--- a/ctrl/facemgr/includes/hicn/facemgr/facelet.h
+++ b/ctrl/facemgr/includes/hicn/facemgr/facelet.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -28,7 +28,7 @@
 
 #include <stdbool.h>
 
-#include <hicn/ctrl/face.h>
+#include <hicn/face.h>
 #include <hicn/ctrl/route.h>
 
 #define MAXSZ_FACELET 1024
@@ -36,111 +36,111 @@
 #define FACELET_MAX_ERRORS 10
 
 /* NOTE: Any test should be sufficient */
-#define IS_VALID_NETDEVICE(netdevice) ((netdevice.index != 0) && (netdevice.name[0] != '\0'))
+#define IS_VALID_NETDEVICE(netdevice) \
+  ((netdevice.index != 0) && (netdevice.name[0] != '\0'))
 
 typedef struct facelet_s facelet_t;
 
 /* Face type */
 
 #define foreach_face_type_layer \
-    _(UNDEFINED)                \
-    _(3)                        \
-    _(4)                        \
-    _(N)
+  _(UNDEFINED)                  \
+  _(3)                          \
+  _(4)                          \
+  _(N)
 
 typedef enum {
-#define _(x) FACE_TYPE_LAYER_ ## x,
-    foreach_face_type_layer
+#define _(x) FACE_TYPE_LAYER_##x,
+  foreach_face_type_layer
 #undef _
 } face_type_layer_t;
 
 #define foreach_face_type_encap \
-    _(UNDEFINED)                \
-    _(TCP)                      \
-    _(UDP)                      \
-    _(N)
+  _(UNDEFINED)                  \
+  _(TCP)                        \
+  _(UDP)                        \
+  _(N)
 
 typedef enum {
-#define _(x) FACE_TYPE_ENCAP_ ## x,
-    foreach_face_type_encap
+#define _(x) FACE_TYPE_ENCAP_##x,
+  foreach_face_type_encap
 #undef _
 } face_type_encap_t;
 
 typedef struct {
-   face_type_layer_t layer;
-   face_type_encap_t encap;
+  face_type_layer_t layer;
+  face_type_encap_t encap;
 } facemgr_face_type_t;
 
+extern const char* face_type_layer_str[];
+extern const char* face_type_encap_str[];
 
-extern const char * face_type_layer_str[];
-extern const char * face_type_encap_str[];
+#define FACEMGR_FACE_TYPE_STR(x) \
+  face_type_layer_str[x.layer], face_type_encap_str[x.encap]
 
-#define FACEMGR_FACE_TYPE_STR(x)                                \
-    face_type_layer_str[x.layer], face_type_encap_str[x.encap]
+#define FACEMGR_FACE_TYPE_UNDEFINED                                         \
+  (facemgr_face_type_t) {                                                   \
+    .layer = FACE_TYPE_LAYER_UNDEFINED, .encap = FACE_TYPE_ENCAP_UNDEFINED, \
+  }
 
-#define FACEMGR_FACE_TYPE_UNDEFINED (facemgr_face_type_t) {     \
-    .layer = FACE_TYPE_LAYER_UNDEFINED,                         \
-    .encap = FACE_TYPE_ENCAP_UNDEFINED,                         \
-}
+#define FACEMGR_FACE_TYPE_NATIVE_UDP                          \
+  (facemgr_face_type_t) {                                     \
+    .layer = FACE_TYPE_LAYER_3, .encap = FACE_TYPE_ENCAP_UDP, \
+  }
 
-#define FACEMGR_FACE_TYPE_NATIVE_UDP (facemgr_face_type_t) {    \
-    .layer = FACE_TYPE_LAYER_3,                                 \
-    .encap = FACE_TYPE_ENCAP_UDP,                               \
-}
+#define FACEMGR_FACE_TYPE_NATIVE_TCP                          \
+  (facemgr_face_type_t) {                                     \
+    .layer = FACE_TYPE_LAYER_3, .encap = FACE_TYPE_ENCAP_TCP, \
+  }
 
-#define FACEMGR_FACE_TYPE_NATIVE_TCP (facemgr_face_type_t) {    \
-    .layer = FACE_TYPE_LAYER_3,                                 \
-    .encap = FACE_TYPE_ENCAP_TCP,                               \
-}
+#define FACEMGR_FACE_TYPE_OVERLAY_UDP                         \
+  (facemgr_face_type_t) {                                     \
+    .layer = FACE_TYPE_LAYER_4, .encap = FACE_TYPE_ENCAP_UDP, \
+  }
 
-#define FACEMGR_FACE_TYPE_OVERLAY_UDP (facemgr_face_type_t) {   \
-    .layer = FACE_TYPE_LAYER_4,                                 \
-    .encap = FACE_TYPE_ENCAP_UDP,                               \
-}
-
-#define FACEMGR_FACE_TYPE_OVERLAY_TCP (facemgr_face_type_t) {   \
-    .layer = FACE_TYPE_LAYER_4,                                 \
-    .encap = FACE_TYPE_ENCAP_TCP,                               \
-}
+#define FACEMGR_FACE_TYPE_OVERLAY_TCP                         \
+  (facemgr_face_type_t) {                                     \
+    .layer = FACE_TYPE_LAYER_4, .encap = FACE_TYPE_ENCAP_TCP, \
+  }
 
 /* Facelet status */
-#define foreach_facelet_status  \
-    _(UNDEFINED)                \
-    _(DOWN)                     \
-    _(UNCERTAIN)                \
-    _(INCOMPLETE)               \
-    _(CREATE)                   \
-    _(CLEAN)                    \
-    _(IGNORED)                  \
-    _(UPDATE)                   \
-    _(DELETE)                   \
-    _(DELETED)                  \
-    _(N)
+#define foreach_facelet_status \
+  _(UNDEFINED)                 \
+  _(DOWN)                      \
+  _(UNCERTAIN)                 \
+  _(INCOMPLETE)                \
+  _(CREATE)                    \
+  _(CLEAN)                     \
+  _(IGNORED)                   \
+  _(UPDATE)                    \
+  _(DELETE)                    \
+  _(DELETED)                   \
+  _(N)
 
 typedef enum {
-#define _(x) FACELET_STATUS_ ## x,
-    foreach_facelet_status
+#define _(x) FACELET_STATUS_##x,
+  foreach_facelet_status
 #undef _
 } facelet_status_t;
 
-extern const char * facelet_status_str[];
+extern const char* facelet_status_str[];
 
 /* Facelet error reason */
-#define foreach_facelet_error_reason    \
-    _(UNDEFINED)                        \
-    _(UNSPECIFIED_ERROR)                \
-    _(FORWARDER_OFFLINE)                \
-    _(PERMISSION_DENIED)                \
-    _(INTERNAL_ERROR)                   \
-    _(N)
+#define foreach_facelet_error_reason \
+  _(UNDEFINED)                       \
+  _(UNSPECIFIED_ERROR)               \
+  _(FORWARDER_OFFLINE)               \
+  _(PERMISSION_DENIED)               \
+  _(INTERNAL_ERROR)                  \
+  _(N)
 
 typedef enum {
-#define _(x) FACELET_ERROR_REASON_ ## x,
-    foreach_facelet_error_reason
+#define _(x) FACELET_ERROR_REASON_##x,
+  foreach_facelet_error_reason
 #undef _
 } facelet_error_reason_t;
 
-extern const char * facelet_error_reason_str[];
+extern const char* facelet_error_reason_str[];
 
 /* Facelet attribute status */
 
@@ -148,62 +148,62 @@ extern const char * facelet_error_reason_str[];
  * We expect an attribute in the cache to be able to take any value but
  * UNDEFINED and N, which facelet events should either be UNSET or CLEAN
  */
-#define foreach_facelet_attr_status             \
-    _(UNDEFINED, '?')                           \
-    _(UNSET, 'X')                               \
-    _(CLEAN, ' ')                               \
-    _(DIRTY, '*')                               \
-    _(PENDING, 'P')                             \
-    _(CONFLICT, '!')                            \
-    _(N, '-')
+#define foreach_facelet_attr_status \
+  _(UNDEFINED, '?')                 \
+  _(UNSET, 'X')                     \
+  _(CLEAN, ' ')                     \
+  _(DIRTY, '*')                     \
+  _(PENDING, 'P')                   \
+  _(CONFLICT, '!')                  \
+  _(N, '-')
 
 typedef enum {
-#define _(x, y) FACELET_ATTR_STATUS_ ## x,
-    foreach_facelet_attr_status
+#define _(x, y) FACELET_ATTR_STATUS_##x,
+  foreach_facelet_attr_status
 #undef _
 } facelet_attr_status_t;
 
-extern const char * facelet_attr_status_str[];
-extern const char * facelet_attr_status_str_short[];
+extern const char* facelet_attr_status_str[];
+extern const char* facelet_attr_status_str_short[];
 
 /* Facelet attribute */
 
 #ifdef WITH_POLICY
-#define foreach_facelet_attr                    \
-    _(netdevice_type_t, netdevice_type)         \
-    _(netdevice_t, netdevice)                   \
-    _(int, family)                              \
-    _(ip_address_t, local_addr)                 \
-    _(u16, local_port)                          \
-    _(ip_address_t, remote_addr)                \
-    _(u16, remote_port)                         \
-    _(face_state_t, admin_state)                \
-    _(face_state_t, state)                      \
-    _(u32, priority)                            \
-    _(facemgr_face_type_t, face_type)
+#define foreach_facelet_attr          \
+  _(netdevice_type_t, netdevice_type) \
+  _(netdevice_t, netdevice)           \
+  _(int, family)                      \
+  _(ip_address_t, local_addr)         \
+  _(u16, local_port)                  \
+  _(ip_address_t, remote_addr)        \
+  _(u16, remote_port)                 \
+  _(face_state_t, admin_state)        \
+  _(face_state_t, state)              \
+  _(u32, priority)                    \
+  _(facemgr_face_type_t, face_type)
 #else
-#define foreach_facelet_attr                    \
-    _(netdevice_type_t, netdevice_type)         \
-    _(netdevice_t, netdevice)                   \
-    _(int, family)                              \
-    _(ip_address_t, local_addr)                 \
-    _(u16, local_port)                          \
-    _(ip_address_t, remote_addr)                \
-    _(u16, remote_port)                         \
-    _(face_state_t, admin_state)                \
-    _(face_state_t, state)                      \
-    _(facemgr_face_type_t, face_type)
+#define foreach_facelet_attr          \
+  _(netdevice_type_t, netdevice_type) \
+  _(netdevice_t, netdevice)           \
+  _(int, family)                      \
+  _(ip_address_t, local_addr)         \
+  _(u16, local_port)                  \
+  _(ip_address_t, remote_addr)        \
+  _(u16, remote_port)                 \
+  _(face_state_t, admin_state)        \
+  _(face_state_t, state)              \
+  _(facemgr_face_type_t, face_type)
 #endif /* WITH_POLICY */
 
-#define foreach_facelet_event   \
-    _(UNDEFINED)                \
-    _(GET)                      \
-    _(CREATE)                   \
-    _(UPDATE)                   \
-    _(DELETE)                   \
-    _(SET_UP)                   \
-    _(SET_DOWN)                 \
-    _(N)
+#define foreach_facelet_event \
+  _(UNDEFINED)                \
+  _(GET)                      \
+  _(CREATE)                   \
+  _(UPDATE)                   \
+  _(DELETE)                   \
+  _(SET_UP)                   \
+  _(SET_DOWN)                 \
+  _(N)
 
 #define MAXSZ_EVENT__ 10
 #define MAXSZ_EVENT_ MAXSZ_EVENT_ + 1
@@ -212,37 +212,37 @@ extern const char * facelet_attr_status_str_short[];
  * \brief Enumeration of the possible types of event
  */
 typedef enum {
-#define _(x) FACELET_EVENT_ ## x,
-foreach_facelet_event
+#define _(x) FACELET_EVENT_##x,
+  foreach_facelet_event
 #undef _
 } facelet_event_t;
 
-extern const char * facelet_event_str[];
+extern const char* facelet_event_str[];
 
 /**
  * \brief Create a facelet.
  */
-facelet_t * facelet_create();
+facelet_t* facelet_create();
 
-facelet_t * facelet_create_from_netdevice(netdevice_t * netdevice);
+facelet_t* facelet_create_from_netdevice(netdevice_t* netdevice);
 
-unsigned facelet_get_id(facelet_t * facelet);
-void facelet_set_id(facelet_t * facelet, unsigned id);
+unsigned facelet_get_id(facelet_t* facelet);
+void facelet_set_id(facelet_t* facelet, unsigned id);
 
-int facelet_validate_face(const facelet_t * facelet);
+int facelet_validate_face(const facelet_t* facelet);
 
-facelet_t * facelet_create_from_face(face_t * face);
+facelet_t* facelet_create_from_face(face_t* face);
 
-void facelet_free(facelet_t * facelet);
+void facelet_free(facelet_t* facelet);
 
-facelet_t * facelet_dup(const facelet_t * current_facelet);
+facelet_t* facelet_dup(const facelet_t* current_facelet);
 
-int facelet_cmp(const facelet_t * f1, const facelet_t * f2);
+int facelet_cmp(const facelet_t* f1, const facelet_t* f2);
 
-bool facelet_equals(const facelet_t * facelet1, const facelet_t * facelet2);
+bool facelet_equals(const facelet_t* facelet1, const facelet_t* facelet2);
 
 /* NOTE: only clean attributes are matched */
-bool facelet_match(const facelet_t * facelet, const facelet_t * facelet_match);
+bool facelet_match(const facelet_t* facelet, const facelet_t* facelet_match);
 
 /**
  * \brief Returns whether the specified facelet has all key attributes defined.
@@ -251,55 +251,58 @@ bool facelet_match(const facelet_t * facelet, const facelet_t * facelet_match);
  * uniquely identify a facelet, otherwise it is a 'wildcard' facelet
  * specification and might match several facelets.
  */
-bool facelet_has_key(const facelet_t * facelet);
+bool facelet_has_key(const facelet_t* facelet);
 
-#define FACELET_ACCESSORS_H(TYPE, NAME)                                         \
-bool facelet_has_ ## NAME(const facelet_t * facelet);                           \
-facelet_attr_status_t facelet_get_ ## NAME ## _status(const facelet_t * facelet);\
-void facelet_set_ ## NAME ## _status(facelet_t * facelet,                       \
-        facelet_attr_status_t status);                                          \
-int facelet_get_ ## NAME(const facelet_t * facelet, TYPE * NAME);               \
-int facelet_set_ ## NAME(facelet_t * facelet, TYPE NAME);                       \
-int facelet_unset_ ## NAME(facelet_t * facelet);
+#define FACELET_ACCESSORS_H(TYPE, NAME)                                        \
+  bool facelet_has_##NAME(const facelet_t* facelet);                           \
+  facelet_attr_status_t facelet_get_##NAME##_status(const facelet_t* facelet); \
+  void facelet_set_##NAME##_status(facelet_t* facelet,                         \
+                                   facelet_attr_status_t status);              \
+  int facelet_get_##NAME(const facelet_t* facelet, TYPE* NAME);                \
+  int facelet_set_##NAME(facelet_t* facelet, TYPE NAME);                       \
+  int facelet_unset_##NAME(facelet_t* facelet);
 
 #define _(TYPE, NAME) FACELET_ACCESSORS_H(TYPE, NAME)
 foreach_facelet_attr
 #undef _
 
-int facelet_get_face(const facelet_t * facelet, face_t ** pface);
+    int
+    facelet_get_face(const facelet_t* facelet, face_t** pface);
 
-int facelet_merge(facelet_t * facelet, facelet_t * facelet_to_merge);
+int facelet_merge(facelet_t* facelet, facelet_t* facelet_to_merge);
 
-facelet_status_t facelet_get_status(const facelet_t * facelet);
-void facelet_set_status(facelet_t * facelet, facelet_status_t status);
-void facelet_set_attr_clean(facelet_t * facelet);
+facelet_status_t facelet_get_status(const facelet_t* facelet);
+void facelet_set_status(facelet_t* facelet, facelet_status_t status);
+void facelet_set_attr_clean(facelet_t* facelet);
 
-void facelet_set_error(facelet_t * facelet, facelet_error_reason_t reason);
-void facelet_unset_error(facelet_t * facelet);
-bool facelet_get_error(const facelet_t * facelet);
+void facelet_set_error(facelet_t* facelet, facelet_error_reason_t reason);
+void facelet_unset_error(facelet_t* facelet);
+bool facelet_get_error(const facelet_t* facelet);
 
-void facelet_set_bj_done(facelet_t * facelet);
-void facelet_unset_bj_done(facelet_t * facelet);
-bool facelet_is_bj_done(const facelet_t * facelet);
-void facelet_set_au_done(facelet_t * facelet);
-bool facelet_is_au_done(const facelet_t * facelet);
+void facelet_set_bj_done(facelet_t* facelet);
+void facelet_unset_bj_done(facelet_t* facelet);
+bool facelet_is_bj_done(const facelet_t* facelet);
 
-facelet_event_t facelet_get_event(const facelet_t * facelet);
-void facelet_set_event(facelet_t * facelet, facelet_event_t event);
+facelet_event_t facelet_get_event(const facelet_t* facelet);
+void facelet_set_event(facelet_t* facelet, facelet_event_t event);
 
-int facelet_add_route(facelet_t * facelet, hicn_route_t * route);
-int facelet_remove_route(facelet_t * facelet, hicn_route_t * route, hicn_route_t ** route_removed);
-int facelet_clear_routes(facelet_t * facelet);
-int facelet_get_route_array(const facelet_t * facelet, hicn_route_t *** route_array);
+int facelet_add_route(facelet_t* facelet, hicn_route_t* route);
+int facelet_remove_route(facelet_t* facelet, hicn_route_t* route,
+                         hicn_route_t** route_removed);
+int facelet_clear_routes(facelet_t* facelet);
+int facelet_get_route_array(const facelet_t* facelet,
+                            hicn_route_t*** route_array);
 
-int facelet_snprintf(char * buf, size_t size, const facelet_t * facelet);
+int facelet_snprintf(char* buf, size_t size, const facelet_t* facelet);
 
-#define DUMP_FACELET(msg, facelet) do {                 \
-    char buf[MAXSZ_FACELET];                            \
-    facelet_snprintf(buf, MAXSZ_FACELET, facelet);      \
-    DEBUG("%s : %s", msg, buf);                         \
-} while(0)
+#define DUMP_FACELET(msg, facelet)                 \
+  do {                                             \
+    char buf[MAXSZ_FACELET];                       \
+    facelet_snprintf(buf, MAXSZ_FACELET, facelet); \
+    DEBUG("%s : %s", msg, buf);                    \
+  } while (0)
 
-int facelet_snprintf_json(char * buf, size_t size, const facelet_t * facelet, int indent);
+int facelet_snprintf_json(char* buf, size_t size, const facelet_t* facelet,
+                          int indent);
 
 #endif /* FACEMGR_FACELET_H */
diff --git a/ctrl/facemgr/includes/hicn/facemgr/loop.h b/ctrl/facemgr/includes/hicn/facemgr/loop.h
index 752a3b365..3965a1f27 100644
--- a/ctrl/facemgr/includes/hicn/facemgr/loop.h
+++ b/ctrl/facemgr/includes/hicn/facemgr/loop.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,23 +25,21 @@
 
 /* fd & timer callbacks */
 
-typedef int (*fd_callback_t)(void * owner, int fd, void * data);
+typedef int (*fd_callback_t)(void *owner, int fd, void *data);
 
 typedef struct {
-    int fd;
-    void *owner;
-    fd_callback_t callback;
-    //int (*callback)(void * owner, int fd, void * data);
-    void *data;
+  int fd;
+  void *owner;
+  fd_callback_t callback;
+  void *data;
 } fd_callback_data_t;
 
 /* timer callbacks */
 typedef struct {
-    unsigned delay_ms;
-    void *owner;
-    fd_callback_t callback;
-    //int (*callback)(void * owner, int fd, void * data);
-    void *data;
+  unsigned delay_ms;
+  void *owner;
+  fd_callback_t callback;
+  void *data;
 } timer_callback_data_t;
 
 /* loop */
@@ -52,33 +50,32 @@ typedef struct loop_s loop_t;
  * \brief Creates a main loop
  * \return Pointer to the newly created loop, or NULL in case of error
  */
-loop_t * loop_create();
+loop_t *loop_create();
 
 /**
  * \brief Releases a loop instance and frees all associated memory
  * \param [in] loop - Pointer to the loop instance to free
  */
-void loop_free(loop_t * loop);
+void loop_free(loop_t *loop);
 
 /**
  * \brief Runs the loop instance to process events
  * \param [in] loop - Pointer to the loop instance
  * \return 0 if successful, -1 otherwise
  */
-int loop_dispatch(loop_t * loop);
+int loop_dispatch(loop_t *loop);
 
 /**
  * \brief Terminates the dispatching of events
  * \param [in] loop - Pointer to the loop instance
  */
-int loop_undispatch(loop_t * loop);
+int loop_undispatch(loop_t *loop);
 
 /**
  * \brief Breaks out of the loop
  * \param [in] loop - Pointer to the loop instance
  */
-void loop_break(loop_t * loop);
-
+void loop_break(loop_t *loop);
 
 /**
  * \brief Callback for loop helpers
@@ -86,6 +83,6 @@ void loop_break(loop_t * loop);
  * \param [in] type - Type of service to be requested
  * \param [in] data - Service specific data
  */
-int loop_callback(loop_t * loop, facemgr_cb_type_t type, void * data);
+int loop_callback(loop_t *loop, facemgr_cb_type_t type, void *data);
 
 #endif /* FACEMGR_LOOP_H */
diff --git a/ctrl/facemgr/src/CMakeLists.txt b/ctrl/facemgr/src/CMakeLists.txt
index cf5606e04..87938fb57 100644
--- a/ctrl/facemgr/src/CMakeLists.txt
+++ b/ctrl/facemgr/src/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -12,130 +12,157 @@
 # limitations under the License.
 
 if(UNIX AND NOT APPLE)
-    set(LINUX TRUE)
+  set(LINUX TRUE)
 endif()
 
-set(COMPILER_DEFINITIONS
-  "-DWITH_POLICY"
-)
 
+##############################################################
+# Sources
+##############################################################
 set(HEADER_FILES
-    common.h
-    error.h
-    facelet_array.h
-    interface.h
-    loop.h
+  common.h
+  error.h
+  facelet_array.h
+  interface.h
+  loop.h
 )
 
 set(SOURCE_FILES
-    api.c
-    cfg.c
-    cfg_file.c
-    error.c
-    facelet.c
-    facelet_array.c
-    interface.c
+  api.c
+  cfg.c
+  cfg_file.c
+  error.c
+  facelet.c
+  facelet_array.c
+  interface.c
 )
 
 if(APPLE)
-set(SOURCE_FILES
+  set(SOURCE_FILES
     ${SOURCE_FILES}
     loop_dispatcher.c
-)
+  )
 endif()
 
 if (LINUX)
-set(SOURCE_FILES
+  set(SOURCE_FILES
     ${SOURCE_FILES}
     loop_libevent.c
-)
+  )
 endif()
 
+add_subdirectory(interfaces)
+
+
+##############################################################
+# Include directories
+##############################################################
 set(INCLUDE_DIRS
-    ./
-    ../includes/
-    ${HICN_INCLUDE_DIRS}
-    ${LIBHICNCTRL_INCLUDE_DIRS}
-    ${CONFIG_INCLUDE_DIR}
-    ${LIBEVENT_INCLUDE_DIR}
+  PRIVATE ./
+  PRIVATE ${CONFIG_INCLUDE_DIR}
+  PRIVATE ${LIBEVENT_INCLUDE_DIR}
+  PUBLIC
+    $<BUILD_INTERFACE:${LIBFACEMGR_INCLUDE_DIRS}>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
 )
 
+
+##############################################################
+# Libraries to link
+##############################################################
 set(LIBRARIES
-    m
-    ${HICN_LIBRARIES}
-    ${LIBHICNCTRL_LIBRARIES}
-    ${LIBCONFIG_LIBRARIES}
-    ${LIBEVENT_LIBRARY}
+  PUBLIC ${HICN_LIBRARIES}
+  PUBLIC ${LIBHICNCTRL_LIBRARIES}
+  PRIVATE m
+  PRIVATE ${LIBCONFIG_LIBRARIES}
+  PRIVATE ${LIBEVENT_LIBRARY}
 )
 
-set(FACEMGR_LIBRARY_LIST "${LIBCONFIG_LIBRARIES};${LIBEVENT_LIBRARY}" CACHE INTERNAL "FACEMGR_LIBRARY_LIST")
+if(WITH_THREAD)
+  set(LIBRARIES
+    ${LIBRARIES}
+    "pthread"
+    "event_pthreads"
+  )
+  set(COMPILER_DEFINITIONS
+    ${COMPILER_DEFINITIONS}
+    "-DWITH_THREAD"
+  )
+endif()
 
 
-add_subdirectory(interfaces)
+##############################################################
+# Compiler definitions
+##############################################################
 
 if(WITH_THREAD)
-    set(LIBRARIES
-        ${LIBRARIES}
-        "pthread"
-        "event_pthreads"
-    )
-    set(COMPILER_DEFINITIONS
-        ${COMPILER_DEFINITIONS}
-        "-DWITH_THREAD"
-    )
+  list(APPEND COMPILER_DEFINITIONS
+    "-DWITH_THREAD"
+  )
 endif()
 
 if(WITH_EXAMPLE_DUMMY)
-    set(COMPILER_DEFINITIONS
-        ${COMPILER_DEFINITIONS}
-        "-DWITH_EXAMPLE_DUMMY"
-    )
+  list(APPEND COMPILER_DEFINITIONS
+    "-DWITH_EXAMPLE_DUMMY"
+  )
 endif()
 
 if(WITH_EXAMPLE_UPDOWN)
-    set(COMPILER_DEFINITIONS
-        ${COMPILER_DEFINITIONS}
-        "-DWITH_EXAMPLE_UPDOWN"
-    )
+  list(APPEND COMPILER_DEFINITIONS
+    "-DWITH_EXAMPLE_UPDOWN"
+  )
 endif()
 
+
+##############################################################
+# Compiler options
+##############################################################
+set(COMPILER_OPTIONS
+  ${DEFAULT_COMPILER_OPTIONS}
+)
+
+
+##############################################################
+# Build type
+##############################################################
 if (DISABLE_SHARED_LIBRARIES)
-    build_library(${LIBFACEMGR}
-        STATIC
-        SOURCES ${SOURCE_FILES}
-        INSTALL_HEADERS ${TO_INSTALL_HEADER_FILES}
-        DEPENDS ${DEPENDENCIES}
-        LINK_LIBRARIES ${LIBRARIES}
-        COMPONENT ${FACEMGR}
-        INCLUDE_DIRS ${INCLUDE_DIRS}
-        HEADER_ROOT_DIR hicn
-        DEFINITIONS ${COMPILER_DEFINITIONS}
-    )
+    set(LINK_TYPE STATIC)
 else ()
-    build_library(${LIBFACEMGR}
-        SHARED STATIC NO_DEV
-        SOURCES ${SOURCE_FILES}
-        INSTALL_HEADERS ${TO_INSTALL_HEADER_FILES}
-        DEPENDS ${DEPENDENCIES}
-        LINK_LIBRARIES ${LIBRARIES}
-        COMPONENT ${FACEMGR}
-        INCLUDE_DIRS ${INCLUDE_DIRS}
-        HEADER_ROOT_DIR hicn
-        DEFINITIONS ${COMPILER_DEFINITIONS}
-    )
+    set(LINK_TYPE SHARED STATIC)
 endif ()
 
+
+##############################################################
+# Build libfacemgr
+##############################################################
+build_library(${LIBFACEMGR}
+  ${LINK_TYPE}
+  SOURCES ${SOURCE_FILES}
+  INSTALL_HEADERS ${TO_INSTALL_HEADER_FILES}
+  DEPENDS ${DEPENDENCIES}
+  LINK_LIBRARIES ${LIBRARIES}
+  COMPONENT ${FACEMGR}
+  INCLUDE_DIRS PRIVATE ${INCLUDE_DIRS}
+  DEFINITIONS PRIVATE ${COMPILER_DEFINITIONS}
+  COMPILE_OPTIONS ${COMPILER_OPTIONS}
+)
+
+
+##############################################################
+# Build executable
+##############################################################
 if(NOT DISABLE_EXECUTABLES)
-    list(APPEND DAEMON_SRC
-      main.c
-    )
-
-    build_executable(${FACEMGR}
-      SOURCES ${DAEMON_SRC}
-      LINK_LIBRARIES ${LIBFACEMGR}.static ${LIBRARIES}
-      DEPENDS ${LIBFACEMGR}.static
-      COMPONENT ${FACEMGR}
-      INCLUDE_DIRS ${INCLUDE_DIRS}
-      DEFINITIONS ${COMPILER_DEFINITIONS}
-    )
+  list(APPEND DAEMON_SRC
+    main.c
+  )
+
+  build_executable(${FACEMGR}
+    SOURCES ${DAEMON_SRC}
+    LINK_LIBRARIES PRIVATE ${LIBFACEMGR}.static
+    DEPENDS ${LIBFACEMGR}.static
+    COMPONENT ${FACEMGR}
+    INCLUDE_DIRS ${INCLUDE_DIRS}
+    DEFINITIONS ${COMPILER_DEFINITIONS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS}
+  )
 endif ()
diff --git a/ctrl/facemgr/src/api.c b/ctrl/facemgr/src/api.c
index dfbd24bcb..d030abd1f 100644
--- a/ctrl/facemgr/src/api.c
+++ b/ctrl/facemgr/src/api.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,17 +21,9 @@
 #ifdef __ANDROID__
 
 /*
- * Use FacemgrUtility to determine interface types
- *
- * NOTE: this is currently disabled as SDK APIs do not allow to determine the
- * type of interfaces that are DOWN
- */
-//#define WITH_FACEMGR_UTILITY
-
-/*
  * Use priority controller interface
  */
-#define WITH_PRIORITY_CONTROLLER
+//#define WITH_PRIORITY_CONTROLLER
 
 /*
  * Dump facelets (debug)
@@ -62,15 +54,14 @@
 
 #ifdef __linux__
 #include "interfaces/bonjour/bonjour.h"
+#ifdef __ANDROID__
+#include "interfaces/android/android.h"
+#endif /* __ANDROID__ */
 #endif /* __linux__ */
 
-#ifdef WITH_FACEMGR_UTILITY
-#include "interfaces/android_utility/android_utility.h"
-#endif /* WITH_FACEMGR_UTILITY */
-
 #include "interfaces/priority_controller/priority_controller.h"
 
-#include <hicn/ctrl/face.h>
+#include <hicn/face.h>
 #include <hicn/facemgr/facelet.h>
 #include "common.h"
 #include "facelet_array.h"
@@ -84,19 +75,21 @@
 #define MAX_FDS 10
 
 typedef struct {
-    interface_t * interface;
-    int fds[MAX_FDS];
-    size_t num_fds;
+  interface_t *interface;
+  int fds[MAX_FDS];
+  size_t num_fds;
 } interface_map_data_t;
 
 TYPEDEF_SET_H(facelet_set, facelet_t *);
 TYPEDEF_SET(facelet_set, facelet_t *, facelet_cmp, facelet_snprintf);
 
 TYPEDEF_MAP_H(interface_map, const char *, interface_map_data_t *);
-TYPEDEF_MAP(interface_map, const char *, interface_map_data_t *, strcmp, string_snprintf, generic_snprintf);
+TYPEDEF_MAP(interface_map, const char *, interface_map_data_t *, strcmp,
+            string_snprintf, generic_snprintf);
 
 TYPEDEF_MAP_H(bonjour_map, netdevice_t *, interface_t *);
-TYPEDEF_MAP(bonjour_map, netdevice_t *, interface_t *, netdevice_cmp, generic_snprintf, generic_snprintf);
+TYPEDEF_MAP(bonjour_map, netdevice_t *, interface_t *, netdevice_cmp,
+            generic_snprintf, generic_snprintf);
 
 /* TODO automatically register interfaces */
 
@@ -104,12 +97,13 @@ TYPEDEF_MAP(bonjour_map, netdevice_t *, interface_t *, netdevice_cmp, generic_sn
 extern interface_ops_t network_framework_ops;
 #endif
 #ifdef __linux__
+#ifdef __ANDROID__
+extern interface_ops_t android_ops;
+#else
 extern interface_ops_t netlink_ops;
+#endif /* __ANDROID__ */
 extern interface_ops_t bonjour_ops;
 #endif
-#ifdef WITH_FACEMGR_UTILITY
-extern interface_ops_t android_utility_ops;
-#endif /* WITH_FACEMGR_UTILITY */
 #ifdef WITH_PRIORITY_CONTROLLER
 extern interface_ops_t priority_controller_ops;
 #endif
@@ -121,458 +115,421 @@ extern interface_ops_t updown_ops;
 #endif
 extern interface_ops_t hicn_light_ops;
 
-int facemgr_on_event(facemgr_t * facemgr, facelet_t * facelet);
+int facemgr_on_event(facemgr_t *facemgr, facelet_t *facelet);
 
-int
-facemgr_overlay_snprintf(char * s, size_t size, const facemgr_overlay_t * overlay)
-{
-    return -1;
+int facemgr_overlay_snprintf(char *s, size_t size,
+                             const facemgr_overlay_t *overlay) {
+  return -1;
 }
 
 struct facemgr_s {
-    /**************************************************/
-    /* Configuration parameters (exposed through API) */
+  /**************************************************/
+  /* Configuration parameters (exposed through API) */
 
-    facemgr_cfg_t * cfg;
+  facemgr_cfg_t *cfg;
 
 #ifdef __ANDROID__
-    /*
-     * Those two pointers are needed to call java functions from the face
-     * manager.
-     */
-    JavaVM *jvm;
+  /*
+   * Those two pointers are needed to call java functions from the face
+   * manager.
+   */
+  JavaVM *jvm;
 #endif /* __ANDROID__ */
 
-    /* Callback */
-    facemgr_cb_t callback;
-    void * callback_owner;
+  /* Callback */
+  facemgr_cb_t callback;
+  void *callback_owner;
 
-    /****************************/
-    /* Internal data structures */
+  /****************************/
+  /* Internal data structures */
 
-    /* Map of interfaces index by name */
-    interface_map_t * interface_map;
+  /* Map of interfaces index by name */
+  interface_map_t *interface_map;
 
-    /* Faces under construction */
-    facelet_set_t * facelet_cache;
+  /* Faces under construction */
+  facelet_set_t *facelet_cache;
 
-    /* Static facelets */
-    facelet_array_t * static_facelets;
+  /* Static facelets */
+  facelet_array_t *static_facelets;
 
 #ifdef WITH_DEFAULT_PRIORITIES
-    /* Default priorities */
-    u32 default_priority[NETDEVICE_TYPE_N+1];
+  /* Default priorities */
+  u32 default_priority[NETDEVICE_TYPE_N + 1];
 #endif /* WITH_DEFAULT_PRIORITIES */
 
-    /********************************************************/
-    /* Interfaces - Those should be fully replaced by a map */
-
-    interface_t * hl;
+  /********************************************************/
+  /* Interfaces - Those should be fully replaced by a map */
 
-#ifdef WITH_FACEMGR_UTILITY
-    interface_t * au; /* android_utility */
-#endif /* WITH_FACEMGR_UTILITY */
+  interface_t *hl;
 
 #ifdef WITH_PRIORITY_CONTROLLER
-    interface_t * pc;
+  interface_t *pc;
 #endif
 
 #ifdef __APPLE__
-    interface_t * nf; /* network_framework */
-#endif /* __APPLE__ */
+  interface_t *nf; /* network_framework */
+#endif             /* __APPLE__ */
 
 #ifdef __linux__
-    interface_t * nl; /* netlink */
-    /*
-     * We maintain a map of dynamically created bonjour interfaces, one for each
-     * found netdevice
-     */
-    bonjour_map_t * bonjour_map;
+#ifdef __ANDROID__
+  interface_t *android;
+#else
+  interface_t *nl; /* netlink */
+#endif /* __ANDROID__ */
+  /*
+   * We maintain a map of dynamically created bonjour interfaces, one for each
+   * found netdevice
+   */
+  bonjour_map_t *bonjour_map;
 #endif /* __linux__ */
 
 #ifdef WITH_EXAMPLE_DUMMY
-    interface_t * dummy;
+  interface_t *dummy;
 #endif
 #ifdef WITH_EXAMPLE_UPDOWN
-    interface_t * updown;
+  interface_t *updown;
 #endif
-    int timer_fd; /* Timer used for reattempts */
+  int timer_fd; /* Timer used for reattempts */
 
-    int cur_static_id; /* Used to distinguish static faces (pre-incremented) */
+  int cur_static_id; /* Used to distinguish static faces (pre-incremented) */
 };
 
-int
-facemgr_initialize(facemgr_t * facemgr)
-{
-    facemgr->interface_map = interface_map_create();
-    if (!facemgr->interface_map) {
-        ERROR("[facemgr_initialize] Error creating interface map");
-        goto ERR_INTERFACE_MAP;
-    }
-
-    facemgr->facelet_cache = facelet_set_create();
-    if (!facemgr->facelet_cache) {
-        ERROR("[facemgr_initialize] Error creating interface map");
-        goto ERR_FACE_CACHE_PENDING;
-    }
-
-    facemgr->static_facelets = facelet_array_create();
-    if (!facemgr->static_facelets) {
-        ERROR("[facemgr_initialize] Error creating interface map");
-        goto ERR_STATIC;
-    }
+int facemgr_initialize(facemgr_t *facemgr) {
+  facemgr->interface_map = interface_map_create();
+  if (!facemgr->interface_map) {
+    ERROR("[facemgr_initialize] Error creating interface map");
+    goto ERR_INTERFACE_MAP;
+  }
+
+  facemgr->facelet_cache = facelet_set_create();
+  if (!facemgr->facelet_cache) {
+    ERROR("[facemgr_initialize] Error creating interface map");
+    goto ERR_FACE_CACHE_PENDING;
+  }
+
+  facemgr->static_facelets = facelet_array_create();
+  if (!facemgr->static_facelets) {
+    ERROR("[facemgr_initialize] Error creating interface map");
+    goto ERR_STATIC;
+  }
 
 #ifdef __linux__
-    facemgr->bonjour_map = bonjour_map_create();
-    if (!facemgr->bonjour_map) {
-        ERROR("[facemgr_initialize] Error creating bonjour map");
-        goto ERR_BJ;
-    }
+  facemgr->bonjour_map = bonjour_map_create();
+  if (!facemgr->bonjour_map) {
+    ERROR("[facemgr_initialize] Error creating bonjour map");
+    goto ERR_BJ;
+  }
 #endif /* __linux */
 
-    facemgr->cfg = facemgr_cfg_create();
-    if (!facemgr->cfg) {
-        ERROR("[facemgr_initialize] Error creating face manager configuration");
-        goto ERR_CFG;
-    }
+  facemgr->cfg = facemgr_cfg_create();
+  if (!facemgr->cfg) {
+    ERROR("[facemgr_initialize] Error creating face manager configuration");
+    goto ERR_CFG;
+  }
 
-    facemgr->timer_fd = 0;
-    facemgr->cur_static_id = 0;
+  facemgr->timer_fd = 0;
+  facemgr->cur_static_id = 0;
 
 #ifdef WITH_DEFAULT_PRIORITIES
 
-#define _(x) facemgr->default_priority[NETDEVICE_TYPE_ ## x] = 0;
-foreach_netdevice_type
+#define _(x) facemgr->default_priority[NETDEVICE_TYPE_##x] = 0;
+  foreach_netdevice_type
 #undef _
 
 #endif /* WITH_DEFAULT_PRIORITIES */
 
-    return 0;
+      return 0;
 
 ERR_CFG:
 #ifdef __linux__
-    bonjour_map_free(facemgr->bonjour_map);
+  bonjour_map_free(facemgr->bonjour_map);
 ERR_BJ:
 #endif /* __linux__ */
-    facelet_array_free(facemgr->static_facelets);
+  facelet_array_free(facemgr->static_facelets);
 ERR_STATIC:
-    facelet_set_free(facemgr->facelet_cache);
+  facelet_set_free(facemgr->facelet_cache);
 ERR_FACE_CACHE_PENDING:
-    interface_map_free(facemgr->interface_map);
+  interface_map_free(facemgr->interface_map);
 ERR_INTERFACE_MAP:
-    return -1;
+  return -1;
 }
 
-int
-facemgr_finalize(facemgr_t * facemgr)
-{
-    int ret = 0;
-    int rc;
+int facemgr_finalize(facemgr_t *facemgr) {
+  int ret = 0;
+  int rc;
 
-    if (facemgr->timer_fd) {
-        rc = facemgr->callback(facemgr->callback_owner,
-                FACEMGR_CB_TYPE_UNREGISTER_TIMER, &facemgr->timer_fd);
-        if (rc < 0) {
-            ERROR("[facemgr_finalize] Error unregistering timer");
-            ret = -1;
-        }
-        facemgr->timer_fd = 0;
+  if (facemgr->timer_fd) {
+    rc =
+        facemgr->callback(facemgr->callback_owner,
+                          FACEMGR_CB_TYPE_UNREGISTER_TIMER, &facemgr->timer_fd);
+    if (rc < 0) {
+      ERROR("[facemgr_finalize] Error unregistering timer");
+      ret = -1;
     }
+    facemgr->timer_fd = 0;
+  }
 
-    interface_map_free(facemgr->interface_map);
+  interface_map_free(facemgr->interface_map);
 
-    /* Free all facelets from cache */
-    facelet_t ** facelet_array;
-    int n = facelet_set_get_array(facemgr->facelet_cache, &facelet_array);
-    if (n < 0) {
-        ERROR("[facemgr_finalize] Could not retrieve facelets in cache");
-    } else {
-        for (unsigned i = 0; i < n; i++) {
-            facelet_t * facelet = facelet_array[i];
-            if (facelet_set_remove(facemgr->facelet_cache, facelet, NULL)) {
-                ERROR("[facemgr_finalize] Could not purge facelet from cache");
-            }
-            facelet_free(facelet);
-        }
-        free(facelet_array);
+  /* Free all facelets from cache */
+  facelet_t **facelet_array;
+  int n = facelet_set_get_array(facemgr->facelet_cache, &facelet_array);
+  if (n < 0) {
+    ERROR("[facemgr_finalize] Could not retrieve facelets in cache");
+  } else {
+    for (unsigned i = 0; i < n; i++) {
+      facelet_t *facelet = facelet_array[i];
+      if (!facelet) continue; /* Should not occur */
+      if (facelet_set_remove(facemgr->facelet_cache, facelet, NULL)) {
+        ERROR("[facemgr_finalize] Could not purge facelet from cache");
+      }
+      facelet_free(facelet);
     }
+    free(facelet_array);
+  }
 
-    facelet_set_free(facemgr->facelet_cache);
+  facelet_set_free(facemgr->facelet_cache);
 
-    /* Free all facelets from static array */
-    for (unsigned i = 0; i < facelet_array_len(facemgr->static_facelets); i++) {
-        facelet_t * facelet;
-        if (facelet_array_get_index(facemgr->static_facelets, i, &facelet) < 0) {
-            ERROR("[facemgr_cfg_finalize] Error getting facelet in array");
-            continue;
-        }
-        if (facelet_array_remove_index(facemgr->static_facelets, i, NULL) < 0) {
-            ERROR("[facemgr_finalize] Could not purge facelet from static array");
-        }
-        facelet_free(facelet);
+  /* Free all facelets from static array */
+  for (unsigned i = 0; i < facelet_array_len(facemgr->static_facelets); i++) {
+    facelet_t *facelet;
+    if (facelet_array_get_index(facemgr->static_facelets, i, &facelet) < 0) {
+      ERROR("[facemgr_cfg_finalize] Error getting facelet in array");
+      continue;
+    }
+    if (facelet_array_remove_index(facemgr->static_facelets, i, NULL) < 0) {
+      ERROR("[facemgr_finalize] Could not purge facelet from static array");
     }
+    facelet_free(facelet);
+  }
 
-    facelet_array_free(facemgr->static_facelets);
+  facelet_array_free(facemgr->static_facelets);
 
 #ifdef __linux__
-    bonjour_map_free(facemgr->bonjour_map);
+  bonjour_map_free(facemgr->bonjour_map);
 #endif /* __linux__ */
 
-    interface_unregister_all();
+  interface_unregister_all();
 
-    return ret;
+  return ret;
 }
 
 AUTOGENERATE_CREATE_FREE(facemgr);
 
-int
-facemgr_set_config(facemgr_t * facemgr, facemgr_cfg_t * cfg)
-{
-    if (facemgr->cfg) {
-        facemgr_cfg_free(facemgr->cfg);
-    }
-    facemgr->cfg = cfg;
-
-    /* Populate the initial list of static facelets */
-    facelet_t ** facelet_array;
-    int n = facemgr_cfg_get_static_facelet_array(cfg, &facelet_array);
-    if (n < 0) {
-        ERROR("[facemgr_finalize] Could not retrieve static facelets from cfg");
-    } else {
-        for (unsigned i = 0; i < n; i++) {
-            facelet_t * facelet = facelet_dup(facelet_array[i]);
-            facelet_set_status(facelet, FACELET_STATUS_UNDEFINED);
-            facelet_set_attr_clean(facelet);
-            if (facelet_array_add(facemgr->static_facelets, facelet)) {
-                ERROR("[facemgr_finalize] Could not add static facelet to face manager");
-            }
-        }
+int facemgr_set_config(facemgr_t *facemgr, facemgr_cfg_t *cfg) {
+  if (facemgr->cfg) {
+    facemgr_cfg_free(facemgr->cfg);
+  }
+  facemgr->cfg = cfg;
+
+  /* Populate the initial list of static facelets */
+  facelet_t **facelet_array;
+  int n = facemgr_cfg_get_static_facelet_array(cfg, &facelet_array);
+  if (n < 0) {
+    ERROR("[facemgr_finalize] Could not retrieve static facelets from cfg");
+  } else {
+    for (unsigned i = 0; i < n; i++) {
+      facelet_t *facelet = facelet_dup(facelet_array[i]);
+      facelet_set_status(facelet, FACELET_STATUS_UNDEFINED);
+      facelet_set_attr_clean(facelet);
+      if (facelet_array_add(facemgr->static_facelets, facelet)) {
+        ERROR(
+            "[facemgr_finalize] Could not add static facelet to face manager");
+      }
     }
+  }
 
-    return 0;
+  return 0;
 }
 
-int facemgr_reset_config(facemgr_t * facemgr)
-{
-    assert(facemgr->cfg);
-    facemgr_cfg_free(facemgr->cfg);
-    facemgr->cfg = facemgr_cfg_create();
-    if (!facemgr->cfg)
-        return -1;
-    return 0;
+int facemgr_reset_config(facemgr_t *facemgr) {
+  assert(facemgr->cfg);
+  facemgr_cfg_free(facemgr->cfg);
+  facemgr->cfg = facemgr_cfg_create();
+  if (!facemgr->cfg) return -1;
+  return 0;
 }
 
-facemgr_t *
-facemgr_create_with_config(facemgr_cfg_t * cfg)
-{
-    facemgr_t * facemgr = facemgr_create();
-    if (!facemgr)
-        return NULL;
-    int rc = facemgr_set_config(facemgr, cfg);
-    if (rc < 0) {
-        free(facemgr);
-        return NULL;
-    }
-    return facemgr;
+facemgr_t *facemgr_create_with_config(facemgr_cfg_t *cfg) {
+  facemgr_t *facemgr = facemgr_create();
+  if (!facemgr) return NULL;
+  int rc = facemgr_set_config(facemgr, cfg);
+  if (rc < 0) {
+    free(facemgr);
+    return NULL;
+  }
+  return facemgr;
 }
 
 /*
  * \brief Heuristics to determine face type based on name, until a better
  * solution is found
  */
-netdevice_type_t
-facemgr_get_netdevice_type(const facemgr_t * facemgr, const char * interface_name)
-{
-    if (strncmp(interface_name, "lo", 2) == 0) {
-        return NETDEVICE_TYPE_LOOPBACK;
-    }
-    if ((strncmp(interface_name, "eth", 3) == 0) ||
-            (strncmp(interface_name, "en", 2) == 0)) {
-        /* eth* en* enx* */
-        return NETDEVICE_TYPE_WIRED;
-    }
-    if (strncmp(interface_name, "wl", 2) == 0) {
-        /* wlan* wlp* wlx* */
-        return NETDEVICE_TYPE_WIFI;
-    }
-    if (strncmp(interface_name, "rmnet_ipa", 9) == 0) {
-        /* Qualcomm IPA driver */
-        return NETDEVICE_TYPE_UNDEFINED;
-    }
-    if ((strncmp(interface_name, "rmnet", 5) == 0) ||
-            (strncmp(interface_name, "rev_rmnet", 9) == 0) ||
-            (strncmp(interface_name, "ccmni", 5) == 0)) {
-        /*
-         * rmnet* (Qualcomm) ccmni* (MediaTek)
-         */
-        return NETDEVICE_TYPE_CELLULAR;
-    }
-    /* usb0 might be cellular (eg Zenfone2) */
-    /* what about tethering */
-    /* tun* dummy* ... */
-    /* bnet* pan* hci* for bluetooth */
+netdevice_type_t facemgr_get_netdevice_type(const facemgr_t *facemgr,
+                                            const char *interface_name) {
+  if (strncmp(interface_name, "lo", 2) == 0) {
+    return NETDEVICE_TYPE_LOOPBACK;
+  }
+  if ((strncmp(interface_name, "eth", 3) == 0) ||
+      (strncmp(interface_name, "en", 2) == 0)) {
+    /* eth* en* enx* */
+    return NETDEVICE_TYPE_WIRED;
+  }
+  if (strncmp(interface_name, "wl", 2) == 0) {
+    /* wlan* wlp* wlx* */
+    return NETDEVICE_TYPE_WIFI;
+  }
+  if (strncmp(interface_name, "rmnet_ipa", 9) == 0) {
+    /* Qualcomm IPA driver */
     return NETDEVICE_TYPE_UNDEFINED;
+  }
+  if ((strncmp(interface_name, "rmnet", 5) == 0) ||
+      (strncmp(interface_name, "rev_rmnet", 9) == 0) ||
+      (strncmp(interface_name, "ccmni", 5) == 0)) {
+    /*
+     * rmnet* (Qualcomm) ccmni* (MediaTek)
+     */
+    return NETDEVICE_TYPE_CELLULAR;
+  }
+  /* usb0 might be cellular (eg Zenfone2) */
+  /* what about tethering */
+  /* tun* dummy* ... */
+  /* bnet* pan* hci* for bluetooth */
+  return NETDEVICE_TYPE_UNDEFINED;
 }
 
-int facemgr_callback(facemgr_t * facemgr, interface_cb_type_t type, void * data);
-
-int
-facemgr_create_interface(facemgr_t * facemgr, const char * name, const char * type, void * cfg, interface_t ** pinterface)
-{
-    char rand_name[RAND_NAME_LEN+1];
-    interface_t * interface;
-
-    if (!name) {
-        /*
-         * We can manipulate the name on the stack as it will be strdup'ed by
-         * interface_create
-         */
-        rand_str(rand_name, RAND_NAME_LEN);
-        name = rand_name;
-    }
-
-    INFO("Creating interface %s [%s]...", name, type);
-    interface = interface_create(name, type);
-    if (!interface) {
-        ERROR("Error creating interface %s [%s]", name, type);
-        goto ERR_CREATE;
-    }
-    interface_set_callback(interface, facemgr, facemgr_callback);
+int facemgr_callback(facemgr_t *facemgr, interface_cb_type_t type, void *data);
 
-    interface_map_data_t * interface_map_data = malloc(sizeof(interface_map_data_t));
-    if (!interface_map_data)
-        goto ERR_MAP_DATA;
-
-    *interface_map_data = (interface_map_data_t) {
-        .interface = interface,
-        .fds = {0},
-        .num_fds = 0,
-    };
-
-    if (interface_map_add(facemgr->interface_map, interface->name, interface_map_data) < 0)
-        goto ERR_MAP_ADD;
+int facemgr_create_interface(facemgr_t *facemgr, const char *name,
+                             const char *type, void *cfg,
+                             interface_t **pinterface) {
+  char rand_name[RAND_NAME_LEN + 1];
+  interface_t *interface;
 
+  if (!name) {
     /*
-     * This should be called _after_ the interface_map is initialized otherwise
-     * it will be impossible to register fds from *_initialize
+     * We can manipulate the name on the stack as it will be strdup'ed by
+     * interface_create
      */
-    if (interface_initialize(interface, cfg) < 0) {
-        ERROR("[facemgr_create_interface] Error initializing interface");
-        goto ERR_INIT;
-    }
-
-    DEBUG("Interface %s created successfully.", name);
-    if (pinterface)
-        *pinterface = interface;
-    return 0;
-
-
-    //interface_finalize(interface);
+    rand_str(rand_name, RAND_NAME_LEN);
+    name = rand_name;
+  }
+
+  INFO("Creating interface %s [%s]...", name, type);
+  interface = interface_create(name, type);
+  if (!interface) {
+    ERROR("Error creating interface %s [%s]", name, type);
+    goto ERR_CREATE;
+  }
+  interface_set_callback(interface, facemgr, facemgr_callback);
+
+  interface_map_data_t *interface_map_data =
+      malloc(sizeof(interface_map_data_t));
+  if (!interface_map_data) goto ERR_MAP_DATA;
+
+  *interface_map_data = (interface_map_data_t){
+      .interface = interface,
+      .fds = {0},
+      .num_fds = 0,
+  };
+
+  if (interface_map_add(facemgr->interface_map, interface->name,
+                        interface_map_data) < 0)
+    goto ERR_MAP_ADD;
+
+  /*
+   * This should be called _after_ the interface_map is initialized otherwise
+   * it will be impossible to register fds from *_initialize
+   */
+  if (interface_initialize(interface, cfg) < 0) {
+    ERROR("[facemgr_create_interface] Error initializing interface");
+    goto ERR_INIT;
+  }
+
+  DEBUG("Interface %s created successfully.", name);
+  if (pinterface) *pinterface = interface;
+  return 0;
+
+  // interface_finalize(interface);
 ERR_INIT:
-    interface_map_remove(facemgr->interface_map, interface->name, NULL);
+  interface_map_remove(facemgr->interface_map, interface->name, NULL);
 ERR_MAP_ADD:
-    free(interface_map_data);
+  free(interface_map_data);
 ERR_MAP_DATA:
-    interface_free(interface);
+  interface_free(interface);
 ERR_CREATE:
-    if (pinterface)
-        *pinterface = NULL;
-    return -1;
+  if (pinterface) *pinterface = NULL;
+  return -1;
 }
 
-int
-facemgr_delete_interface(facemgr_t * facemgr, interface_t * interface)
-{
-    int rc;
-
-    interface_map_data_t * interface_map_data = NULL;
+int facemgr_delete_interface(facemgr_t *facemgr, interface_t *interface) {
+  int rc;
 
-    DEBUG("Removing interface %s", interface->name);
-    rc = interface_map_remove(facemgr->interface_map, interface->name, &interface_map_data);
-    if (rc < 0)
-        return -1;
+  /*
+   * It is possible that one interface was never initialized, and thus the
+   * facemgr never started, and we still call stop(). This is for instance the
+   * case on Android (sdk 30) when netlink is blocked.
+   */
+  if (!interface) return 0;
 
-    if (!interface_map_data)
-        return -1;
-
-    for (unsigned i = 0; i < interface_map_data->num_fds; i++) {
-        int fd = interface_map_data->fds[i];
-        fd_callback_data_t fd_callback_data = {
-            .fd = fd,
-            .owner = facemgr,
-            .callback = NULL,
-            .data = NULL,
-        };
-        facemgr->callback(facemgr->callback_owner, FACEMGR_CB_TYPE_UNREGISTER_FD, &fd_callback_data);
-        if (rc < 0)
-            WARN("[facemgr_delete_interface] Error unregistering fd %d for interface", fd);
-    }
+  interface_map_data_t *interface_map_data = NULL;
 
-    free(interface_map_data);
+  DEBUG("Removing interface %s", interface->name);
+  rc = interface_map_remove(facemgr->interface_map, interface->name,
+                            &interface_map_data);
+  if (rc < 0) return -1;
 
-    interface_finalize(interface);
-    interface_free(interface);
+  if (!interface_map_data) return -1;
 
-    return 0;
-}
-
-#ifdef __linux__
-int facemgr_query_bonjour(facemgr_t * facemgr, netdevice_t * netdevice)
-{
-    interface_t * bj = NULL;
-
-    int rc = bonjour_map_get(facemgr->bonjour_map, netdevice, &bj);
+  for (unsigned i = 0; i < interface_map_data->num_fds; i++) {
+    int fd = interface_map_data->fds[i];
+    fd_callback_data_t fd_callback_data = {
+        .fd = fd,
+        .owner = facemgr,
+        .callback = NULL,
+        .data = NULL,
+    };
+    facemgr->callback(facemgr->callback_owner, FACEMGR_CB_TYPE_UNREGISTER_FD,
+                      &fd_callback_data);
     if (rc < 0)
-        return rc;
-
-    if (!bj) {
-        /* Create a new bonjour interface */
-        bonjour_cfg_t bj_cfg = {
-            .netdevice = *netdevice,
-        };
-        rc = facemgr_create_interface(facemgr, NULL, "bonjour", &bj_cfg, &bj);
-        if (rc < 0) {
-            ERROR("Error creating 'Bonjour' interface for '%s'\n", netdevice->name);
-            return -1;
-        }
-    }
+      WARN("[facemgr_delete_interface] Error unregistering fd %d for interface",
+           fd);
+  }
 
-    DEBUG("sending event to bonjour interface");
+  free(interface_map_data);
 
-    /* Send an event to the interface (GET ?) */
-    // XXX error handling
-    return interface_on_event(bj, NULL);
+  interface_finalize(interface);
+  interface_free(interface);
+
+  return 0;
 }
-#endif /* __linux__ */
 
-#ifdef WITH_FACEMGR_UTILITY
-int facemgr_query_android_utility(facemgr_t * facemgr, netdevice_t netdevice)
-{
-    /* Send an event to the interface */
-    facelet_t * facelet = facelet_create();
-    if (!facelet)
-        goto ERR_MALLOC;
+#ifdef __linux__
+int facemgr_query_bonjour(facemgr_t *facemgr, netdevice_t *netdevice) {
+  interface_t *bj = NULL;
 
-    int rc = facelet_set_netdevice(facelet, netdevice);
-    if (rc < 0)
-        goto ERR_ND;
+  int rc = bonjour_map_get(facemgr->bonjour_map, netdevice, &bj);
+  if (rc < 0) return rc;
 
-    rc = interface_on_event(facemgr->au, facelet);
+  if (!bj) {
+    /* Create a new bonjour interface */
+    bonjour_cfg_t bj_cfg = {
+        .netdevice = *netdevice,
+    };
+    rc = facemgr_create_interface(facemgr, NULL, "bonjour", &bj_cfg, &bj);
     if (rc < 0) {
-        // XXX error handling
-        goto ERR_EVENT;
+      ERROR("Error creating 'Bonjour' interface for '%s'\n", netdevice->name);
+      return -1;
     }
+  }
 
-    return 0;
+  DEBUG("sending event to bonjour interface");
 
-ERR_EVENT:
-ERR_ND:
-    facelet_free(facelet);
-ERR_MALLOC:
-    return -1;
+  /* Send an event to the interface (GET ?) */
+  // XXX error handling
+  return interface_on_event(bj, NULL);
 }
-#endif /* WITH_FACEMGR_UTILITY */
-
+#endif /* __linux__ */
 
 /**
  * \brief Performs a cache lookup to find matching facelets
@@ -583,43 +540,38 @@ ERR_MALLOC:
  * \return The number of entries in the array in case of success (positive
  *      value), or -1 in case of error.
  */
-int
-facelet_cache_lookup(const facelet_set_t * facelet_cache, facelet_t * facelet,
-        facelet_t ***cached_facelets)
-{
-    assert(facelet);
-
-    /* ...otherwise, we iterate over the facelet
-     * cache to find matching elements.
-     */
-    facelet_t ** facelet_array;
-    int n = facelet_set_get_array(facelet_cache, &facelet_array);
-    if (n < 0) {
-        ERROR("[facelet_cache_lookup] Error during cache match");
-        return -1;
-    }
-    if (cached_facelets)
-        *cached_facelets = malloc(n * sizeof(facelet_t*));
+int facelet_cache_lookup(const facelet_set_t *facelet_cache, facelet_t *facelet,
+                         facelet_t ***cached_facelets) {
+  assert(facelet);
+
+  /* ...otherwise, we iterate over the facelet
+   * cache to find matching elements.
+   */
+  facelet_t **facelet_array;
+  int n = facelet_set_get_array(facelet_cache, &facelet_array);
+  if (n < 0) {
+    ERROR("[facelet_cache_lookup] Error during cache match");
+    return -1;
+  }
+  if (cached_facelets) *cached_facelets = malloc(n * sizeof(facelet_t *));
 
-    int num_match = 0;
-    for (unsigned i = 0; i < n; i++) {
+  int num_match = 0;
+  for (unsigned i = 0; i < n; i++) {
 #if 0
-        char facelet_s[MAXSZ_FACELET];
-        facelet_snprintf(facelet_s, MAXSZ_FACELET, facelet_array[i]);
-        DEBUG("cache entry #%d/%di = %s", i+1, n, facelet_s);
+    char facelet_s[MAXSZ_FACELET];
+    facelet_snprintf(facelet_s, MAXSZ_FACELET, facelet_array[i]);
+    DEBUG("cache entry #%d/%di = %s", i + 1, n, facelet_s);
 #endif
-        if (!facelet_match(facelet_array[i], facelet)) {
-            continue;
-        }
-        if (cached_facelets)
-            (*cached_facelets)[num_match] = facelet_array[i];
-        num_match++;
-    }
-    free(facelet_array);
-    return num_match;
+    facelet_t *f = facelet_array[i];
+    if (!f) continue; /* Should not occur */
+    if (!facelet_match(f, facelet)) continue;
+    if (cached_facelets) (*cached_facelets)[num_match] = f;
+    num_match++;
+  }
+  free(facelet_array);
+  return num_match;
 }
 
-
 /**
  * \brief Checks whether the facelet satisfies face creation rules
  * \param [in] facemgr - Pointer to the face manager instance
@@ -627,129 +579,92 @@ facelet_cache_lookup(const facelet_set_t * facelet_cache, facelet_t * facelet,
  * \return 0 in case of success, -2 if we don't have enough information to
  * decide, -3 if the face does not satisfy rules, and -1 in case of error
  */
-int
-facemgr_facelet_satisfy_rules(facemgr_t * facemgr, facelet_t * facelet)
-{
-    /* As key, netdevice and family should always be present */
-    netdevice_t netdevice = NETDEVICE_EMPTY;
-    int rc = facelet_get_netdevice(facelet, &netdevice);
-    if (rc < 0) {
-        ERROR("[facemgr_facelet_satisfy_rules] Error retrieving netdevice from facelet");
+int facemgr_facelet_satisfy_rules(facemgr_t *facemgr, facelet_t *facelet) {
+  /* As key, netdevice and family should always be present */
+  netdevice_t netdevice = NETDEVICE_EMPTY;
+  int rc = facelet_get_netdevice(facelet, &netdevice);
+  if (rc < 0) {
+    ERROR(
+        "[facemgr_facelet_satisfy_rules] Error retrieving netdevice from "
+        "facelet");
+    return -1;
+  }
+
+  int family = AF_UNSPEC;
+  if (facelet_has_family(facelet)) {
+    if (facelet_get_family(facelet, &family) < 0) {
+      ERROR(
+          "[facemgr_facelet_satisfy_rules] Error retrieving family from "
+          "facelet");
+      return -1;
+    }
+  }
+
+  netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
+  /*
+   * In addition to netdevice, netdevice_type should be present to correctly
+   * apply rules
+   */
+  rc = facelet_get_netdevice_type(facelet, &netdevice_type);
+  if (rc < 0) {
+    ERROR(
+        "[facemgr_facelet_satisfy_rules] Error retrieving netdevice_type from "
+        "facelet");
+    return -2;
+  }
+
+  /* Default ignore list */
+  if ((netdevice_type == NETDEVICE_TYPE_LOOPBACK) ||
+      (netdevice_type == NETDEVICE_TYPE_UNDEFINED)) {
+    DEBUG("Ignored interface '%s/%s'...", netdevice.name,
+          netdevice_type_str(netdevice_type));
+    return -3;
+  }
+
+  /* Ignore */
+  bool ignore;
+  if (facemgr_cfg_get_ignore(facemgr->cfg, &netdevice, netdevice_type,
+                             &ignore) < 0)
+    return -1;
+  if (ignore) {
+    DEBUG("Ignored interface '%s/%s'...", netdevice.name,
+          netdevice_type_str(netdevice_type));
+    return -3;
+  }
+
+  switch (family) {
+    case AF_INET: {
+      bool ipv4;
+      if (facemgr_cfg_get_ipv4(facemgr->cfg, &netdevice, netdevice_type,
+                               &ipv4) < 0)
         return -1;
-    }
-
-    int family = AF_UNSPEC;
-    if (facelet_has_family(facelet)) {
-        if (facelet_get_family(facelet, &family) < 0) {
-            ERROR("[facemgr_facelet_satisfy_rules] Error retrieving family from facelet");
-            return -1;
-        }
-    }
-
-    netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
-#ifndef WITH_FACEMGR_UTILITY
-    /*
-     * In addition to netdevice, netdevice_type should be present to correctly
-     * apply rules
-     */
-    rc = facelet_get_netdevice_type(facelet, &netdevice_type);
-    if (rc < 0) {
-        ERROR("[facemgr_facelet_satisfy_rules] Error retrieving netdevice_type from facelet");
-        return -2;
-    }
-#endif /* WITH_FACEMGR_UTILITY */
-
-    /* Default ignore list */
-    if ((netdevice_type == NETDEVICE_TYPE_LOOPBACK) || (netdevice_type == NETDEVICE_TYPE_UNDEFINED)) {
-        DEBUG("Ignored interface '%s/%s'...", netdevice.name,
-                netdevice_type_str[netdevice_type]);
+      if (!ipv4) {
+        DEBUG("Ignored IPv4 facelet...");
         return -3;
+      }
+      break;
     }
 
-    /* Ignore */
-    bool ignore;
-    if (facemgr_cfg_get_ignore(facemgr->cfg, &netdevice, netdevice_type,
-                &ignore) < 0)
+    case AF_INET6: {
+      bool ipv6;
+      if (facemgr_cfg_get_ipv6(facemgr->cfg, &netdevice, netdevice_type,
+                               &ipv6) < 0)
         return -1;
-    if (ignore) {
-        DEBUG("Ignored interface '%s/%s'...", netdevice.name,
-                netdevice_type_str[netdevice_type]);
+      if (!ipv6) {
+        DEBUG("Ignored IPv6 facelet...");
         return -3;
+      }
+      break;
     }
 
-    switch(family) {
-        case AF_INET:
-        {
-            bool ipv4;
-            if (facemgr_cfg_get_ipv4(facemgr->cfg, &netdevice, netdevice_type,
-                        &ipv4) < 0)
-                return -1;
-            if (!ipv4) {
-                DEBUG("Ignored IPv4 facelet...");
-                return -3;
-            }
-            break;
-        }
-
-        case AF_INET6:
-        {
-            bool ipv6;
-            if (facemgr_cfg_get_ipv6(facemgr->cfg, &netdevice, netdevice_type,
-                        &ipv6) < 0)
-                return -1;
-            if (!ipv6) {
-                DEBUG("Ignored IPv6 facelet...");
-                return -3;
-            }
-            break;
-        }
-
-        default:
-            DEBUG("Ignored facelet with unknown family");
-            return -2;
-    }
+    default:
+      DEBUG("Ignored facelet with unknown family");
+      return -2;
+  }
 
-    return 0;
+  return 0;
 }
 
-#ifdef WITH_FACEMGR_UTILITY
-/**
- * \brief Complements facelet information through Android Utility interface
- * \return 0 if request was successful, -1 in case of error, and -2 if the
- *      interface is not applicable
- *
- * This function returnds _after_ completion.
- */
-int
-facemgr_complement_facelet_au(facemgr_t * facemgr, facelet_t * facelet)
-{
-
-    if (facelet_has_netdevice_type(facelet))
-        return -2;
-
-    if (facelet_is_au_done(facelet))
-        return -2;
-
-    netdevice_t netdevice = NETDEVICE_EMPTY;
-
-    int rc = facelet_get_netdevice(facelet, &netdevice);
-    if (rc < 0) {
-        ERROR("[facemgr_complement_facelet_bj] Error retrieving netdevice from facelet");
-        return -1;
-    }
-
-    DEBUG("Querying android utility...");
-
-    /* /!\ Synchronous code here /!\ */
-    if (facemgr_query_android_utility(facemgr, netdevice) < 0) {
-        return -1;
-    }
-
-    facelet_set_au_done(facelet);
-    return 0;
-}
-#endif /* WITH_FACEMGR_UTILITY */
-
 #ifdef __linux__
 /**
  * \brief Complements facelet information through Bonjour interface.
@@ -759,66 +674,68 @@ facemgr_complement_facelet_au(facemgr_t * facemgr, facelet_t * facelet)
  * This function returnds _before_ completion as bonjour querying is
  * asynchronous.
  */
-int
-facemgr_complement_facelet_bj(facemgr_t * facemgr, facelet_t * facelet)
-{
-    netdevice_t netdevice = NETDEVICE_EMPTY;
-    int rc = facelet_get_netdevice(facelet, &netdevice);
-    if (rc < 0) {
-        ERROR("[facemgr_complement_facelet_bj] Error retrieving netdevice from facelet");
-        return -1;
-    }
-
-    netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
-#ifndef WITH_FACEMGR_UTILITY
-    /*
-     * In addition to netdevice, netdevice_type should be present to correctly
-     * apply rules
-     */
-    rc = facelet_get_netdevice_type(facelet, &netdevice_type);
-    if (rc < 0) {
-        ERROR("[facemgr_complement_facelet_bj] Error retrieving netdevice_type from facelet");
-        return -2;
-    }
-#endif /* WITH_FACEMGR_UTILITY */
-
-    bool discovery;
-    if (facemgr_cfg_get_discovery(facemgr->cfg, &netdevice, netdevice_type,
-                &discovery) < 0)
-        return -2;
-
-    DEBUG("Discovery: %s", discovery ? "ON" : "OFF");
-
-    if (!discovery)
-        return -2;
-
-    facemgr_face_type_t face_type = FACEMGR_FACE_TYPE_UNDEFINED;
-    if (facelet_get_face_type(facelet, &face_type) < 0) {
-        ERROR("[facemgr_complement_facelet_bj] Error retrieving face type from facelet");
-        return -1;
-    }
+int facemgr_complement_facelet_bj(facemgr_t *facemgr, facelet_t *facelet) {
+  netdevice_t netdevice = NETDEVICE_EMPTY;
+  int rc = facelet_get_netdevice(facelet, &netdevice);
+  if (rc < 0) {
+    ERROR(
+        "[facemgr_complement_facelet_bj] Error retrieving netdevice from "
+        "facelet");
+    return -1;
+  }
+
+  netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
+  /*
+   * In addition to netdevice, netdevice_type should be present to correctly
+   * apply rules
+   */
+  rc = facelet_get_netdevice_type(facelet, &netdevice_type);
+  if (rc < 0) {
+    ERROR(
+        "[facemgr_complement_facelet_bj] Error retrieving netdevice_type from "
+        "facelet");
+    return -2;
+  }
+
+  bool discovery;
+  if (facemgr_cfg_get_discovery(facemgr->cfg, &netdevice, netdevice_type,
+                                &discovery) < 0)
+    return -2;
+
+  DEBUG("Discovery: %s", discovery ? "ON" : "OFF");
+
+  if (!discovery) return -2;
+
+  facemgr_face_type_t face_type = FACEMGR_FACE_TYPE_UNDEFINED;
+  if (facelet_get_face_type(facelet, &face_type) < 0) {
+    ERROR(
+        "[facemgr_complement_facelet_bj] Error retrieving face type from "
+        "facelet");
+    return -1;
+  }
 
-    bool discovery_needed = (face_type.layer == FACE_TYPE_LAYER_4) &&
-        ((!facelet_has_remote_addr(facelet)) || (!facelet_has_remote_port(facelet)));
+  bool discovery_needed = (face_type.layer == FACE_TYPE_LAYER_4) &&
+                          ((!facelet_has_remote_addr(facelet)) ||
+                           (!facelet_has_remote_port(facelet)));
 
-    DEBUG("Discovery needed: %s", discovery ? "ON" : "OFF");
+  DEBUG("Discovery needed: %s", discovery ? "ON" : "OFF");
 
-    if (!discovery_needed) {
-        return -2;
-    }
+  if (!discovery_needed) {
+    return -2;
+  }
 
-    if (!facelet_has_local_addr(facelet)) {
-        DEBUG("No discovery possible without local address");
-        return -2;
-    }
+  if (!facelet_has_local_addr(facelet)) {
+    DEBUG("No discovery possible without local address");
+    return -2;
+  }
 
-    if (facelet_is_bj_done(facelet)) {
-        DEBUG("Bonjour already queried");
-        return -2;
-    }
+  if (facelet_is_bj_done(facelet)) {
+    DEBUG("Bonjour already queried");
+    return -2;
+  }
 
-    facelet_set_bj_done(facelet);
-    return facemgr_query_bonjour(facemgr, &netdevice);
+  facelet_set_bj_done(facelet);
+  return facemgr_query_bonjour(facemgr, &netdevice);
 }
 #endif /* __linux__ */
 
@@ -830,49 +747,52 @@ facemgr_complement_facelet_bj(facemgr_t * facemgr, facelet_t * facelet)
  * This function returnds _before_ completion as bonjour querying is
  * asynchronous.
  */
-int
-facemgr_complement_facelet_manual(facemgr_t * facemgr, facelet_t * facelet)
-{
-
-    netdevice_t netdevice = NETDEVICE_EMPTY;
-    int rc = facelet_get_netdevice(facelet, &netdevice);
-    if (rc < 0) {
-        ERROR("[facemgr_complement_facelet_manual] Error retrieving netdevice from facelet");
-        return -1;
-    }
-
-    netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
-#ifndef WITH_FACEMGR_UTILITY
-    /*
-     * In addition to netdevice, netdevice_type should be present to correctly
-     * apply rules
-     */
-    rc = facelet_get_netdevice_type(facelet, &netdevice_type);
-    if (rc < 0) {
-        ERROR("[facemgr_complement_facelet_manual] Error retrieving netdevice_type from facelet");
-        return -2;
-    }
-#endif /* WITH_FACEMGR_UTILITY */
-
-    int family = AF_UNSPEC;
-    if (facelet_has_family(facelet)) {
-        if (facelet_get_family(facelet, &family) < 0) {
-            ERROR("[facemgr_complement_facelet_manual] Error retrieving family from facelet");
-            return -1;
-        }
-    }
-
-    /* Do not query manual is there is a change to go through bonjour */
-    bool discovery;
-    if (facemgr_cfg_get_discovery(facemgr->cfg, &netdevice, netdevice_type,
-                &discovery) < 0)
-        return -2;
-
-    facemgr_face_type_t face_type = FACEMGR_FACE_TYPE_UNDEFINED;
-    if (facelet_get_face_type(facelet, &face_type) < 0) {
-        ERROR("[facemgr_complement_facelet_manual] Error retrieving face type from facelet");
-        return -1;
-    }
+int facemgr_complement_facelet_manual(facemgr_t *facemgr, facelet_t *facelet) {
+  netdevice_t netdevice = NETDEVICE_EMPTY;
+  int rc = facelet_get_netdevice(facelet, &netdevice);
+  if (rc < 0) {
+    ERROR(
+        "[facemgr_complement_facelet_manual] Error retrieving netdevice from "
+        "facelet");
+    return -1;
+  }
+
+  netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
+  /*
+   * In addition to netdevice, netdevice_type should be present to correctly
+   * apply rules
+   */
+  rc = facelet_get_netdevice_type(facelet, &netdevice_type);
+  if (rc < 0) {
+    ERROR(
+        "[facemgr_complement_facelet_manual] Error retrieving netdevice_type "
+        "from facelet");
+    return -2;
+  }
+
+  int family = AF_UNSPEC;
+  if (facelet_has_family(facelet)) {
+    if (facelet_get_family(facelet, &family) < 0) {
+      ERROR(
+          "[facemgr_complement_facelet_manual] Error retrieving family from "
+          "facelet");
+      return -1;
+    }
+  }
+
+  /* Do not query manual is there is a change to go through bonjour */
+  bool discovery;
+  if (facemgr_cfg_get_discovery(facemgr->cfg, &netdevice, netdevice_type,
+                                &discovery) < 0)
+    return -2;
+
+  facemgr_face_type_t face_type = FACEMGR_FACE_TYPE_UNDEFINED;
+  if (facelet_get_face_type(facelet, &face_type) < 0) {
+    ERROR(
+        "[facemgr_complement_facelet_manual] Error retrieving face type from "
+        "facelet");
+    return -1;
+  }
 
 #if 0 /* Wrong if we need to complement local addr / port */
     bool discovery_needed = (face_type.layer == FACE_TYPE_LAYER_4) &&
@@ -884,91 +804,97 @@ facemgr_complement_facelet_manual(facemgr_t * facemgr, facelet_t * facelet)
     }
 #endif
 
-    if (discovery && !facelet_is_bj_done(facelet)) {
-        DEBUG("manual settings not considered as discovery is enabled and Bonjour has not yet been done");
-        return -2;
-    }
-
-    DEBUG("Applying manual settings...");
-    /*
-     * Manual overlay specification (remote addr/port)
-     * We never override a result we have obtained through bonjour
-     */
-    if (!facelet_has_remote_addr(facelet)) {
-        ip_address_t remote_addr;
-        if (facemgr_cfg_get_overlay_remote_addr(facemgr->cfg,
-                &netdevice, netdevice_type, family, &remote_addr) < 0) {
-            ERROR("[facemgr_complement_facelet_manual] Error getting remote addr information from cfg");
-            return -1;
-        }
-        if (ip_address_empty(&remote_addr)) {
-            ERROR("[facemgr_complement_facelet_manual] Got empty remote addr information from cfg");
-        } else {
-            DEBUG(" - remote address");
-            facelet_set_remote_addr(facelet, remote_addr);
-        }
-    }
-
-    if (!facelet_has_remote_port(facelet)) {
-        uint16_t remote_port;
-        int rc = facemgr_cfg_get_overlay_remote_port(facemgr->cfg,
-                &netdevice, netdevice_type, family, &remote_port);
-        if (rc < 0) {
-            ERROR("[facemgr_complement_facelet_manual] Error getting remote port information from cfg");
-            return -1;
-        }
-        DEBUG(" - remote port");
-        facelet_set_remote_port(facelet, remote_port);
-    }
-
-    /*
-     * Complementing local addr/port XXX this should be done somewhere
-     * else : manual settings have the lowest priority
-     *
-     * Local IP address is specific as it allows to override the source
-     * address just before creating the face... we would need to check
-     * whether this is an address that belong to us... it might be used
-     * to arbitrate amongst several IP addresses instead...
-     */
-    ip_address_t local_addr;
-    if (facemgr_cfg_get_overlay_local_addr(facemgr->cfg, &netdevice,
-            netdevice_type, family, &local_addr) < 0) {
-        ERROR("[facemgr_complement_facelet_manual] Error getting local addr information from cfg");
-        return -1;
-    }
-    if (ip_address_empty(&local_addr)) {
-        ERROR("[facemgr_complement_facelet_manual] Got empty local addr information from cfg");
+  if (discovery && !facelet_is_bj_done(facelet)) {
+    DEBUG(
+        "manual settings not considered as discovery is enabled and Bonjour "
+        "has not yet been done");
+    return -2;
+  }
+
+  DEBUG("Applying manual settings...");
+  /*
+   * Manual overlay specification (remote addr/port)
+   * We never override a result we have obtained through bonjour
+   */
+  if (!facelet_has_remote_addr(facelet)) {
+    ip_address_t remote_addr;
+    if (facemgr_cfg_get_overlay_remote_addr(facemgr->cfg, &netdevice,
+                                            netdevice_type, family,
+                                            &remote_addr) < 0) {
+      ERROR(
+          "[facemgr_complement_facelet_manual] Error getting remote addr "
+          "information from cfg");
+      return -1;
+    }
+    if (ip_address_empty(&remote_addr)) {
+      ERROR(
+          "[facemgr_complement_facelet_manual] Got empty remote addr "
+          "information from cfg");
     } else {
-        DEBUG(" - local addres");
-        facelet_set_local_addr(facelet, local_addr);
+      DEBUG(" - remote address");
+      facelet_set_remote_addr(facelet, remote_addr);
     }
+  }
 
-    /* Sets a default local port, so far nobody sets it */
-    uint16_t local_port;
-    if (facemgr_cfg_get_overlay_local_port(facemgr->cfg,
-            &netdevice, netdevice_type, family, &local_port) < 0) {
-        ERROR("[facemgr_complement_facelet_manual] Error getting local port information from cfg");
-        return -1;
-    }
-    DEBUG(" - local port");
-    facelet_set_local_port(facelet, local_port);
-    return 0;
+  if (!facelet_has_remote_port(facelet)) {
+    uint16_t remote_port;
+    int rc = facemgr_cfg_get_overlay_remote_port(
+        facemgr->cfg, &netdevice, netdevice_type, family, &remote_port);
+    if (rc < 0) {
+      ERROR(
+          "[facemgr_complement_facelet_manual] Error getting remote port "
+          "information from cfg");
+      return -1;
+    }
+    DEBUG(" - remote port");
+    facelet_set_remote_port(facelet, remote_port);
+  }
+
+  /*
+   * Complementing local addr/port XXX this should be done somewhere
+   * else : manual settings have the lowest priority
+   *
+   * Local IP address is specific as it allows to override the source
+   * address just before creating the face... we would need to check
+   * whether this is an address that belong to us... it might be used
+   * to arbitrate amongst several IP addresses instead...
+   */
+  ip_address_t local_addr;
+  if (facemgr_cfg_get_overlay_local_addr(
+          facemgr->cfg, &netdevice, netdevice_type, family, &local_addr) < 0) {
+    ERROR(
+        "[facemgr_complement_facelet_manual] Error getting local addr "
+        "information from cfg");
+    return -1;
+  }
+  if (ip_address_empty(&local_addr)) {
+    ERROR(
+        "[facemgr_complement_facelet_manual] Got empty local addr information "
+        "from cfg");
+  } else {
+    DEBUG(" - local addres");
+    facelet_set_local_addr(facelet, local_addr);
+  }
+
+  /* Sets a default local port, so far nobody sets it */
+  uint16_t local_port;
+  if (facemgr_cfg_get_overlay_local_port(
+          facemgr->cfg, &netdevice, netdevice_type, family, &local_port) < 0) {
+    ERROR(
+        "[facemgr_complement_facelet_manual] Error getting local port "
+        "information from cfg");
+    return -1;
+  }
+  DEBUG(" - local port");
+  facelet_set_local_port(facelet, local_port);
+  return 0;
 }
 
-int
-facemgr_complement_facelet(facemgr_t * facemgr, facelet_t * facelet)
-{
-    int rc;
+int facemgr_complement_facelet(facemgr_t *facemgr, facelet_t *facelet) {
+  int rc;
 
-    DEBUG("[facemgr_complement_facelet]");
-    if (!facelet_has_key(facelet))
-        return -2;
-
-#ifdef WITH_FACEMGR_UTILITY
-    rc = facemgr_complement_facelet_au(facemgr, facelet);
-    if (rc != -2)
-        return rc;
-#endif /* WITH_FACEMGR_UTILITY */
+  DEBUG("[facemgr_complement_facelet]");
+  if (!facelet_has_key(facelet)) return -2;
 
 #if 0
     if (!facelet_has_netdevice_type(facelet)) {
@@ -988,51 +914,51 @@ facemgr_complement_facelet(facemgr_t * facemgr, facelet_t * facelet)
      */
 
 #ifdef __linux__
-    rc = facemgr_complement_facelet_bj(facemgr, facelet);
-    if (rc != -2)
-        return rc;
+  rc = facemgr_complement_facelet_bj(facemgr, facelet);
+  if (rc != -2) return rc;
 #endif /* __linux__ */
 
-    DEBUG("[facemgr_complement_facelet] Complement manual");
+  DEBUG("[facemgr_complement_facelet] Complement manual");
 
-    rc = facemgr_complement_facelet_manual(facemgr, facelet);
-    if (rc != -2)
-        return rc;
+  rc = facemgr_complement_facelet_manual(facemgr, facelet);
+  if (rc != -2) return rc;
 
-    INFO("[facemgr_complement_facelet] No more interfaces to query... incomplete face");
-    return 0;
+  INFO(
+      "[facemgr_complement_facelet] No more interfaces to query... incomplete "
+      "face");
+  return 0;
 }
 
-int facemgr_assign_face_type(facemgr_t * facemgr, facelet_t * facelet)
-{
-    DEBUG("[facemgr_assign_face_type]");
-    /* As key, netdevice and family should always be present */
-    netdevice_t netdevice = NETDEVICE_EMPTY;
-    int rc = facelet_get_netdevice(facelet, &netdevice);
-    if (rc < 0) {
-        ERROR("[facemgr_assign_face_type] Error retrieving netdevice from facelet");
-        return -1;
-    }
-
-    netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
-#ifndef WITH_FACEMGR_UTILITY
-    /*
-     * In addition to netdevice, netdevice_type should be present to correctly
-     * apply rules
-     */
-    rc = facelet_get_netdevice_type(facelet, &netdevice_type);
-    if (rc < 0) {
-        ERROR("[facemgr_assign_face_type] Error retrieving netdevice_type from facelet");
-        return -2;
-    }
-#endif /* WITH_FACEMGR_UTILITY */
-
-    facemgr_face_type_t face_type = FACEMGR_FACE_TYPE_UNDEFINED;
-    if (facemgr_cfg_get_face_type(facemgr->cfg, &netdevice, netdevice_type, &face_type) < 0)
-        return rc;
-    facelet_set_face_type(facelet, face_type);
-    DEBUG("[facemgr_assign_face_type] %s", FACEMGR_FACE_TYPE_STR(face_type));
-    return 0;
+int facemgr_assign_face_type(facemgr_t *facemgr, facelet_t *facelet) {
+  DEBUG("[facemgr_assign_face_type]");
+  /* As key, netdevice and family should always be present */
+  netdevice_t netdevice = NETDEVICE_EMPTY;
+  int rc = facelet_get_netdevice(facelet, &netdevice);
+  if (rc < 0) {
+    ERROR("[facemgr_assign_face_type] Error retrieving netdevice from facelet");
+    return -1;
+  }
+
+  netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
+  /*
+   * In addition to netdevice, netdevice_type should be present to correctly
+   * apply rules
+   */
+  rc = facelet_get_netdevice_type(facelet, &netdevice_type);
+  if (rc < 0) {
+    ERROR(
+        "[facemgr_assign_face_type] Error retrieving netdevice_type from "
+        "facelet");
+    return -2;
+  }
+
+  facemgr_face_type_t face_type = FACEMGR_FACE_TYPE_UNDEFINED;
+  if (facemgr_cfg_get_face_type(facemgr->cfg, &netdevice, netdevice_type,
+                                &face_type) < 0)
+    return rc;
+  facelet_set_face_type(facelet, face_type);
+  DEBUG("[facemgr_assign_face_type] %s", FACEMGR_FACE_TYPE_STR(face_type));
+  return 0;
 }
 
 /*
@@ -1041,102 +967,102 @@ int facemgr_assign_face_type(facemgr_t * facemgr, facelet_t * facelet)
  *
  * We assume the facelet is already present in the cache
  */
-int
-facemgr_process_facelet(facemgr_t * facemgr, facelet_t * facelet)
-{
-    int rc;
-    facelet_error_reason_t reason = FACELET_ERROR_REASON_INTERNAL_ERROR;
-
-    switch(facelet_get_status(facelet)) {
-        case FACELET_STATUS_UNCERTAIN:
-            /*
-             * All new faces are marked UNCERTAIN. We need to check whether we
-             * have sufficient information to check rules, if not proceed,
-             * otherwise possibly mark the face as IGNORED. Otherwise, we verify
-             * the completeness of the information we have, and continue towards
-             * being able to mark the face as CREATE.
-             */
-            rc = facemgr_facelet_satisfy_rules(facemgr, facelet);
-            switch(rc) {
-                case -3:
-                    /* Does not satisfy rules */
-                    DEBUG("[facemgr_process_facelet] Does not satisfy rules");
-                    facelet_set_status(facelet, FACELET_STATUS_IGNORED);
-                    return 0;
-
-                case -2:
-                    DEBUG("[facemgr_process_facelet] Complementing facelet is required");
-                    if (facemgr_complement_facelet(facemgr, facelet) < 0) {
-                        ERROR("[facemgr_process_facelet] Error while attempting to complement face for fields required by face creation");
-                        goto ERR;
-                    }
-                    return 0;
-
-                case 0:
-                    /* Ok pass rules */
-                    break;
-
-                default:
-                    /* -1 - Error */
-                    goto ERR;
-            }
-
-            if (facemgr_assign_face_type(facemgr, facelet) < 0) {
-                ERROR("[facemgr_process_facelet] Could not assign face type");
-                goto ERR;
-            }
-            facelet_set_status(facelet, FACELET_STATUS_INCOMPLETE);
-            /* Continue in case facelet satisfies rules */
-
-        case FACELET_STATUS_INCOMPLETE:
-            if (!facelet_validate_face(facelet)) {
-                /* We need additional information */
-                if (facemgr_complement_facelet(facemgr, facelet) < 0) {
-                    ERROR("[facemgr_process_facelet] Error while attempting to complement face for fields required by face creation");
-                    goto ERR;
-                }
-            }
-            if (!facelet_validate_face(facelet))
-                return 0;
-
-            facelet_set_status(facelet, FACELET_STATUS_CREATE);
-            /* Continue in case we need to proceed to creation */
-
-        case FACELET_STATUS_CREATE:
-            facelet_set_event(facelet, FACELET_EVENT_CREATE);
-            rc = interface_on_event(facemgr->hl, facelet);
-            if (rc < 0) {
-                ERROR("[facemgr_process_facelet] Failed to create face");
-                reason = -rc;
-                goto ERR;
-            }
-
-            /* This works assuming the call to hicn-light is blocking */
-            facelet_set_status(facelet, FACELET_STATUS_CLEAN);
-            break;
+int facemgr_process_facelet(facemgr_t *facemgr, facelet_t *facelet) {
+  int rc;
+  facelet_error_reason_t reason = FACELET_ERROR_REASON_INTERNAL_ERROR;
+
+  switch (facelet_get_status(facelet)) {
+    case FACELET_STATUS_UNCERTAIN:
+      /*
+       * All new faces are marked UNCERTAIN. We need to check whether we
+       * have sufficient information to check rules, if not proceed,
+       * otherwise possibly mark the face as IGNORED. Otherwise, we verify
+       * the completeness of the information we have, and continue towards
+       * being able to mark the face as CREATE.
+       */
+      rc = facemgr_facelet_satisfy_rules(facemgr, facelet);
+      switch (rc) {
+        case -3:
+          /* Does not satisfy rules */
+          DEBUG("[facemgr_process_facelet] Does not satisfy rules");
+          facelet_set_status(facelet, FACELET_STATUS_IGNORED);
+          return 0;
+
+        case -2:
+          DEBUG("[facemgr_process_facelet] Complementing facelet is required");
+          if (facemgr_complement_facelet(facemgr, facelet) < 0) {
+            ERROR(
+                "[facemgr_process_facelet] Error while attempting to "
+                "complement face for fields required by face creation");
+            goto ERR;
+          }
+          return 0;
 
+        case 0:
+          /* Ok pass rules */
+          break;
 
-        case FACELET_STATUS_UPDATE:
-            facelet_set_event(facelet, FACELET_EVENT_UPDATE);
-            rc = interface_on_event(facemgr->hl, facelet);
-            if (rc < 0) {
-                ERROR("[facemgr_process_facelet] Failed to update face");
-                reason = -rc;
-                goto ERR;
-            }
+        default:
+          /* -1 - Error */
+          goto ERR;
+      }
 
-            /* This works assuming the call to hicn-light is blocking */
-            facelet_set_status(facelet, FACELET_STATUS_CLEAN);
-            break;
-
-        case FACELET_STATUS_DELETE:
-            facelet_set_event(facelet, FACELET_EVENT_DELETE);
-            rc = interface_on_event(facemgr->hl, facelet);
-            if (rc < 0) {
-                ERROR("[facemgr_process_facelet] Failed to delete face");
-                reason = -rc;
-                goto ERR;
-            }
+      if (facemgr_assign_face_type(facemgr, facelet) < 0) {
+        ERROR("[facemgr_process_facelet] Could not assign face type");
+        goto ERR;
+      }
+      facelet_set_status(facelet, FACELET_STATUS_INCOMPLETE);
+      /* Continue in case facelet satisfies rules */
+
+    case FACELET_STATUS_INCOMPLETE:
+      if (!facelet_validate_face(facelet)) {
+        /* We need additional information */
+        if (facemgr_complement_facelet(facemgr, facelet) < 0) {
+          ERROR(
+              "[facemgr_process_facelet] Error while attempting to complement "
+              "face for fields required by face creation");
+          goto ERR;
+        }
+      }
+      if (!facelet_validate_face(facelet)) return 0;
+
+      facelet_set_status(facelet, FACELET_STATUS_CREATE);
+      /* Continue in case we need to proceed to creation */
+
+    case FACELET_STATUS_CREATE:
+      facelet_set_event(facelet, FACELET_EVENT_CREATE);
+      rc = interface_on_event(facemgr->hl, facelet);
+      if (rc < 0) {
+        ERROR("[facemgr_process_facelet] Failed to create face");
+        reason = -rc;
+        goto ERR;
+      }
+
+      /* This works assuming the call to hicn-light is blocking */
+      facelet_set_status(facelet, FACELET_STATUS_CLEAN);
+      break;
+
+    case FACELET_STATUS_UPDATE:
+      facelet_set_event(facelet, FACELET_EVENT_UPDATE);
+      rc = interface_on_event(facemgr->hl, facelet);
+      if (rc < 0) {
+        ERROR("[facemgr_process_facelet] Failed to update face");
+        reason = -rc;
+        goto ERR;
+      }
+
+      /* This works assuming the call to hicn-light is blocking */
+      facelet_set_status(facelet, FACELET_STATUS_CLEAN);
+      break;
+
+    case FACELET_STATUS_DELETE:
+      facelet_set_event(facelet, FACELET_EVENT_DELETE);
+      rc = interface_on_event(facemgr->hl, facelet);
+      if (rc < 0) {
+        ERROR("[facemgr_process_facelet] Failed to delete face");
+        reason = -rc;
+        goto ERR;
+      }
 
 #if 0
             if (facelet_get_id(facelet) > 0) {
@@ -1147,111 +1073,102 @@ facemgr_process_facelet(facemgr_t * facemgr, facelet_t * facelet)
                 facelet_free(facelet);
             } else {
 #endif
-                /* This works assuming the call to hicn-light is blocking */
-                DEBUG("[facemgr_process_facelet] Cleaning cached data");
-                facelet_unset_local_addr(facelet);
-                facelet_unset_local_port(facelet);
-                if (facelet_get_id(facelet) == 0) {
-                    facelet_unset_remote_addr(facelet);
-                    facelet_unset_remote_port(facelet);
-                    facelet_clear_routes(facelet);
-                }
-
-                facelet_unset_admin_state(facelet);
-                facelet_unset_state(facelet);
-                facelet_unset_bj_done(facelet);
-#ifdef WITH_FACEMGR_UTILITY
-                facelet_unset_au_done(facelet);
-#endif /* WITH_FACEMGR_UTILITY */
-
-                facelet_set_status(facelet, FACELET_STATUS_DELETED);
+      /* This works assuming the call to hicn-light is blocking */
+      DEBUG("[facemgr_process_facelet] Cleaning cached data");
+      facelet_unset_local_addr(facelet);
+      facelet_unset_local_port(facelet);
+      if (facelet_get_id(facelet) == 0) {
+        facelet_unset_remote_addr(facelet);
+        facelet_unset_remote_port(facelet);
+        facelet_clear_routes(facelet);
+      }
+
+      facelet_unset_admin_state(facelet);
+      facelet_unset_state(facelet);
+      facelet_unset_bj_done(facelet);
+
+      facelet_set_status(facelet, FACELET_STATUS_DELETED);
 #if 0
             }
 #endif
-            break;
-
-        case FACELET_STATUS_CLEAN:
-        case FACELET_STATUS_IGNORED:
-        case FACELET_STATUS_DOWN:
-        case FACELET_STATUS_DELETED:
-            /* Nothing to do */
-            break;
-
-        case FACELET_STATUS_UNDEFINED:
-        case FACELET_STATUS_N:
-            ERROR("[facemgr_process_facelet] Unexpected facelet status");
-            goto ERR;
-    }
+      break;
 
-    facelet_unset_error(facelet);
-    return 0;
+    case FACELET_STATUS_CLEAN:
+    case FACELET_STATUS_IGNORED:
+    case FACELET_STATUS_DOWN:
+    case FACELET_STATUS_DELETED:
+      /* Nothing to do */
+      break;
+
+    case FACELET_STATUS_UNDEFINED:
+    case FACELET_STATUS_N:
+      ERROR("[facemgr_process_facelet] Unexpected facelet status");
+      goto ERR;
+  }
+
+  facelet_unset_error(facelet);
+  return 0;
 
 ERR:
-    facelet_set_error(facelet, reason);
-    return -1;
+  facelet_set_error(facelet, reason);
+  return -1;
 }
 
-int
-facemgr_reattempt_timeout(facemgr_t * facemgr, int fd, void * data)
-{
-    bool has_error = false;
+int facemgr_reattempt_timeout(facemgr_t *facemgr, int fd, void *data) {
+  bool has_error = false;
 
-    assert(data == NULL);
+  assert(data == NULL);
 
-    /* Free all facelets from cache */
-    facelet_t ** facelet_array;
-    int n = facelet_set_get_array(facemgr->facelet_cache, &facelet_array);
-    if (n < 0) {
-        ERROR("[facemgr_reattempt_timeout] Could not retrieve facelets in cache");
+  /* Free all facelets from cache */
+  facelet_t **facelet_array;
+  int n = facelet_set_get_array(facemgr->facelet_cache, &facelet_array);
+  if (n < 0) {
+    ERROR("[facemgr_reattempt_timeout] Could not retrieve facelets in cache");
+    has_error = true;
+  } else {
+    for (unsigned i = 0; i < n; i++) {
+      facelet_t *facelet = facelet_array[i];
+      if (!facelet) continue; /* Should not occur */
+      if (!facelet_get_error(facelet)) continue;
+
+      char buf[MAXSZ_FACELET];
+      facelet_snprintf(buf, MAXSZ_FACELET, facelet);
+      DEBUG("Reattempt to process failed facelet %s", buf);
+      if (facemgr_process_facelet(facemgr, facelet) < 0) {
+        ERROR("[facemgr_reattempt_timeout] Error processing facelet");
         has_error = true;
-    } else {
-        for (unsigned i = 0; i < n; i++) {
-            facelet_t * facelet = facelet_array[i];
-
-            if (!facelet_get_error(facelet))
-                continue;
-
-            char buf[MAXSZ_FACELET];
-            facelet_snprintf(buf, MAXSZ_FACELET, facelet);
-            DEBUG("Reattempt to process failed facelet %s", buf);
-            if (facemgr_process_facelet(facemgr, facelet) < 0) {
-                ERROR("[facemgr_reattempt_timeout] Error processing facelet");
-                has_error = true;
-                continue;
-            }
-            facelet_unset_error(facelet);
-        }
-        free(facelet_array);
+        continue;
+      }
+      facelet_unset_error(facelet);
     }
+    free(facelet_array);
+  }
 
-    if (has_error)
-        return 0;
+  if (has_error) return 0;
 
-    DEBUG("Cancelling timer");
-    if (facemgr->callback(facemgr->callback_owner,
-            FACEMGR_CB_TYPE_UNREGISTER_TIMER, &facemgr->timer_fd) < 0) {
-        ERROR("[facemgr_reattempt_timeout] Error unregistering reattempt timer");
-        return -1;
-    }
-    facemgr->timer_fd = 0;
-    return 0;
+  DEBUG("Cancelling timer");
+  if (facemgr->callback(facemgr->callback_owner,
+                        FACEMGR_CB_TYPE_UNREGISTER_TIMER,
+                        &facemgr->timer_fd) < 0) {
+    ERROR("[facemgr_reattempt_timeout] Error unregistering reattempt timer");
+    return -1;
+  }
+  facemgr->timer_fd = 0;
+  return 0;
 }
 
-int
-facemgr_start_reattempts(facemgr_t * facemgr)
-{
-    if (facemgr->timer_fd > 0)
-        return 0;
-
-    timer_callback_data_t timer_callback = {
-        .delay_ms = DEFAULT_REATTEMPT_DELAY_MS,
-        .owner = facemgr,
-        .callback = (fd_callback_t)facemgr_reattempt_timeout,
-        .data = NULL,
-    };
-    facemgr->timer_fd = facemgr->callback(facemgr->callback_owner,
-            FACEMGR_CB_TYPE_REGISTER_TIMER, &timer_callback);
-    return (facemgr->timer_fd > 0);
+int facemgr_start_reattempts(facemgr_t *facemgr) {
+  if (facemgr->timer_fd > 0) return 0;
+
+  timer_callback_data_t timer_callback = {
+      .delay_ms = DEFAULT_REATTEMPT_DELAY_MS,
+      .owner = facemgr,
+      .callback = (fd_callback_t)facemgr_reattempt_timeout,
+      .data = NULL,
+  };
+  facemgr->timer_fd = facemgr->callback(
+      facemgr->callback_owner, FACEMGR_CB_TYPE_REGISTER_TIMER, &timer_callback);
+  return (facemgr->timer_fd > 0);
 }
 
 /**
@@ -1261,218 +1178,226 @@ facemgr_start_reattempts(facemgr_t * facemgr)
  * \return 0 if everything went correctly, or -1 in case of error.
  *         -2 means we ignored the face purposedly
  */
-int
-facemgr_process_facelet_create(facemgr_t * facemgr, facelet_t * facelet)
-{
-    char facelet_s[MAXSZ_FACELET];
-    facelet_snprintf(facelet_s, MAXSZ_FACELET, facelet); 
-    DEBUG("[facemgr_process_facelet_create] %s", facelet_s);
-    switch(facelet_get_status(facelet)) {
-        case FACELET_STATUS_UNCERTAIN:
-        case FACELET_STATUS_INCOMPLETE:
-        case FACELET_STATUS_CREATE:
-            /* No change */
-            DEBUG("[facemgr_process_facelet_create] UNCHANGED STATUS");
-            break;
-        case FACELET_STATUS_UPDATE:
-        case FACELET_STATUS_DELETE:
-            /*
-             * Unlikely. The face had been created and is planned to
-             * be deleted. Schedule for creation (we should have all
-             * needed information), but make sure to handle errors
-             * correctly if the face is still present.
-             * TODO What if some fields have been updated ?
-             */
-            DEBUG("[facemgr_process_facelet_create] SET STATUS TO CREATE");
-            facelet_set_status(facelet, FACELET_STATUS_CREATE);
-            break;
-        case FACELET_STATUS_CLEAN:
-        case FACELET_STATUS_IGNORED:
-            /*
-             * We should have nothing to do unless some fields have
-             * been updated.
-             */
-            DEBUG("[facemgr_process_facelet_create] NOTHING TO DO");
-            break;
-
-        case FACELET_STATUS_DOWN:
-        case FACELET_STATUS_DELETED:
-            /*
-             * Unless rules have changed, we only need to recover
-             * missing information, and proceed to face creation.
-             * Rule changes should be handled separately.
-             */
-            DEBUG("[facemgr_process_facelet_create] SET STATUS TO INCOMPLETE");
-            facelet_set_status(facelet, FACELET_STATUS_INCOMPLETE);
-            break;
-        case FACELET_STATUS_UNDEFINED:
-        case FACELET_STATUS_N:
-            ERROR("[facemgr_process_facelet_create] Unexpected facelet status");
-            return -1;
-    }
-
-
-    DEBUG("[facemgr_process_facelet_create] Processing facelet");
-    if (facemgr_process_facelet(facemgr, facelet) < 0) {
-        ERROR("[facemgr_process_facelet_create] Error processing facelet");
-        return -1;
-    }
+int facemgr_process_facelet_create(facemgr_t *facemgr, facelet_t *facelet) {
+  char facelet_s[MAXSZ_FACELET];
+  facelet_snprintf(facelet_s, MAXSZ_FACELET, facelet);
+  DEBUG("[facemgr_process_facelet_create] %s", facelet_s);
+  switch (facelet_get_status(facelet)) {
+    case FACELET_STATUS_UNCERTAIN:
+    case FACELET_STATUS_INCOMPLETE:
+    case FACELET_STATUS_CREATE:
+      /* No change */
+      DEBUG("[facemgr_process_facelet_create] UNCHANGED STATUS");
+      break;
+    case FACELET_STATUS_UPDATE:
+    case FACELET_STATUS_DELETE:
+      /*
+       * Unlikely. The face had been created and is planned to
+       * be deleted. Schedule for creation (we should have all
+       * needed information), but make sure to handle errors
+       * correctly if the face is still present.
+       * TODO What if some fields have been updated ?
+       */
+      DEBUG("[facemgr_process_facelet_create] SET STATUS TO CREATE");
+      facelet_set_status(facelet, FACELET_STATUS_CREATE);
+      break;
+    case FACELET_STATUS_CLEAN:
+    case FACELET_STATUS_IGNORED:
+      /*
+       * We should have nothing to do unless some fields have
+       * been updated.
+       */
+      DEBUG("[facemgr_process_facelet_create] NOTHING TO DO");
+      break;
+
+    case FACELET_STATUS_DOWN:
+    case FACELET_STATUS_DELETED:
+      /*
+       * Unless rules have changed, we only need to recover
+       * missing information, and proceed to face creation.
+       * Rule changes should be handled separately.
+       */
+      DEBUG("[facemgr_process_facelet_create] SET STATUS TO INCOMPLETE");
+      facelet_set_status(facelet, FACELET_STATUS_INCOMPLETE);
+      break;
+    case FACELET_STATUS_UNDEFINED:
+    case FACELET_STATUS_N:
+      ERROR("[facemgr_process_facelet_create] Unexpected facelet status");
+      return -1;
+  }
+
+  DEBUG("[facemgr_process_facelet_create] Processing facelet");
+  if (facemgr_process_facelet(facemgr, facelet) < 0) {
+    ERROR("[facemgr_process_facelet_create] Error processing facelet");
+    return -1;
+  }
 
-    return 0;
+  return 0;
 }
 
 /*
  * \return 0 in case of success and no static facelet was added, 1 if a static
  * facelet was added, and -1 in case of error.
  */
-int
-facemgr_consider_static_facelet(facemgr_t * facemgr, facelet_t * facelet)
-{
-    /*
-     * We need to analyze the facelet and eventually:
-     *  - add it in our static list
-     *  - replicate it on multipath interfaces
-     */
-    netdevice_type_t netdevice_type;
-    if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0)
-        return -1;
-
-    if ((netdevice_type == NETDEVICE_TYPE_UNDEFINED) ||
-            (netdevice_type == NETDEVICE_TYPE_LOOPBACK))
-        return 0;
-
-    if ((facelet_get_route_array(facelet, NULL) == 0))
-        return 0;
-
-    /*
-     * How to differenciate facelet created by face manager from user
-     * created ones ? This cannot be a flag in the facelet as it needs
-     * to work across restarts of the face manager...
-     * Also we might have two default routes.
-     *
-     * TODO:
-     * - The static one should not be a duplicate of the one we would
-     * create by default....
-     * - This should anyways be detected...
-     *
-     * One solution would be to install the default ones as static but
-     * this requires to implement a priority scheme between some of the
-     * static routes so that the override mechanism continues to work as
-     * usual.
-     *
-     * Current, we recognize the routes created by default by the face
-     * maanger thanks to the routing prefixes (a single default route).
-     */
-
-    facelet_t * static_facelet = facelet_dup(facelet);
-    facelet_set_event(static_facelet, FACELET_EVENT_CREATE);
-    facelet_unset_netdevice(static_facelet);
-    facelet_unset_netdevice_type(static_facelet);
-    facelet_unset_local_addr(static_facelet);
-    facelet_unset_local_port(static_facelet);
-
-    facelet_t * facelet_found = NULL;
-    if (facelet_array_get(facemgr->static_facelets, static_facelet, &facelet_found) < 0) {
-        ERROR("[facemgr_consider_static_facelet] Error checking whether static facelet already exists or not");
-        return -1;
-    }
+int facemgr_consider_static_facelet(facemgr_t *facemgr, facelet_t *facelet) {
+  /*
+   * We need to analyze the facelet and eventually:
+   *  - add it in our static list
+   *  - replicate it on multipath interfaces
+   */
+  netdevice_type_t netdevice_type;
+  if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) return -1;
+
+  if ((netdevice_type == NETDEVICE_TYPE_UNDEFINED) ||
+      (netdevice_type == NETDEVICE_TYPE_LOOPBACK))
+    return 0;
 
-    /* Skip addition if facelet exists */
-    if (facelet_found)
-        return 0;
+  if ((facelet_get_route_array(facelet, NULL) == 0)) return 0;
+
+  /*
+   * How to differenciate facelet created by face manager from user
+   * created ones ? This cannot be a flag in the facelet as it needs
+   * to work across restarts of the face manager...
+   * Also we might have two default routes.
+   *
+   * TODO:
+   * - The static one should not be a duplicate of the one we would
+   * create by default....
+   * - This should anyways be detected...
+   *
+   * One solution would be to install the default ones as static but
+   * this requires to implement a priority scheme between some of the
+   * static routes so that the override mechanism continues to work as
+   * usual.
+   *
+   * Current, we recognize the routes created by default by the face
+   * maanger thanks to the routing prefixes (a single default route).
+   */
+
+  facelet_t *static_facelet = facelet_dup(facelet);
+  facelet_set_event(static_facelet, FACELET_EVENT_CREATE);
+  facelet_unset_netdevice(static_facelet);
+  facelet_unset_netdevice_type(static_facelet);
+  facelet_unset_local_addr(static_facelet);
+  facelet_unset_local_port(static_facelet);
+
+  facelet_t *facelet_found = NULL;
+  if (facelet_array_get(facemgr->static_facelets, static_facelet,
+                        &facelet_found) < 0) {
+    ERROR(
+        "[facemgr_consider_static_facelet] Error checking whether static "
+        "facelet already exists or not");
+    return -1;
+  }
 
-    facemgr->cur_static_id++;
+  /* Skip addition if facelet exists */
+  if (facelet_found) return 0;
 
-    facelet_set_id(static_facelet, facemgr->cur_static_id);
-    facelet_set_id(facelet, facemgr->cur_static_id);
+  facemgr->cur_static_id++;
 
-    if (facelet_array_add(facemgr->static_facelets, static_facelet) < 0) {
-        ERROR("[facemgr_consider_static_facelet] Could not add facelet to static array");
-        facelet_free(static_facelet);
-        return -1;
-    }
+  facelet_set_id(static_facelet, facemgr->cur_static_id);
+  facelet_set_id(facelet, facemgr->cur_static_id);
 
-    char facelet_s[MAXSZ_FACELET];
-    int rc = facelet_snprintf(facelet_s, MAXSZ_FACELET, static_facelet);
-    if (rc >= MAXSZ_FACELET)
-        ERROR("[facemgr_consider_static_facelet] Unexpected truncation of facelet string");
-    if (rc < 0)
-        ERROR("[facemgr_consider_static_facelet] Error during facelet string output");
-    DEBUG("[facemgr_consider_static_facelet] Successfully added facelet to static array %s", facelet_s);
+  if (facelet_array_add(facemgr->static_facelets, static_facelet) < 0) {
+    ERROR(
+        "[facemgr_consider_static_facelet] Could not add facelet to static "
+        "array");
+    facelet_free(static_facelet);
+    return -1;
+  }
+
+  char facelet_s[MAXSZ_FACELET];
+  int rc = facelet_snprintf(facelet_s, MAXSZ_FACELET, static_facelet);
+  if (rc >= MAXSZ_FACELET)
+    ERROR(
+        "[facemgr_consider_static_facelet] Unexpected truncation of facelet "
+        "string");
+  if (rc < 0)
+    ERROR(
+        "[facemgr_consider_static_facelet] Error during facelet string output");
+  DEBUG(
+      "[facemgr_consider_static_facelet] Successfully added facelet to static "
+      "array %s",
+      facelet_s);
 
 #if 1
-    /* Force application of the static face on all existing interfaces */
-    facelet_t ** facelet_array;
-    int n = facelet_set_get_array(facemgr->facelet_cache, &facelet_array);
-    if (n >= 0) {
-        for (unsigned i = 0; i < n; i++) {
-            facelet_t * cached_facelet = facelet_array[i];
-
-            netdevice_type_t netdevice_type;
-            if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) {
-                ERROR("[facemgr_consider_static_facelet] Error retrieving netdevice type from cached facelet");
-                continue;
-            }
-            if ((netdevice_type == NETDEVICE_TYPE_LOOPBACK) || (netdevice_type == NETDEVICE_TYPE_UNDEFINED))
-                continue;
-
-            facelet_t * new_facelet = facelet_dup(cached_facelet);
-            facelet_unset_remote_addr(new_facelet);
-            facelet_unset_remote_port(new_facelet);
-            facelet_unset_admin_state(new_facelet);
-            facelet_unset_state(new_facelet);
-            facelet_unset_bj_done(new_facelet);
-            facelet_clear_routes(new_facelet);
-#ifdef WITH_FACEMGR_UTILITY
-            facelet_unset_au_done(new_facelet);
-#endif /* WITH_FACEMGR_UTILITY */
-
-            /* We try to apply static_facelet over facelet */
-            if (!facelet_match(new_facelet, static_facelet)) {
-                facelet_free(new_facelet);
-                continue;
-            }
-
-            if (facelet_merge(new_facelet, static_facelet) < 0) {
-                ERROR("[facemgr_consider_static_facelet] Error merging facelets");
-                facelet_free(new_facelet);
-                continue;
-            }
-
-            /*
-             * We need to set the id before checking for existence as tuple used
-             * is (id, netdevice, family)
-             */
-            facelet_set_id(new_facelet, facemgr->cur_static_id);
-
-            facelet_found = NULL;
-            if (facelet_set_get(facemgr->facelet_cache, new_facelet, &facelet_found) < 0) {
-                ERROR("[facemgr_consider_static_facelet] Error checking whether new static facelet already exists or not");
-                continue;
-            }
-
-
-            /* Skip addition if facelet exists */
-            if (facelet_found) {
-                facelet_free(new_facelet);
-                continue;
-            }
-
-            facelet_set_attr_clean(new_facelet);
-            facelet_set_status(facelet, FACELET_STATUS_UNDEFINED);
-
-            if (facemgr_on_event(facemgr, new_facelet) < 0) {
-                ERROR("[facemgr_process_facelet_create_no_family] Error creating static facelet for existing face");
-                continue;
-            }
-
-            INFO("Successfully created static facelet for existing face");
-        }
-        free(facelet_array);
+  /* Force application of the static face on all existing interfaces */
+  facelet_t **facelet_array;
+  int n = facelet_set_get_array(facemgr->facelet_cache, &facelet_array);
+  if (n >= 0) {
+    for (unsigned i = 0; i < n; i++) {
+      facelet_t *cached_facelet = facelet_array[i];
+      if (!cached_facelet) continue; /* Should not occur */
+
+      netdevice_type_t netdevice_type;
+      if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) {
+        ERROR(
+            "[facemgr_consider_static_facelet] Error retrieving netdevice type "
+            "from cached facelet");
+        continue;
+      }
+      if ((netdevice_type == NETDEVICE_TYPE_LOOPBACK) ||
+          (netdevice_type == NETDEVICE_TYPE_UNDEFINED))
+        continue;
+
+      facelet_t *new_facelet = facelet_dup(cached_facelet);
+      facelet_unset_remote_addr(new_facelet);
+      facelet_unset_remote_port(new_facelet);
+      facelet_unset_admin_state(new_facelet);
+      facelet_unset_state(new_facelet);
+      facelet_unset_bj_done(new_facelet);
+      facelet_clear_routes(new_facelet);
+
+      /* We try to apply static_facelet over facelet */
+      if (!facelet_match(new_facelet, static_facelet)) {
+        facelet_free(new_facelet);
+        continue;
+      }
+
+      if (facelet_merge(new_facelet, static_facelet) < 0) {
+        ERROR("[facemgr_consider_static_facelet] Error merging facelets");
+        facelet_free(new_facelet);
+        continue;
+      }
+
+      /*
+       * We need to set the id before checking for existence as tuple used
+       * is (id, netdevice, family)
+       */
+      facelet_set_id(new_facelet, facemgr->cur_static_id);
+
+      facelet_found = NULL;
+      if (facelet_set_get(facemgr->facelet_cache, new_facelet, &facelet_found) <
+          0) {
+        ERROR(
+            "[facemgr_consider_static_facelet] Error checking whether new "
+            "static facelet already exists or not");
+        continue;
+      }
+
+      /* Skip addition if facelet exists */
+      if (facelet_found) {
+        facelet_free(new_facelet);
+        continue;
+      }
+
+      facelet_set_attr_clean(new_facelet);
+      facelet_set_status(facelet, FACELET_STATUS_UNDEFINED);
+
+      if (facemgr_on_event(facemgr, new_facelet) < 0) {
+        ERROR(
+            "[facemgr_process_facelet_create_no_family] Error creating static "
+            "facelet for existing face");
+        continue;
+      }
+
+      INFO("Successfully created static facelet for existing face");
     }
+    free(facelet_array);
+  }
 #endif
 
-    return 1;
+  return 1;
 }
 
 /**
@@ -1482,93 +1407,96 @@ facemgr_consider_static_facelet(facemgr_t * facemgr, facelet_t * facelet)
  * \return 0 if everything went correctly, or -1 in case of error.
  *         -2 means we ignored the face purposedly
  */
-int
-facemgr_process_facelet_get(facemgr_t * facemgr, facelet_t * facelet)
-{
-    assert(facelet);
+int facemgr_process_facelet_get(facemgr_t *facemgr, facelet_t *facelet) {
+  assert(facelet);
 
-    if (!facelet_has_netdevice(facelet))
-        return -2;
+  if (!facelet_has_netdevice(facelet)) return -2;
 
-    netdevice_t netdevice;
-    if (facelet_get_netdevice(facelet, &netdevice) < 0)
-        return -1;
-    if (!IS_VALID_NETDEVICE(netdevice))
-        return -2;
+  netdevice_t netdevice;
+  if (facelet_get_netdevice(facelet, &netdevice) < 0) return -1;
+  if (!IS_VALID_NETDEVICE(netdevice)) return -2;
 
-    facelet_set_status(facelet, FACELET_STATUS_CLEAN);
+  facelet_set_status(facelet, FACELET_STATUS_CLEAN);
 
-    /* Skip if face exists */
-    int n = facelet_cache_lookup(facemgr->facelet_cache, facelet, NULL);
-    if (n < 0) {
-        ERROR("[facemgr_process_facelet_get] Error during cache lookup");
-        return -1;
-    }
-    assert (n <= 1);
-    if (n > 0)
-        return 0;
-
-    /* Process untagged faces */
-    netdevice_type_t netdevice_type;
+  /* Skip if face exists */
+  int n = facelet_cache_lookup(facemgr->facelet_cache, facelet, NULL);
+  if (n < 0) {
+    ERROR("[facemgr_process_facelet_get] Error during cache lookup");
+    return -1;
+  }
+  assert(n <= 1);
+  if (n > 0) return 0;
+
+  /* Process untagged faces */
+  netdevice_type_t netdevice_type;
+  if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) {
+    facelet_set_netdevice_type(
+        facelet, facemgr_get_netdevice_type(facemgr, netdevice.name));
     if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) {
-        facelet_set_netdevice_type(facelet, facemgr_get_netdevice_type(facemgr, netdevice.name));
-        if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) {
-            /* Inspect local address */
-            int family;
-            ip_address_t local;
-            if (facelet_get_family(facelet, &family) < 0) {
-                ERROR("[facemgr_process_facelet_get] Error getting facelet family");
-                return -1;
-            }
-            if (facelet_get_local_addr(facelet, &local) < 0) {
-                ERROR("[facemgr_process_facelet_get] Error getting facelet local address");
-                return -1;
-            }
-            switch(family) {
-                case AF_INET:
-                    if (ip_address_cmp(&local, &IPV4_LOOPBACK, family) == 0) {
-                        facelet_set_netdevice_type(facelet, NETDEVICE_TYPE_LOOPBACK);
-                    } else {
-                        return -2;
-                    }
-                    break;
-                case AF_INET6:
-                    if (ip_address_cmp(&local, &IPV6_LOOPBACK, family) == 0) {
-                        facelet_set_netdevice_type(facelet, NETDEVICE_TYPE_LOOPBACK);
-                    } else {
-                        return -2;
-                    }
-                    break;
-                default:
-                    return -2;
-            }
-        }
-
-        if ((netdevice_type == NETDEVICE_TYPE_UNDEFINED) || (netdevice_type == NETDEVICE_TYPE_LOOPBACK))
-            return 0;
-
-        if (facemgr_process_facelet(facemgr, facelet) < 0) {
-            ERROR("[facemgr_process_facelet_get] Error processing facelet");
-            return -1;
-        }
-    }
-
-    if ((netdevice_type == NETDEVICE_TYPE_UNDEFINED) || (netdevice_type == NETDEVICE_TYPE_LOOPBACK))
-        return 0;
-
-    if (facelet_set_add(facemgr->facelet_cache, facelet) < 0) {
-        ERROR("[facemgr_process_facelet_get] Error adding received facelet to cache");
+      /* Inspect local address */
+      int family;
+      ip_address_t local;
+      if (facelet_get_family(facelet, &family) < 0) {
+        ERROR("[facemgr_process_facelet_get] Error getting facelet family");
         return -1;
+      }
+      if (facelet_get_local_addr(facelet, &local) < 0) {
+        ERROR(
+            "[facemgr_process_facelet_get] Error getting facelet local "
+            "address");
+        return -1;
+      }
+      switch (family) {
+        case AF_INET:
+          if (ip_address_cmp(&local, &IPV4_LOOPBACK, family) == 0) {
+            facelet_set_netdevice_type(facelet, NETDEVICE_TYPE_LOOPBACK);
+          } else {
+            return -2;
+          }
+          break;
+        case AF_INET6:
+          if (ip_address_cmp(&local, &IPV6_LOOPBACK, family) == 0) {
+            facelet_set_netdevice_type(facelet, NETDEVICE_TYPE_LOOPBACK);
+          } else {
+            return -2;
+          }
+          break;
+        default:
+          return -2;
+      }
     }
 
-    n = facemgr_consider_static_facelet(facemgr, facelet);
-    if (n < 0) {
-        ERROR("[facemgr_process_facelet_get] Could not add facelet to static array");
-        return -1;
+    if ((netdevice_type == NETDEVICE_TYPE_UNDEFINED) ||
+        (netdevice_type == NETDEVICE_TYPE_LOOPBACK))
+      return -2;
+
+    if (facemgr_process_facelet(facemgr, facelet) < 0) {
+      ERROR("[facemgr_process_facelet_get] Error processing facelet");
+      return -1;
     }
+  }
 
+  if ((netdevice_type == NETDEVICE_TYPE_UNDEFINED) ||
+      (netdevice_type == NETDEVICE_TYPE_LOOPBACK))
+    return -2;
 
-    return 0;
+  if (facelet_set_add(facemgr->facelet_cache, facelet) < 0) {
+    ERROR(
+        "[facemgr_process_facelet_get] Error adding received facelet to cache");
+    return -1;
+  }
+
+  /*
+   * From there, don't raise errors otherwise the facelet just added to cache
+   * will be freed
+   */
+  n = facemgr_consider_static_facelet(facemgr, facelet);
+  if (n < 0) {
+    ERROR(
+        "[facemgr_process_facelet_get] Could not add facelet to static array");
+  }
+
+  return 0;
 }
 
 /**
@@ -1578,45 +1506,43 @@ facemgr_process_facelet_get(facemgr_t * facemgr, facelet_t * facelet)
  * \return 0 if everything went correctly, or -1 in case of error.
  *         -2 means we ignored the face purposedly
  */
-int
-facemgr_process_facelet_update(facemgr_t * facemgr, facelet_t * facelet)
-{
-    char facelet_s[MAXSZ_FACELET];
-    facelet_snprintf(facelet_s, MAXSZ_FACELET, facelet);
-    DEBUG("[facemgr_process_facelet_update] %s", facelet_s);
-    switch(facelet_get_status(facelet)) {
-        case FACELET_STATUS_UNCERTAIN:
-        case FACELET_STATUS_INCOMPLETE:
-        case FACELET_STATUS_CREATE:
-        case FACELET_STATUS_UPDATE:
-            /* No change */
-            DEBUG("[facemgr_process_facelet_update] UNCHANGED STATUS");
-            break;
-        case FACELET_STATUS_CLEAN:
-            DEBUG("[facemgr_process_facelet_update] SET STATUS TO UPDATE");
-            facelet_set_status(facelet, FACELET_STATUS_UPDATE);
-            break;
-        case FACELET_STATUS_DOWN:
-        case FACELET_STATUS_DELETE:
-        case FACELET_STATUS_DELETED:
-        case FACELET_STATUS_IGNORED:
-            /* Reconsider face creation in light of new information */
-            DEBUG("[facemgr_process_facelet_update] SET STATUS TO UNCERTAIN");
-            facelet_set_status(facelet, FACELET_STATUS_UNCERTAIN);
-            break;
-        case FACELET_STATUS_UNDEFINED:
-        case FACELET_STATUS_N:
-            ERROR("[facemgr_process_facelet_update] Unexpected facelet status");
-            return -1;
-    }
-
-    DEBUG("[facemgr_process_facelet_update] Processing facelet");
-    if (facemgr_process_facelet(facemgr, facelet) < 0) {
-        ERROR("[facemgr_process_facelet_update] Error processing facelet");
-        return -1;
-    }
+int facemgr_process_facelet_update(facemgr_t *facemgr, facelet_t *facelet) {
+  char facelet_s[MAXSZ_FACELET];
+  facelet_snprintf(facelet_s, MAXSZ_FACELET, facelet);
+  DEBUG("[facemgr_process_facelet_update] %s", facelet_s);
+  switch (facelet_get_status(facelet)) {
+    case FACELET_STATUS_UNCERTAIN:
+    case FACELET_STATUS_INCOMPLETE:
+    case FACELET_STATUS_CREATE:
+    case FACELET_STATUS_UPDATE:
+      /* No change */
+      DEBUG("[facemgr_process_facelet_update] UNCHANGED STATUS");
+      break;
+    case FACELET_STATUS_CLEAN:
+      DEBUG("[facemgr_process_facelet_update] SET STATUS TO UPDATE");
+      facelet_set_status(facelet, FACELET_STATUS_UPDATE);
+      break;
+    case FACELET_STATUS_DOWN:
+    case FACELET_STATUS_DELETE:
+    case FACELET_STATUS_DELETED:
+    case FACELET_STATUS_IGNORED:
+      /* Reconsider face creation in light of new information */
+      DEBUG("[facemgr_process_facelet_update] SET STATUS TO UNCERTAIN");
+      facelet_set_status(facelet, FACELET_STATUS_UNCERTAIN);
+      break;
+    case FACELET_STATUS_UNDEFINED:
+    case FACELET_STATUS_N:
+      ERROR("[facemgr_process_facelet_update] Unexpected facelet status");
+      return -1;
+  }
+
+  DEBUG("[facemgr_process_facelet_update] Processing facelet");
+  if (facemgr_process_facelet(facemgr, facelet) < 0) {
+    ERROR("[facemgr_process_facelet_update] Error processing facelet");
+    return -1;
+  }
 
-    return 0;
+  return 0;
 }
 
 /**
@@ -1626,15 +1552,13 @@ facemgr_process_facelet_update(facemgr_t * facemgr, facelet_t * facelet)
  * \return 0 if everything went correctly, or -1 in case of error.
  *         -2 means we ignored the face purposedly
  */
-int
-facemgr_process_facelet_delete(facemgr_t * facemgr, facelet_t * facelet)
-{
-    switch(facelet_get_status(facelet)) {
-        case FACELET_STATUS_UNCERTAIN:
-        case FACELET_STATUS_INCOMPLETE:
-        case FACELET_STATUS_IGNORED:
-        case FACELET_STATUS_DOWN:
-        case FACELET_STATUS_CREATE:
+int facemgr_process_facelet_delete(facemgr_t *facemgr, facelet_t *facelet) {
+  switch (facelet_get_status(facelet)) {
+    case FACELET_STATUS_UNCERTAIN:
+    case FACELET_STATUS_INCOMPLETE:
+    case FACELET_STATUS_IGNORED:
+    case FACELET_STATUS_DOWN:
+    case FACELET_STATUS_CREATE:
 #if 0
             /* Facelets created from static get deleted */
             if (facelet_get_id(facelet) > 0) {
@@ -1645,142 +1569,159 @@ facemgr_process_facelet_delete(facemgr_t * facemgr, facelet_t * facelet)
                 facelet_free(facelet);
             } else {
 #endif
-                /* Face has not been created */
-                DEBUG("[facemgr_process_facelet] Cleaning cached data");
-                facelet_unset_local_addr(facelet);
-                facelet_unset_local_port(facelet);
-                if (facelet_get_id(facelet) == 0) {
-                    facelet_unset_remote_addr(facelet);
-                    facelet_unset_remote_port(facelet);
-                    facelet_clear_routes(facelet);
-                }
-                facelet_unset_admin_state(facelet);
-                facelet_unset_state(facelet);
-                facelet_unset_bj_done(facelet);
-#ifdef WITH_FACEMGR_UTILITY
-                facelet_unset_au_done(facelet);
-#endif /* WITH_FACEMGR_UTILITY */
-                facelet_unset_error(facelet);
-                facelet_set_status(facelet, FACELET_STATUS_DELETED);
+      /* Face has not been created */
+      DEBUG("[facemgr_process_facelet] Cleaning cached data");
+      facelet_unset_local_addr(facelet);
+      facelet_unset_local_port(facelet);
+      if (facelet_get_id(facelet) == 0) {
+        facelet_unset_remote_addr(facelet);
+        facelet_unset_remote_port(facelet);
+        facelet_clear_routes(facelet);
+      }
+      facelet_unset_admin_state(facelet);
+      facelet_unset_state(facelet);
+      facelet_unset_bj_done(facelet);
+      facelet_unset_error(facelet);
+      facelet_set_status(facelet, FACELET_STATUS_DELETED);
 #if 0
             }
 #endif
-            break;
-
-        case FACELET_STATUS_UPDATE:
-        case FACELET_STATUS_CLEAN:
-            facelet_set_status(facelet, FACELET_STATUS_DELETE);
-            if (facemgr_process_facelet(facemgr, facelet) < 0) {
-                ERROR("[facemgr_process_facelet_delete] Error processing facelet");
-                return -1;
-            }
-            break;
+      break;
 
-        case FACELET_STATUS_DELETE:
-        case FACELET_STATUS_DELETED:
-            /* Nothing to do */
-            break;
+    case FACELET_STATUS_UPDATE:
+    case FACELET_STATUS_CLEAN:
+      facelet_set_status(facelet, FACELET_STATUS_DELETE);
+      if (facemgr_process_facelet(facemgr, facelet) < 0) {
+        ERROR("[facemgr_process_facelet_delete] Error processing facelet");
+        return -1;
+      }
+      break;
 
-        case FACELET_STATUS_UNDEFINED:
-        case FACELET_STATUS_N:
-            ERROR("[facemgr_process_facelet_delete] Unexpected facelet status");
-            return -1;
-    }
+    case FACELET_STATUS_DELETE:
+    case FACELET_STATUS_DELETED:
+      /* Nothing to do */
+      break;
 
-    return 0;
-}
+    case FACELET_STATUS_UNDEFINED:
+    case FACELET_STATUS_N:
+      ERROR("[facemgr_process_facelet_delete] Unexpected facelet status");
+      return -1;
+  }
 
-int
-facemgr_process_facelet_create_no_family(facemgr_t * facemgr, facelet_t * facelet)
-{
+  return 0;
+}
 
+int facemgr_process_facelet_create_no_family(facemgr_t *facemgr,
+                                             facelet_t *facelet) {
 #ifdef WITH_DEFAULT_PRIORITIES
-    /* Assign default priority based on face type */
-    netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
-    if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) {
-        ERROR("[facemgr_process_facelet_create_no_family] Error getting netdevice_type: no default priority set.");
-        goto ERR_PRIORITY;
-    }
-    if (facelet_set_priority(facelet, facemgr->default_priority[netdevice_type]) < 0) {
-        ERROR("[facemgr_process_facelet_create_no_family] Error setting default priority");
-    }
+  /* Assign default priority based on face type */
+  netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
+  if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) {
+    ERROR(
+        "[facemgr_process_facelet_create_no_family] Error getting "
+        "netdevice_type: no default priority set.");
+    goto ERR_PRIORITY;
+  }
+  if (facelet_set_priority(facelet, facemgr->default_priority[netdevice_type]) <
+      0) {
+    ERROR(
+        "[facemgr_process_facelet_create_no_family] Error setting default "
+        "priority");
+  }
 ERR_PRIORITY:
 #endif /* WITH_DEFAULT_PRIORITIES */
 
-    DEBUG("[facemgr_process_facelet_create_no_family] Default v4");
-    /* Create default v4 and v6 facelets */
-    facelet_t * facelet_v4 = facelet_dup(facelet);
-    if (!facelet_v4) {
-        ERROR("[facemgr_process_facelet_create_no_family] Error allocating default IPv4 face");
-    } else {
-        facelet_set_family(facelet_v4, AF_INET);
-        facelet_set_attr_clean(facelet_v4);
-        if (facemgr_on_event(facemgr, facelet_v4) < 0) {
-            ERROR("[facemgr_process_facelet_create_no_family] Error creating default IPv4 face");
-            //facelet_free(facelet_v4);
-        }
-    }
-
-    DEBUG("[facemgr_process_facelet_create_no_family] Default v6");
-    facelet_t * facelet_v6 = facelet_dup(facelet);
-    if (!facelet_v6) {
-        ERROR("[facemgr_process_facelet_create_no_family] Error allocating default IPv6 face");
-    } else {
-        facelet_set_family(facelet_v6, AF_INET6);
-        facelet_set_attr_clean(facelet_v6);
-        if (facemgr_on_event(facemgr, facelet_v6) < 0) {
-            ERROR("[facemgr_process_facelet_create_no_family] Error creating default IPv6 face");
-            //facelet_free(facelet_v6);
-        }
+  DEBUG("[facemgr_process_facelet_create_no_family] Default v4");
+  /* Create default v4 and v6 facelets */
+  facelet_t *facelet_v4 = facelet_dup(facelet);
+  if (!facelet_v4) {
+    ERROR(
+        "[facemgr_process_facelet_create_no_family] Error allocating default "
+        "IPv4 face");
+  } else {
+    facelet_set_family(facelet_v4, AF_INET);
+    facelet_set_attr_clean(facelet_v4);
+    if (facemgr_on_event(facemgr, facelet_v4) < 0) {
+      ERROR(
+          "[facemgr_process_facelet_create_no_family] Error creating default "
+          "IPv4 face");
+      // facelet_free(facelet_v4);
+    }
+  }
+
+  DEBUG("[facemgr_process_facelet_create_no_family] Default v6");
+  facelet_t *facelet_v6 = facelet_dup(facelet);
+  if (!facelet_v6) {
+    ERROR(
+        "[facemgr_process_facelet_create_no_family] Error allocating default "
+        "IPv6 face");
+  } else {
+    facelet_set_family(facelet_v6, AF_INET6);
+    facelet_set_attr_clean(facelet_v6);
+    if (facemgr_on_event(facemgr, facelet_v6) < 0) {
+      ERROR(
+          "[facemgr_process_facelet_create_no_family] Error creating default "
+          "IPv6 face");
+      // facelet_free(facelet_v6);
+    }
+  }
+
+  /* Create additional connections
+   *
+   * This is where we spawn multiple facelets based on the
+   * configured "static routes" in addition to the default
+   * routes managed by the face manager.
+   */
+  DEBUG("[facemgr_process_facelet_create_no_family] Loop static");
+  for (unsigned i = 0; i < facelet_array_len(facemgr->static_facelets); i++) {
+    facelet_t *static_facelet;
+    if (facelet_array_get_index(facemgr->static_facelets, i, &static_facelet) <
+        0) {
+      ERROR(
+          "[facemgr_process_facelet_create_no_family] Error getting static "
+          "facelet");
+      continue;
     }
 
-    /* Create additional connections
-     *
-     * This is where we spawn multiple facelets based on the
-     * configured "static routes" in addition to the default
-     * routes managed by the face manager.
+    /*
+     * We don't enforce any present or absent fields. A match
+     * operation will be performed deciding whether to create
+     * the facelet (if it bring additional information to the
+     * ingress one) or not.
      */
-    DEBUG("[facemgr_process_facelet_create_no_family] Loop static");
-    for (unsigned i = 0; i < facelet_array_len(facemgr->static_facelets); i++) {
-        facelet_t * static_facelet;
-        if (facelet_array_get_index(facemgr->static_facelets, i, &static_facelet) < 0) {
-            ERROR("[facemgr_process_facelet_create_no_family] Error getting static facelet");
-            continue;
-        }
-
-        /*
-         * We don't enforce any present or absent fields. A match
-         * operation will be performed deciding whether to create
-         * the facelet (if it bring additional information to the
-         * ingress one) or not.
-         */
-        /* We try to apply static_facelet over facelet */
-        if (!facelet_match(facelet, static_facelet)) {
-            continue;
-        }
-
-        facelet_t * facelet_new = facelet_dup(facelet);
-        if (!facelet_new) {
-            ERROR("[facemgr_process_facelet_create_no_family] Error allocating static facelet");
-            continue;
-        } else {
-            if (facelet_merge(facelet_new, static_facelet) < 0) {
-                ERROR("[facemgr_process_facelet_create_no_family] Error merging facelets");
-                facelet_free(facelet_new);
-                continue;
-            }
-            facelet_set_id(facelet_new, facelet_get_id(static_facelet));
-            facelet_set_attr_clean(facelet_new);
-            facelet_set_status(facelet, FACELET_STATUS_UNDEFINED);
-
-            if (facemgr_on_event(facemgr, facelet_new) < 0) {
-                ERROR("[facemgr_process_facelet_create_no_family] Error creating default IPv6 face");
-                //facelet_free(facelet_new);
-            }
-        }
+    /* We try to apply static_facelet over facelet */
+    if (!facelet_match(facelet, static_facelet)) {
+      continue;
     }
 
-    return 0;
+    facelet_t *facelet_new = facelet_dup(facelet);
+    if (!facelet_new) {
+      ERROR(
+          "[facemgr_process_facelet_create_no_family] Error allocating static "
+          "facelet");
+      continue;
+    } else {
+      if (facelet_merge(facelet_new, static_facelet) < 0) {
+        ERROR(
+            "[facemgr_process_facelet_create_no_family] Error merging "
+            "facelets");
+        facelet_free(facelet_new);
+        continue;
+      }
+      facelet_set_id(facelet_new, facelet_get_id(static_facelet));
+      facelet_set_attr_clean(facelet_new);
+      facelet_set_status(facelet, FACELET_STATUS_UNDEFINED);
+
+      if (facemgr_on_event(facemgr, facelet_new) < 0) {
+        ERROR(
+            "[facemgr_process_facelet_create_no_family] Error creating default "
+            "IPv6 face");
+        // facelet_free(facelet_new);
+      }
+    }
+  }
+
+  return 0;
 }
 
 /**
@@ -1790,30 +1731,29 @@ ERR_PRIORITY:
  *  - Any event or timeout due to an interface triggers either a local cache
  *  update, as well a face operations needed to resync the state.
  */
-int
-facemgr_on_event(facemgr_t * facemgr, facelet_t * facelet_in)
-{
-    bool remove_facelet = true;
+int facemgr_on_event(facemgr_t *facemgr, facelet_t *facelet_in) {
+  bool remove_facelet = true;
 #if WITH_DUMP
-    bool dump = true;
+  bool dump = true;
 #endif /* WITH_DUMP */
-    int ret = 0;
-    int rc;
-    assert(facelet_in);
-
-    /* Update Netdevice type */
-    if ((facelet_get_event(facelet_in) != FACELET_EVENT_GET) &&
-            facelet_has_netdevice(facelet_in) &&
-            (!facelet_has_netdevice_type(facelet_in))) {
-        netdevice_t netdevice = NETDEVICE_EMPTY;
+  int ret = 0;
+  int rc;
+  assert(facelet_in);
+
+  /* Update Netdevice type */
+  if ((facelet_get_event(facelet_in) != FACELET_EVENT_GET) &&
+      facelet_has_netdevice(facelet_in) &&
+      (!facelet_has_netdevice_type(facelet_in))) {
+    netdevice_t netdevice = NETDEVICE_EMPTY;
 
-        rc = facelet_get_netdevice(facelet_in, &netdevice);
-        if (rc < 0) {
-            ERROR("[facemgr_on_event] Error retrieving netdevice from facelet");
-            return -1;
-        }
-        facelet_set_netdevice_type(facelet_in, facemgr_get_netdevice_type(facemgr, netdevice.name));
+    rc = facelet_get_netdevice(facelet_in, &netdevice);
+    if (rc < 0) {
+      ERROR("[facemgr_on_event] Error retrieving netdevice from facelet");
+      return -1;
     }
+    facelet_set_netdevice_type(
+        facelet_in, facemgr_get_netdevice_type(facemgr, netdevice.name));
+  }
 
 #if 0
     netdevice_type_t netdevice_type;
@@ -1826,656 +1766,660 @@ facemgr_on_event(facemgr_t * facemgr, facelet_t * facelet_in)
         return 0;
 #endif
 
-    char facelet_s[MAXSZ_FACELET];
-    facelet_snprintf(facelet_s, MAXSZ_FACELET, facelet_in);
+  char facelet_s[MAXSZ_FACELET];
+  facelet_snprintf(facelet_s, MAXSZ_FACELET, facelet_in);
 
-    facelet_t ** cached_facelets = NULL;
-    assert(facelet_in);
+  facelet_t **cached_facelets = NULL;
+  assert(facelet_in);
 
-    if (facelet_get_status(facelet_in) == FACELET_STATUS_UNDEFINED) {
-        facelet_set_status(facelet_in, FACELET_STATUS_UNCERTAIN);
-    }
+  if (facelet_get_status(facelet_in) == FACELET_STATUS_UNDEFINED) {
+    facelet_set_status(facelet_in, FACELET_STATUS_UNCERTAIN);
+  }
 
-    int n = facelet_cache_lookup(facemgr->facelet_cache, facelet_in, &cached_facelets);
-    if (n < 0) {
-        ERROR("[facemgr_on_event] Error during cache lookup");
-        free(facelet_in);
-        return -1;
-    }
-    if (n == 0) {
-        /* This is a new facelet...  we expect a CREATE event. */
-        switch(facelet_get_event(facelet_in)) {
-            case FACELET_EVENT_CREATE:
-            {
-                /*
-                 * This is the first time we hear about a facelet, it will
-                 * likely not have an address family
-                 *
-                 * Assumption: we should always see the link before the address
-                 * assignment
-                 */
-                DEBUG("[facemgr_on_event] CREATE NEW %s", facelet_s);
-
-                if (!facelet_has_family(facelet_in)) {
-                    facemgr_assign_face_type(facemgr, facelet_in);
-                    if (facemgr_process_facelet_create_no_family(facemgr, facelet_in) < 0) {
-                        ERROR("[facemgr_on_event] Error processing new interface event");
-                        goto ERR;
-                    }
-                    goto DUMP_CACHE;
-                }
+  int n = facelet_cache_lookup(facemgr->facelet_cache, facelet_in,
+                               &cached_facelets);
+  if (n < 0) {
+    ERROR("[facemgr_on_event] Error during cache lookup");
+    free(facelet_in);
+    return -1;
+  }
+  if (n == 0) {
+    /* This is a new facelet...  we expect a CREATE event. */
+    switch (facelet_get_event(facelet_in)) {
+      case FACELET_EVENT_CREATE: {
+        /*
+         * This is the first time we hear about a facelet, it will
+         * likely not have an address family
+         *
+         * Assumption: we should always see the link before the address
+         * assignment
+         */
+        DEBUG("[facemgr_on_event] CREATE NEW %s", facelet_s);
 
-                if (facelet_set_add(facemgr->facelet_cache, facelet_in) < 0) {
-                    ERROR("[facemgr_on_event] Error adding facelet to cache");
-                    goto ERR;
-                }
+        if (!facelet_has_family(facelet_in)) {
+          facemgr_assign_face_type(facemgr, facelet_in);
+          if (facemgr_process_facelet_create_no_family(facemgr, facelet_in) <
+              0) {
+            ERROR("[facemgr_on_event] Error processing new interface event");
+            goto ERR;
+          }
+          goto DUMP_CACHE;
+        }
 
-                if (facemgr_process_facelet_create(facemgr, facelet_in) < 0) {
-                    ERROR("[facemgr_on_event] Error processing facelet CREATE event");
-                    ret = -1;
-                }
+        if (facelet_set_add(facemgr->facelet_cache, facelet_in) < 0) {
+          ERROR("[facemgr_on_event] Error adding facelet to cache");
+          goto ERR;
+        }
 
-                remove_facelet = false;
+        if (facemgr_process_facelet_create(facemgr, facelet_in) < 0) {
+          ERROR("[facemgr_on_event] Error processing facelet CREATE event");
+          ret = -1;
+        }
 
-                break;
-            }
+        remove_facelet = false;
 
-            case FACELET_EVENT_GET:
-                /* Insert new facelet in cached */
-                //DEBUG("[facemgr_on_event] GET NEW %s", facelet_s);
-                rc = facemgr_process_facelet_get(facemgr, facelet_in);
-                if (rc == 0)
-                    remove_facelet = false;
+        break;
+      }
+
+      case FACELET_EVENT_GET:
+        /* Insert new facelet in cached */
+        // DEBUG("[facemgr_on_event] GET NEW %s", facelet_s);
+        rc = facemgr_process_facelet_get(facemgr, facelet_in);
+        if (rc == 0) remove_facelet = false;
 #if WITH_DUMP
-                dump = false;
+        dump = false;
 #endif
-                if (rc == -1) {
-                    ERROR("[facemgr_on_event] Error processing GET event");
-                    goto ERR;
-                }
-                break;
+        if (rc == -1) {
+          ERROR("[facemgr_on_event] Error processing GET event");
+          goto ERR;
+        }
+        break;
 
-            case FACELET_EVENT_UPDATE:
-                /* Might be because we previously ignored the facelet... */
-                //ERROR("[facemgr_on_event] Unexpected UPDATE... face does not exist");
-                //goto ERR;
+      case FACELET_EVENT_UPDATE:
+        /* Might be because we previously ignored the facelet... */
+        // ERROR("[facemgr_on_event] Unexpected UPDATE... face does not exist");
+        // goto ERR;
 
 #ifdef WITH_DEFAULT_PRIORITIES
-                if (facelet_has_netdevice_type(facelet_in) && !facelet_has_netdevice(facelet_in) && facelet_has_priority(facelet_in)) {
-                    /* Remember last priority choice for newly created facelets */
-                    netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
-                    u32 priority = 0;
-                    if (facelet_get_netdevice_type(facelet_in, &netdevice_type) < 0) {
-                        ERROR("[facelet_on_event] Error getting netdevice_type");
-                        goto ERR;
-                    }
-                    if (facelet_get_priority(facelet_in, &priority) < 0) {
-                        ERROR("[facelet_on_event] Error getting priority");
-                        goto ERR;
-                    }
-                    facemgr->default_priority[netdevice_type] = priority;
-                }
+        if (facelet_has_netdevice_type(facelet_in) &&
+            !facelet_has_netdevice(facelet_in) &&
+            facelet_has_priority(facelet_in)) {
+          /* Remember last priority choice for newly created facelets */
+          netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
+          u32 priority = 0;
+          if (facelet_get_netdevice_type(facelet_in, &netdevice_type) < 0) {
+            ERROR("[facelet_on_event] Error getting netdevice_type");
+            goto ERR;
+          }
+          if (facelet_get_priority(facelet_in, &priority) < 0) {
+            ERROR("[facelet_on_event] Error getting priority");
+            goto ERR;
+          }
+          facemgr->default_priority[netdevice_type] = priority;
+        }
 #endif /* WITH_DEFAULT_PRIORITIES */
 
-                DEBUG("[facemgr_on_event] UPDATE NEW %s", facelet_s);
-                INFO("Ignored UPDATE for non-existing face");
-                break;
+        DEBUG("[facemgr_on_event] UPDATE NEW %s", facelet_s);
+        INFO("Ignored UPDATE for non-existing face");
+        break;
 
-            case FACELET_EVENT_DELETE:
-                DEBUG("[facemgr_on_event] DELETE NEW %s", facelet_s);
-                ERROR("[facemgr_on_event] Unexpected DELETE... face does not exist");
-                goto ERR;
-
-            case FACELET_EVENT_SET_UP:
-            case FACELET_EVENT_SET_DOWN:
-                ERROR("[facemgr_on_event] Unexpected event on a face that does not exist");
-                goto ERR;
+      case FACELET_EVENT_DELETE:
+        DEBUG("[facemgr_on_event] DELETE NEW %s", facelet_s);
+        ERROR("[facemgr_on_event] Unexpected DELETE... face does not exist");
+        goto ERR;
 
-            case FACELET_EVENT_UNDEFINED:
-            case FACELET_EVENT_N:
-                ERROR("[facemgr_on_event] Unexpected UNDEFINED event.");
-                ret = -1;
-                goto ERR;
+      case FACELET_EVENT_SET_UP:
+      case FACELET_EVENT_SET_DOWN:
+        ERROR(
+            "[facemgr_on_event] Unexpected event on a face that does not "
+            "exist");
+        goto ERR;
 
-        }
-        goto DUMP_CACHE;
+      case FACELET_EVENT_UNDEFINED:
+      case FACELET_EVENT_N:
+        ERROR("[facemgr_on_event] Unexpected UNDEFINED event.");
+        ret = -1;
+        goto ERR;
     }
+    goto DUMP_CACHE;
+  }
 
+  /*
+   * From now on, it should not make any difference whether we have one or
+   * more facelet.
+   */
+  for (unsigned i = 0; i < n; i++) {
     /*
-     * From now on, it should not make any difference whether we have one or
-     * more facelet.
+     * We merge each cached facelet with incoming one, and perform state
+     * reconciliation by sending appropriate updates to the forwarder
      */
-    for (unsigned i = 0; i < n; i ++) {
+    facelet_t *facelet = cached_facelets[i];
+
+    char facelet_old_s[MAXSZ_FACELET];
+    facelet_snprintf(facelet_old_s, MAXSZ_FACELET, facelet);
+    // DEBUG("Facelet from cache #%d %s", i, facelet_s);
+
+    switch (facelet_get_event(facelet_in)) {
+      case FACELET_EVENT_CREATE:
         /*
-         * We merge each cached facelet with incoming one, and perform state
-         * reconciliation by sending appropriate updates to the forwarder
+         * This can occur for a facelet already in cache but that has
+         * been previously deleted... we need to be able to consider
+         * static facelets in this situation too...
          */
-        facelet_t * facelet = cached_facelets[i];
-
-        char facelet_old_s[MAXSZ_FACELET];
-        facelet_snprintf(facelet_old_s, MAXSZ_FACELET, facelet);
-        //DEBUG("Facelet from cache #%d %s", i, facelet_s);
-
-        switch(facelet_get_event(facelet_in)) {
-            case FACELET_EVENT_CREATE:
-                /*
-                 * This can occur for a facelet already in cache but that has
-                 * been previously deleted... we need to be able to consider
-                 * static facelets in this situation too...
-                 */
-                DEBUG("[facemgr_on_event] CREATE EXISTING %s", facelet_s);
-
-                if (!facelet_has_family(facelet_in)) {
-                    if (facemgr_process_facelet_create_no_family(facemgr, facelet_in) < 0) {
-                        ERROR("[facemgr_on_event] Error processing new interface event");
-                        goto ERR;
-                    }
-                    goto DUMP_CACHE;
-                }
+        DEBUG("[facemgr_on_event] CREATE EXISTING %s", facelet_s);
 
-                // This case will occur when we try to re-create existing faces,
-                // eg. in the situation of a forwarder restarting.
-                // likely this occurs when the interface receives a (potentially new) address
-                if (facelet_merge(facelet, facelet_in) < 0) {
-                    ERROR("[facemgr_on_event] Error merging facelets");
-                    continue;
-                }
+        if (!facelet_has_family(facelet_in)) {
+          if (facemgr_process_facelet_create_no_family(facemgr, facelet_in) <
+              0) {
+            ERROR("[facemgr_on_event] Error processing new interface event");
+            goto ERR;
+          }
+          goto DUMP_CACHE;
+        }
 
-                if (facemgr_process_facelet_create(facemgr, facelet) < 0) {
-                    ERROR("[facemgr_on_event] Error processing facelet CREATE event");
-                    ret = -1;
-                }
+        // This case will occur when we try to re-create existing faces,
+        // eg. in the situation of a forwarder restarting.
+        // likely this occurs when the interface receives a (potentially new)
+        // address
+        if (facelet_merge(facelet, facelet_in) < 0) {
+          ERROR("[facemgr_on_event] Error merging facelets");
+          continue;
+        }
 
-                continue;
+        if (facemgr_process_facelet_create(facemgr, facelet) < 0) {
+          ERROR("[facemgr_on_event] Error processing facelet CREATE event");
+          ret = -1;
+        }
 
-            case FACELET_EVENT_GET: /* should be an INFORM message */
-                /*
-                 * This happens due to polling of the forwarder (or when it
-                 * restarts)
-                 */
-                //DEBUG("[facemgr_on_event] GET EXISTING %s", facelet_old_s);
-                //DEBUG("                           WITH %s", facelet_s);
-                //ERROR("[facemgr_on_event] GET event for a face that already exists...");
+        continue;
+
+      case FACELET_EVENT_GET: /* should be an INFORM message */
+                              /*
+                               * This happens due to polling of the forwarder (or when it
+                               * restarts)
+                               */
+        // DEBUG("[facemgr_on_event] GET EXISTING %s", facelet_old_s);
+        // DEBUG("                           WITH %s", facelet_s);
+        // ERROR("[facemgr_on_event] GET event for a face that already
+        // exists...");
 #ifdef WITH_DUMP
-                dump = false;
+        dump = false;
 #endif /* WITH_DUMP */
-                continue;
+        continue;
 
-            case FACELET_EVENT_UPDATE:
-                DEBUG("[facemgr_on_event] UPDATE EXISTING %s", facelet_old_s);
-                DEBUG("                              WITH %s", facelet_s);
+      case FACELET_EVENT_UPDATE:
+        DEBUG("[facemgr_on_event] UPDATE EXISTING %s", facelet_old_s);
+        DEBUG("                              WITH %s", facelet_s);
 
 #ifdef WITH_DEFAULT_PRIORITIES
-                if (facelet_has_netdevice_type(facelet_in) && !facelet_has_netdevice(facelet_in) && facelet_has_priority(facelet_in)) {
-                    /* Remember last priority choice for newly created facelets */
-                    netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
-                    u32 priority = 0;
-                    if (facelet_get_netdevice_type(facelet_in, &netdevice_type) < 0) {
-                        ERROR("[facelet_on_event] Error getting netdevice_type");
-                        goto ERR;
-                    }
-                    if (facelet_get_priority(facelet_in, &priority) < 0) {
-                        ERROR("[facelet_on_event] Error getting priority");
-                        goto ERR;
-                    }
-                    facemgr->default_priority[netdevice_type] = priority;
-                }
+        if (facelet_has_netdevice_type(facelet_in) &&
+            !facelet_has_netdevice(facelet_in) &&
+            facelet_has_priority(facelet_in)) {
+          /* Remember last priority choice for newly created facelets */
+          netdevice_type_t netdevice_type = NETDEVICE_TYPE_UNDEFINED;
+          u32 priority = 0;
+          if (facelet_get_netdevice_type(facelet_in, &netdevice_type) < 0) {
+            ERROR("[facelet_on_event] Error getting netdevice_type");
+            goto ERR;
+          }
+          if (facelet_get_priority(facelet_in, &priority) < 0) {
+            ERROR("[facelet_on_event] Error getting priority");
+            goto ERR;
+          }
+          facemgr->default_priority[netdevice_type] = priority;
+        }
 #endif /* WITH_DEFAULT_PRIORITIES */
 
-                if (facelet_merge(facelet, facelet_in) < 0) {
-                    ERROR("[facemgr_on_event] Error merging facelets");
-                    continue;
-                }
-                if (facemgr_process_facelet_update(facemgr, facelet) < 0) {
-                    ERROR("[facemgr_on_event] Error processing facelet UPDATE event");
-                    ret = -1;
-                }
-                continue;
-
-            case FACELET_EVENT_DELETE:
-                DEBUG("[facemgr_on_event] DELETE EXISTING %s", facelet_old_s);
-                DEBUG("                              WITH %s", facelet_s);
-                if (facelet_merge(facelet, facelet_in) < 0) {
-                    ERROR("[facemgr_on_event] Error merging facelets");
-                    continue;
-                }
-                if (facemgr_process_facelet_delete(facemgr, facelet) < 0) {
-                        ERROR("[facemgr_on_event] Error processing facelet DELETE event");
-                    ret = -1;
-                }
-                continue;
-
-            case FACELET_EVENT_SET_UP:
-                ERROR("[facemgr_on_event] Not implemented\n");
-                ret = -1;
-                continue;
-
-            case FACELET_EVENT_SET_DOWN:
-                DEBUG("[facemgr_on_event] SET DOWN EXISTING %s", facelet_old_s);
-                DEBUG("                                WITH %s", facelet_s);
-                /* We don't even need to merge */
-                if (facelet_merge(facelet, facelet_in) < 0) {
-                    ERROR("[facemgr_on_event] Error merging facelets");
-                    continue;
-                }
-                if (facemgr_process_facelet_delete(facemgr, facelet) < 0) {
-                    ERROR("[facemgr_on_event] Error processing facelet DELETE event");
-                    continue;
-                }
-                continue;
-
-            case FACELET_EVENT_UNDEFINED:
-            case FACELET_EVENT_N:
-                ERROR("[facemgr_on_event] Unexpected UNDEFINED event.");
-                ret = -1;
-                goto ERR;
-
+        if (facelet_merge(facelet, facelet_in) < 0) {
+          ERROR("[facemgr_on_event] Error merging facelets");
+          continue;
         }
+        if (facemgr_process_facelet_update(facemgr, facelet) < 0) {
+          ERROR("[facemgr_on_event] Error processing facelet UPDATE event");
+          ret = -1;
+        }
+        continue;
+
+      case FACELET_EVENT_DELETE:
+        DEBUG("[facemgr_on_event] DELETE EXISTING %s", facelet_old_s);
+        DEBUG("                              WITH %s", facelet_s);
+        if (facelet_merge(facelet, facelet_in) < 0) {
+          ERROR("[facemgr_on_event] Error merging facelets");
+          continue;
+        }
+        if (facemgr_process_facelet_delete(facemgr, facelet) < 0) {
+          ERROR("[facemgr_on_event] Error processing facelet DELETE event");
+          ret = -1;
+        }
+        continue;
+
+      case FACELET_EVENT_SET_UP:
+        ERROR("[facemgr_on_event] Not implemented\n");
+        ret = -1;
+        continue;
+
+      case FACELET_EVENT_SET_DOWN:
+        DEBUG("[facemgr_on_event] SET DOWN EXISTING %s", facelet_old_s);
+        DEBUG("                                WITH %s", facelet_s);
+        /* We don't even need to merge */
+        if (facelet_merge(facelet, facelet_in) < 0) {
+          ERROR("[facemgr_on_event] Error merging facelets");
+          continue;
+        }
+        if (facemgr_process_facelet_delete(facemgr, facelet) < 0) {
+          ERROR("[facemgr_on_event] Error processing facelet DELETE event");
+          continue;
+        }
+        continue;
 
+      case FACELET_EVENT_UNDEFINED:
+      case FACELET_EVENT_N:
+        ERROR("[facemgr_on_event] Unexpected UNDEFINED event.");
+        ret = -1;
+        goto ERR;
     }
-    goto DUMP_CACHE;
+  }
+  goto DUMP_CACHE;
 
 ERR:
-    ret = -1;
+  ret = -1;
 
 DUMP_CACHE:
 #if WITH_DUMP
-    if (dump) {
-        DEBUG("    <CACHE>");
-        facelet_set_dump(facemgr->facelet_cache);
-        DEBUG("    </CACHE>");
-        DEBUG("</EVENT ret=%d>", ret);
-        DEBUG("----------------------------------");
-    }
+  if (dump) {
+    DEBUG("    <CACHE>");
+    facelet_set_dump(facemgr->facelet_cache);
+    DEBUG("    </CACHE>");
+    DEBUG("</EVENT ret=%d>", ret);
+    DEBUG("----------------------------------");
+  }
 #endif /* WITH_DUMP */
 
-    free(cached_facelets);
+  free(cached_facelets);
 
-    if (remove_facelet)
-        facelet_free(facelet_in);
+  if (remove_facelet) facelet_free(facelet_in);
 
-    if (ret == -1) {
-        INFO("Error... starting reattempts");
-        facemgr_start_reattempts(facemgr);
-    }
+  if (ret == -1) {
+    INFO("Error... starting reattempts");
+    facemgr_start_reattempts(facemgr);
+  }
 
-    return ret;
+  return ret;
 }
 
-int facemgr_callback(facemgr_t * facemgr, interface_cb_type_t type, void * data)
-{
-    switch(type) {
-        case INTERFACE_CB_TYPE_RAISE_EVENT:
-            return facemgr_on_event(facemgr, data);
-
-        case INTERFACE_CB_TYPE_REGISTER_FD:
-        {
-            /* Remember fd for further release */
-            fd_callback_data_t * fd_callback_data = data;
-            interface_t * interface = (interface_t*)(fd_callback_data->owner);
-
-            interface_map_data_t * interface_map_data = NULL;
-            if (interface_map_get(facemgr->interface_map, interface->name, &interface_map_data) < 0) {
-                ERROR("[facemgr_callback] Error getting interface map data");
-                return -1;
-            }
-            if (!interface_map_data) {
-                ERROR("[facemgr_callback] No entry in interface map data");
-                return -1;
-            }
-            interface_map_data->fds[interface_map_data->num_fds++] = fd_callback_data->fd;
+int facemgr_callback(facemgr_t *facemgr, interface_cb_type_t type, void *data) {
+  switch (type) {
+    case INTERFACE_CB_TYPE_RAISE_EVENT:
+      return facemgr_on_event(facemgr, data);
 
-            return facemgr->callback(facemgr->callback_owner,
-                    FACEMGR_CB_TYPE_REGISTER_FD, data);
-        }
+    case INTERFACE_CB_TYPE_REGISTER_FD: {
+      /* Remember fd for further release */
+      fd_callback_data_t *fd_callback_data = data;
+      interface_t *interface = (interface_t *)(fd_callback_data->owner);
 
-        case INTERFACE_CB_TYPE_UNREGISTER_FD:
-        {
-            fd_callback_data_t * fd_callback_data = data;
-            interface_t * interface = (interface_t*)(fd_callback_data->owner);
+      interface_map_data_t *interface_map_data = NULL;
+      if (interface_map_get(facemgr->interface_map, interface->name,
+                            &interface_map_data) < 0) {
+        ERROR("[facemgr_callback] Error getting interface map data");
+        return -1;
+      }
+      if (!interface_map_data) {
+        ERROR("[facemgr_callback] No entry in interface map data");
+        return -1;
+      }
+      interface_map_data->fds[interface_map_data->num_fds++] =
+          fd_callback_data->fd;
 
-            interface_map_data_t * interface_map_data = NULL;
-            if (interface_map_get(facemgr->interface_map, interface->name, &interface_map_data) < 0) {
-                ERROR("[facemgr_callback] Error getting interface map data");
-                return -1;
-            }
-            if (!interface_map_data) {
-                ERROR("[facemgr_callback] No entry in interface map data");
-                return -1;
-            }
+      return facemgr->callback(facemgr->callback_owner,
+                               FACEMGR_CB_TYPE_REGISTER_FD, data);
+    }
 
-            for (unsigned i = 0; i < interface_map_data->num_fds; i++) {
-                if (interface_map_data->fds[i] == fd_callback_data->fd) {
-                    interface_map_data->fds[i] = interface_map_data->fds[--interface_map_data->num_fds];
-                    break;
-                }
-            }
+    case INTERFACE_CB_TYPE_UNREGISTER_FD: {
+      fd_callback_data_t *fd_callback_data = data;
+      interface_t *interface = (interface_t *)(fd_callback_data->owner);
 
-            return facemgr->callback(facemgr->callback_owner,
-                    FACEMGR_CB_TYPE_UNREGISTER_FD, data);
+      interface_map_data_t *interface_map_data = NULL;
+      if (interface_map_get(facemgr->interface_map, interface->name,
+                            &interface_map_data) < 0) {
+        ERROR("[facemgr_callback] Error getting interface map data");
+        return -1;
+      }
+      if (!interface_map_data) {
+        ERROR("[facemgr_callback] No entry in interface map data");
+        return -1;
+      }
+
+      for (unsigned i = 0; i < interface_map_data->num_fds; i++) {
+        if (interface_map_data->fds[i] == fd_callback_data->fd) {
+          interface_map_data->fds[i] =
+              interface_map_data->fds[--interface_map_data->num_fds];
+          break;
         }
+      }
 
-        case INTERFACE_CB_TYPE_REGISTER_TIMER:
-            return facemgr->callback(facemgr->callback_owner,
-                    FACEMGR_CB_TYPE_REGISTER_TIMER, data);
+      return facemgr->callback(facemgr->callback_owner,
+                               FACEMGR_CB_TYPE_UNREGISTER_FD, data);
+    }
 
-        case INTERFACE_CB_TYPE_UNREGISTER_TIMER:
-            return facemgr->callback(facemgr->callback_owner,
-                    FACEMGR_CB_TYPE_UNREGISTER_TIMER, data);
+    case INTERFACE_CB_TYPE_REGISTER_TIMER:
+      return facemgr->callback(facemgr->callback_owner,
+                               FACEMGR_CB_TYPE_REGISTER_TIMER, data);
 
-    }
-    return -1;
+    case INTERFACE_CB_TYPE_UNREGISTER_TIMER:
+      return facemgr->callback(facemgr->callback_owner,
+                               FACEMGR_CB_TYPE_UNREGISTER_TIMER, data);
+  }
+  return -1;
 }
 
-int
-facemgr_bootstrap(facemgr_t * facemgr)
-{
-    int rc;
+int facemgr_bootstrap(facemgr_t *facemgr) {
+  int rc;
 
-    DEBUG("Registering interfaces...");
-    rc = interface_register(&hicn_light_ops);
-    if (rc < 0) {
-        ERROR("[facemgr_bootstrap] Error registering hicn_light interface");
-        goto ERR_REGISTER;
-    }
+  DEBUG("Registering interfaces...");
+  rc = interface_register(&hicn_light_ops);
+  if (rc < 0) {
+    ERROR("[facemgr_bootstrap] Error registering hicn_light interface");
+    goto ERR_REGISTER;
+  }
 
 #ifdef __APPLE__
-    rc = interface_register(&network_framework_ops);
-    if (rc < 0) {
-        ERROR("[facemgr_bootstrap] Error registering network_framework interface");
-        goto ERR_REGISTER;
-    }
+  rc = interface_register(&network_framework_ops);
+  if (rc < 0) {
+    ERROR("[facemgr_bootstrap] Error registering network_framework interface");
+    goto ERR_REGISTER;
+  }
 #endif /* __APPLE__ */
 
 #ifdef __linux__
-    rc = interface_register(&netlink_ops);
-    if (rc < 0) {
-        ERROR("[facemgr_bootstrap] Error registering netlink interface");
-        goto ERR_REGISTER;
-    }
+#ifdef __ANDROID__
+  rc = interface_register(&android_ops);
+  if (rc < 0) {
+    ERROR("[facemgr_bootstrap] Error registering android interface");
+    goto ERR_REGISTER;
+  }
+#else
+  rc = interface_register(&netlink_ops);
+  if (rc < 0) {
+    ERROR("[facemgr_bootstrap] Error registering netlink interface");
+    goto ERR_REGISTER;
+  }
+#endif /* __ANDROID__ */
 
-    rc = interface_register(&bonjour_ops);
-    if (rc < 0) {
-        ERROR("[facemgr_bootstrap] Error registering bonjour interface");
-        goto ERR_REGISTER;
-    }
+  rc = interface_register(&bonjour_ops);
+  if (rc < 0) {
+    ERROR("[facemgr_bootstrap] Error registering bonjour interface");
+    goto ERR_REGISTER;
+  }
 #endif /* __linux__ */
 
-#ifdef WITH_FACEMGR_UTILITY
-    rc = interface_register(&android_utility_ops);
-    if (rc < 0) {
-        ERROR("[facemgr_bootstrap] Error registering android_utility interface");
-        goto ERR_REGISTER;
-    }
-#endif /* WITH_FACEMGR_UTILITY */
-
 #ifdef WITH_PRIORITY_CONTROLLER
-    INFO("[facemgr_bootstrap] registering priority_controller interface");
-    rc = interface_register(&priority_controller_ops);
-    if (rc < 0) {
-        ERROR("[facemgr_bootstrap] Error registering priority_controller interface");
-        goto ERR_REGISTER;
-    }
+  INFO("[facemgr_bootstrap] registering priority_controller interface");
+  rc = interface_register(&priority_controller_ops);
+  if (rc < 0) {
+    ERROR(
+        "[facemgr_bootstrap] Error registering priority_controller interface");
+    goto ERR_REGISTER;
+  }
 #endif
 
 #ifdef WITH_EXAMPLE_DUMMY
-    rc = interface_register(&dummy_ops);
-    if (rc < 0) {
-        ERROR("[facemgr_bootstrap] Error registering dummy interface");
-        goto ERR_REGISTER;
-    }
+  rc = interface_register(&dummy_ops);
+  if (rc < 0) {
+    ERROR("[facemgr_bootstrap] Error registering dummy interface");
+    goto ERR_REGISTER;
+  }
 #endif
 
 #ifdef WITH_EXAMPLE_UPDOWN
-    rc = interface_register(&updown_ops);
-    if (rc < 0) {
-        ERROR("[facemgr_bootstrap] Error registering updown interface");
-        goto ERR_REGISTER;
-    }
+  rc = interface_register(&updown_ops);
+  if (rc < 0) {
+    ERROR("[facemgr_bootstrap] Error registering updown interface");
+    goto ERR_REGISTER;
+  }
 #endif
 
-    rc = facemgr_create_interface(facemgr, "hl", "hicn_light", NULL, &facemgr->hl);
-    if (rc < 0) {
-        ERROR("Error creating 'hICN forwarder (hicn-light)' interface\n");
-        goto ERR_HL_CREATE;
-    }
-
 #ifdef __APPLE__
-    network_framework_cfg_t nf_cfg = {
-    };
-    rc = facemgr_create_interface(facemgr, "nf", "network_framework", &nf_cfg, &facemgr->nf);
-    if (rc < 0) {
-        ERROR("Error creating 'Apple Network Framework' interface\n");
-        goto ERR_NF_CREATE;
-    }
+  network_framework_cfg_t nf_cfg = {};
+  rc = facemgr_create_interface(facemgr, "nf", "network_framework", &nf_cfg,
+                                &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", NULL, &facemgr->nl);
-    if (rc < 0) {
-        ERROR("Error creating 'Netlink' interface\n");
-        goto ERR_NL_CREATE;
-    }
+#ifdef __ANDROID__
+  android_cfg_t android_cfg = {
+      .jvm = facemgr->jvm,
+  };
+  rc = facemgr_create_interface(facemgr, "android", "android", &android_cfg,
+                                &facemgr->android);
+  if (rc < 0) {
+    ERROR("Error creating 'Android' interface\n");
+    goto ERR_ANDROID_CREATE;
+  }
+#else
+  rc = facemgr_create_interface(facemgr, "nl", "netlink", NULL, &facemgr->nl);
+  if (rc < 0) {
+    ERROR("Error creating 'Netlink' interface\n");
+    goto ERR_NL_CREATE;
+  }
+#endif /* __ANDROID__ */
 #endif /* __linux__ */
 
-#ifdef WITH_FACEMGR_UTILITY
-    android_utility_cfg_t au_cfg = {
-        .jvm = facemgr->jvm,
-    };
-    rc = facemgr_create_interface(facemgr, "au", "android_utility", &au_cfg, &facemgr->au);
-    if (rc < 0) {
-        ERROR("Error creating 'Android Utility' interface\n");
-        goto ERR_AU_CREATE;
-    }
-#endif /* WITH_FACEMGR_UTILITY */
-
 #ifdef WITH_PRIORITY_CONTROLLER
-    INFO("[facemgr_bootstrap] creating priority_controller interface");
-    priority_controller_cfg_t pc_cfg = {
+  INFO("[facemgr_bootstrap] creating priority_controller interface");
+  priority_controller_cfg_t pc_cfg = {
 #ifdef PRIORITY_CONTROLLER_INTERNAL
-        .jvm = facemgr->jvm,
+      .jvm = facemgr->jvm,
 #endif /* PRIORITY_CONTROLLER_INTERNAL */
-    };
-    rc = facemgr_create_interface(facemgr, "pc", "priority_controller", &pc_cfg, &facemgr->pc);
-    if (rc < 0) {
-        ERROR("Error creating 'Priority Controller' interface\n");
-        goto ERR_PC_CREATE;
-    }
+  };
+  rc = facemgr_create_interface(facemgr, "pc", "priority_controller", &pc_cfg,
+                                &facemgr->pc);
+  if (rc < 0) {
+    ERROR("Error creating 'Priority Controller' interface\n");
+    goto ERR_PC_CREATE;
+  }
 #endif
 
 #ifdef WITH_EXAMPLE_DUMMY
-    rc = facemgr_create_interface(facemgr, "dummy0", "dummy", NULL, &facemgr->dummy);
-    if (rc < 0) {
-        ERROR("Error creating 'dummy' interface\n");
-        goto ERR_DUMMY_CREATE;
-    }
+  rc = facemgr_create_interface(facemgr, "dummy0", "dummy", NULL,
+                                &facemgr->dummy);
+  if (rc < 0) {
+    ERROR("Error creating 'dummy' interface\n");
+    goto ERR_DUMMY_CREATE;
+  }
 #endif
 
 #ifdef WITH_EXAMPLE_UPDOWN
-    rc = facemgr_create_interface(facemgr, "updown0", "updown", NULL, &facemgr->updown);
-    if (rc < 0) {
-        ERROR("Error creating 'updown' interface\n");
-        goto ERR_UPDOWN_CREATE;
-    }
+  rc = facemgr_create_interface(facemgr, "updown0", "updown", NULL,
+                                &facemgr->updown);
+  if (rc < 0) {
+    ERROR("Error creating 'updown' interface\n");
+    goto ERR_UPDOWN_CREATE;
+  }
 #endif
 
-    DEBUG("Facemgr successfully initialized...");
+  rc =
+      facemgr_create_interface(facemgr, "hl", "hicn_light", NULL, &facemgr->hl);
+  if (rc < 0) {
+    ERROR("Error creating 'hICN forwarder (hicn-light)' interface\n");
+    goto ERR_HL_CREATE;
+  }
 
-    return 0;
+  DEBUG("Facemgr successfully initialized...");
+
+  return 0;
 
+ERR_HL_CREATE:
 #ifdef WITH_EXAMPLE_UPDOWN
-    facemgr_delete_interface(facemgr, facemgr->updown);
+  facemgr_delete_interface(facemgr, facemgr->updown);
 ERR_UPDOWN_CREATE:
 #endif
+
 #ifdef WITH_EXAMPLE_DUMMY
-    facemgr_delete_interface(facemgr, facemgr->dummy);
+  facemgr_delete_interface(facemgr, facemgr->dummy);
 ERR_DUMMY_CREATE:
 #endif
-#ifdef WITH_FACEMGR_UTILITY
-    facemgr_delete_interface(facemgr, facemgr->au);
-ERR_AU_CREATE:
-#endif /* WITH_FACEMGR_UTILITY */
+
 #ifdef WITH_PRIORITY_CONTROLLER
-    facemgr_delete_interface(facemgr, facemgr->pc);
+  facemgr_delete_interface(facemgr, facemgr->pc);
 ERR_PC_CREATE:
 #endif
+
 #ifdef __linux__
-    facemgr_delete_interface(facemgr, facemgr->nl);
+#ifdef __ANDROID__
+  facemgr_delete_interface(facemgr, facemgr->android);
+ERR_ANDROID_CREATE:
+#else
+  facemgr_delete_interface(facemgr, facemgr->nl);
 ERR_NL_CREATE:
+#endif /* __ANDROID__ */
 #endif /* __linux__ */
+
 #ifdef __APPLE__
-    facemgr_delete_interface(facemgr, facemgr->nf);
+  facemgr_delete_interface(facemgr, facemgr->nf);
 ERR_NF_CREATE:
 #endif /* __APPLE__ */
-    facemgr_delete_interface(facemgr, facemgr->hl);
-ERR_HL_CREATE:
 ERR_REGISTER:
-    return -1;
+  return -1;
 }
 
-void facemgr_stop(facemgr_t * facemgr)
-{
-    // FIXME we should iterate on interface map
+void facemgr_stop(facemgr_t *facemgr) {
+  // FIXME we should iterate on interface map
 
 #ifdef __APPLE__
-    facemgr_delete_interface(facemgr, facemgr->nf);
+  facemgr_delete_interface(facemgr, facemgr->nf);
 #endif /* __APPLE__ */
 
-
 #ifdef __linux__
-    facemgr_delete_interface(facemgr, facemgr->nl);
-
-    /* Delete all bonjour interfaces */
-    interface_t ** bonjour_array = NULL;
-    int n = bonjour_map_get_value_array(facemgr->bonjour_map, &bonjour_array);
-    if (n >= 0) {
-        netdevice_t ** netdevice_array = NULL;
-        int m = bonjour_map_get_key_array(facemgr->bonjour_map, &netdevice_array);
-        if (m >= 0) {
-            assert(m == n);
-            for (int i = 0; i < n; i++) { /* Fail silently */
-                DEBUG("Deleting bonjour interface associated to %s (%p)",
-                        netdevice_array[i]->name, bonjour_array[i]);
-                facemgr_delete_interface(facemgr, bonjour_array[i]);
-            }
-            free(netdevice_array);
-        }
-        free(bonjour_array);
-    }
-#endif /* __linux__ */
+#ifdef __ANDROID__
+  facemgr_delete_interface(facemgr, facemgr->android);
+#else
+  facemgr_delete_interface(facemgr, facemgr->nl);
+#endif /* __ANDROID__ */
 
-#ifdef WITH_FACEMGR_UTILITY
-    facemgr_delete_interface(facemgr, facemgr->au);
-#endif /* WITH_FACEMGR_UTILITY */
+  /* Delete all bonjour interfaces */
+  interface_t **bonjour_array = NULL;
+  int n = bonjour_map_get_value_array(facemgr->bonjour_map, &bonjour_array);
+  if (n >= 0) {
+    netdevice_t **netdevice_array = NULL;
+    int m = bonjour_map_get_key_array(facemgr->bonjour_map, &netdevice_array);
+    if (m >= 0) {
+      assert(m == n);
+      for (int i = 0; i < n; i++) { /* Fail silently */
+        DEBUG("Deleting bonjour interface associated to %s (%p)",
+              netdevice_array[i]->name, bonjour_array[i]);
+        facemgr_delete_interface(facemgr, bonjour_array[i]);
+      }
+      free(netdevice_array);
+    }
+    free(bonjour_array);
+  }
+#endif /* __linux__ */
 
 #ifdef WITH_PRIORITY_CONTROLLER
-    facemgr_delete_interface(facemgr, facemgr->pc);
+  facemgr_delete_interface(facemgr, facemgr->pc);
 #endif
 
-    facemgr_delete_interface(facemgr, facemgr->hl);
+  facemgr_delete_interface(facemgr, facemgr->hl);
 
 #ifdef WITH_EXAMPLE_DUMMY
-    facemgr_delete_interface(facemgr, facemgr->dummy);
+  facemgr_delete_interface(facemgr, facemgr->dummy);
 #endif
 
 #ifdef WITH_EXAMPLE_UPDOWN
-    facemgr_delete_interface(facemgr, facemgr->updown);
+  facemgr_delete_interface(facemgr, facemgr->updown);
 #endif
 }
 
 #ifdef __ANDROID__
-void facemgr_set_jvm(facemgr_t * facemgr, JavaVM *jvm)
-{
-    facemgr->jvm = jvm;
+void facemgr_set_jvm(facemgr_t *facemgr, JavaVM *jvm) { facemgr->jvm = jvm; }
+
+void facemgr_on_android_callback(facemgr_t *facemgr, const char *interface_name,
+                                 netdevice_type_t netdevice_type, bool up,
+                                 int family, const char *ip_address) {
+  android_on_network_event(facemgr->android, interface_name, netdevice_type, up,
+                           family, ip_address);
 }
 #endif /* __ANDROID__ */
 
-void
-facemgr_set_callback(facemgr_t * facemgr, void * callback_owner, facemgr_cb_t callback)
-{
-    facemgr->callback = callback;
-    facemgr->callback_owner = callback_owner;
+void facemgr_set_callback(facemgr_t *facemgr, void *callback_owner,
+                          facemgr_cb_t callback) {
+  facemgr->callback = callback;
+  facemgr->callback_owner = callback_owner;
 }
 
-void facemgr_list_facelets(const facemgr_t * facemgr, facemgr_list_facelets_cb_t cb, void * user_data)
-{
-    facelet_t ** facelet_array;
-    if (!cb)
-        return;
-    int n = facelet_set_get_array(facemgr->facelet_cache, &facelet_array);
-    if (n < 0) {
-        ERROR("[facemgr_list_facelets] Could not retrieve facelets in cache");
-        return;
-    }
-    for (unsigned i = 0; i < n; i++) {
-        facelet_t * facelet = facelet_array[i];
-        cb(facemgr, facelet, user_data);
-    }
-    free(facelet_array);
+void facemgr_list_facelets(const facemgr_t *facemgr,
+                           facemgr_list_facelets_cb_t cb, void *user_data) {
+  facelet_t **facelet_array;
+  if (!cb) return;
+  int n = facelet_set_get_array(facemgr->facelet_cache, &facelet_array);
+  if (n < 0) {
+    ERROR("[facemgr_list_facelets] Could not retrieve facelets in cache");
+    return;
+  }
+  for (unsigned i = 0; i < n; i++) {
+    facelet_t *facelet = facelet_array[i];
+    if (!facelet) continue; /* Should not occur */
+    cb(facemgr, facelet, user_data);
+  }
+  free(facelet_array);
 }
 
-int
-facemgr_list_facelets_json(const facemgr_t * facemgr, char ** buffer)
-{
-    char * cur;
-    char * s;
-    int rc;
-
-    facelet_t ** facelet_array;
-    int n = facelet_set_get_array(facemgr->facelet_cache, &facelet_array);
-    if (n < 0) {
-        ERROR("[facemgr_list_facelets_json] Could not retrieve facelets in cache");
-        return -1;
-    }
-    /* This should be enough for JSON overhead, refine later */
-    size_t size = 2 * n * MAXSZ_FACELET;
-    *buffer = malloc(size);
-    if (!buffer) {
-        ERROR("[facemgr_list_facelets_json] Could not allocate JSON s");
-        free(facelet_array);
-        return -1;
-    }
-    s = *buffer;
-    cur = s;
+int facemgr_list_facelets_json(const facemgr_t *facemgr, char **buffer) {
+  char *cur;
+  char *s;
+  int rc;
 
-    rc = snprintf(cur, s + size - cur, "{\"facelets\": [\n");
-    if (rc < 0)
-        goto ERR;
-    cur += rc;
-    if (size != 0 && cur >= s + size)
-        goto END;
+  facelet_t **facelet_array;
+  int n = facelet_set_get_array(facemgr->facelet_cache, &facelet_array);
+  if (n < 0) {
+    ERROR("[facemgr_list_facelets_json] Could not retrieve facelets in cache");
+    return -1;
+  }
+  /* This should be enough for JSON overhead, refine later */
+  size_t size = 2 * n * MAXSZ_FACELET;
+  *buffer = malloc(size);
+  if (!buffer) {
+    ERROR("[facemgr_list_facelets_json] Could not allocate JSON s");
+    free(facelet_array);
+    return -1;
+  }
+  s = *buffer;
+  cur = s;
 
-    for (unsigned i = 0; i < n; i++) {
-        facelet_t * facelet = facelet_array[i];
+  rc = snprintf(cur, s + size - cur, "{\"facelets\": [\n");
+  if (rc < 0) goto ERR;
+  cur += rc;
+  if (size != 0 && cur >= s + size) goto END;
 
-        rc = facelet_snprintf_json(cur, s + size - cur, facelet, /* indent */ 1);
-        if (rc < 0)
-            goto ERR;
-        cur += rc;
-        if (size != 0 && cur >= s + size)
-            goto END;
+  for (unsigned i = 0; i < n; i++) {
+    facelet_t *facelet = facelet_array[i];
+    if (!facelet) continue; /* Should not occur */
 
-        rc = snprintf(cur, s + size - cur, (i == n-1) ? "\n" : ",\n");
-        if (rc < 0)
-            goto ERR;
-        cur += rc;
-        if (size != 0 && cur >= s + size)
-            goto END;
-    }
+    rc = facelet_snprintf_json(cur, s + size - cur, facelet, /* indent */ 1);
+    if (rc < 0) goto ERR;
+    cur += rc;
+    if (size != 0 && cur >= s + size) goto END;
 
-    rc = snprintf(cur, s + size - cur, "]}\n");
-    if (rc < 0)
-        goto ERR;
+    rc = snprintf(cur, s + size - cur, (i == n - 1) ? "\n" : ",\n");
+    if (rc < 0) goto ERR;
     cur += rc;
-    if (size != 0 && cur >= s + size)
-        goto END;
+    if (size != 0 && cur >= s + size) goto END;
+  }
+
+  rc = snprintf(cur, s + size - cur, "]}\n");
+  if (rc < 0) goto ERR;
+  cur += rc;
+  if (size != 0 && cur >= s + size) goto END;
 
 END:
-    free(facelet_array);
-    return (int)(cur - s);
+  free(facelet_array);
+  return (int)(cur - s);
 
 ERR:
-    free(facelet_array);
-    return rc;
+  free(facelet_array);
+  return rc;
 }
-
diff --git a/ctrl/facemgr/src/cache.c b/ctrl/facemgr/src/cache.c
index f994d7d37..98c68e9b0 100644
--- a/ctrl/facemgr/src/cache.c
+++ b/ctrl/facemgr/src/cache.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -22,106 +22,86 @@
  * search.h).
  */
 
-#include <math.h> // log2
-#include <string.h> // memmove
+#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_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;
+  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:
+  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;
+  face_cache->size = 0;
 
-    return face_cache;
+  return face_cache;
 
-#if(FACE_CACHE_MAX_SIZE_LOG_INIT != 0)
+#if (FACE_CACHE_MAX_SIZE_LOG_INIT != 0)
 ERR_ARRAY:
-    free(face_cache);
+  free(face_cache);
 #endif
 ERR_MALLOC:
-    return NULL;
+  return NULL;
 }
 
-void
-face_cache_free(face_cache_t * face_cache)
-{
-    free(face_cache->faces);
+void face_cache_free(face_cache_t* face_cache) {
+  free(face_cache->faces);
 
-    free(face_cache);
+  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*));
-    }
+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;
+  if (!face_cache->faces) goto ERR_REALLOC;
 
-    face_cache->faces[face_cache->size++] = face;
+  face_cache->faces[face_cache->size++] = face;
 
-    return face;
+  return face;
 
 ERR_REALLOC:
-    return NULL;
+  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;
+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;
+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);
+  /* 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--;
+  face_cache->size--;
 
-    return face;
+  return face;
 }
 
 /* TODO : remove by ... */
 
-face_t *
-face_cache_get_by_id(face_cache_t * face_cache, int id)
-{
-    return NULL;
-}
-
-
+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)
-{
-
-}
+void face_cache_dump(face_cache_t* face_cache) {}
diff --git a/ctrl/facemgr/src/cache.h b/ctrl/facemgr/src/cache.h
index 1389ed6ec..ac14fabb8 100644
--- a/ctrl/facemgr/src/cache.h
+++ b/ctrl/facemgr/src/cache.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -32,22 +32,22 @@
  * \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_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);
+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_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);
+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);
+void face_cache_dump(face_cache_t* face_cache);
 
 #endif /* FACEMGR_CACHE_H */
diff --git a/ctrl/facemgr/src/cfg.c b/ctrl/facemgr/src/cfg.c
index df73acd1b..9c374388a 100644
--- a/ctrl/facemgr/src/cfg.c
+++ b/ctrl/facemgr/src/cfg.c
@@ -4,7 +4,7 @@
  */
 
 #include <assert.h>
-#include <hicn/ctrl.h> // HICN_DEFAULT_PORT
+#include <hicn/ctrl.h>  // HICN_DEFAULT_PORT
 #include <hicn/facemgr/cfg.h>
 #include <hicn/policy.h>
 #include <hicn/util/ip_address.h>
@@ -14,691 +14,643 @@
 /* Overlay */
 
 typedef struct {
-    bool is_local_port;
-    uint16_t local_port;
-    bool is_local_addr;
-    ip_address_t local_addr;
-    bool is_remote_port;
-    uint16_t remote_port;
-    bool is_remote_addr;
-    ip_address_t remote_addr;
+  bool is_local_port;
+  uint16_t local_port;
+  bool is_local_addr;
+  ip_address_t local_addr;
+  bool is_remote_port;
+  uint16_t remote_port;
+  bool is_remote_addr;
+  ip_address_t remote_addr;
 } facemgr_cfg_overlay_t;
 
-int facemgr_cfg_overlay_initialize(facemgr_cfg_overlay_t * overlay)
-{
-    overlay->is_local_port = false;
-    overlay->local_port = 0;
-    overlay->is_local_addr = false;
-    overlay->local_addr = IP_ADDRESS_EMPTY;
+int facemgr_cfg_overlay_initialize(facemgr_cfg_overlay_t *overlay) {
+  overlay->is_local_port = false;
+  overlay->local_port = 0;
+  overlay->is_local_addr = false;
+  overlay->local_addr = IP_ADDRESS_EMPTY;
 
-    overlay->is_remote_port = false;
-    overlay->remote_port = 0;
-    overlay->is_remote_addr = false;
-    overlay->remote_addr = IP_ADDRESS_EMPTY;
+  overlay->is_remote_port = false;
+  overlay->remote_port = 0;
+  overlay->is_remote_addr = false;
+  overlay->remote_addr = IP_ADDRESS_EMPTY;
 
-    return 0;
+  return 0;
 }
 
-int facemgr_cfg_overlay_finalize(facemgr_cfg_overlay_t * overlay)
-{
-    return 0;
-}
+int facemgr_cfg_overlay_finalize(facemgr_cfg_overlay_t *overlay) { return 0; }
 
-facemgr_cfg_overlay_t * facemgr_cfg_overlay_create()
-{
-    facemgr_cfg_overlay_t * overlay = malloc(sizeof(facemgr_cfg_overlay_t));
-    if (!overlay)
-        return NULL;
+facemgr_cfg_overlay_t *facemgr_cfg_overlay_create() {
+  facemgr_cfg_overlay_t *overlay = malloc(sizeof(facemgr_cfg_overlay_t));
+  if (!overlay) return NULL;
 
-    int rc = facemgr_cfg_overlay_initialize(overlay);
-    if (rc < 0) {
-        free(overlay);
-        return NULL;
-    }
+  int rc = facemgr_cfg_overlay_initialize(overlay);
+  if (rc < 0) {
+    free(overlay);
+    return NULL;
+  }
 
-    return overlay;
+  return overlay;
 }
 
-void facemgr_cfg_overlay_free(facemgr_cfg_overlay_t * overlay)
-{
-    facemgr_cfg_overlay_finalize(overlay);
-    free(overlay);
+void facemgr_cfg_overlay_free(facemgr_cfg_overlay_t *overlay) {
+  facemgr_cfg_overlay_finalize(overlay);
+  free(overlay);
 }
 
 typedef struct {
-    facemgr_cfg_overlay_t * v4;
-    facemgr_cfg_overlay_t * v6;
+  facemgr_cfg_overlay_t *v4;
+  facemgr_cfg_overlay_t *v6;
 } facemgr_cfg_overlays_t;
 
 typedef struct {
-    const char * interface_name;
-    netdevice_type_t interface_type;
+  const char *interface_name;
+  netdevice_type_t interface_type;
 } facemgr_cfg_match_t;
 
-
 typedef struct {
-    /* Interface specific */
-    bool is_face_type; // default is auto
-    facemgr_face_type_t face_type;
-
-    /* This should be defaut for the global settings */
-    bool is_ignore;
-    bool ignore;
-    bool is_discovery;
-    bool discovery;
-    bool is_ipv4;
-    bool ipv4;
-    bool is_ipv6;
-    bool ipv6;
-
-    facemgr_cfg_overlays_t overlays; // fallback unless discovery is disabled
+  /* Interface specific */
+  bool is_face_type;  // default is auto
+  facemgr_face_type_t face_type;
+
+  /* This should be defaut for the global settings */
+  bool is_ignore;
+  bool ignore;
+  bool is_discovery;
+  bool discovery;
+  bool is_ipv4;
+  bool ipv4;
+  bool is_ipv6;
+  bool ipv6;
+
+  facemgr_cfg_overlays_t overlays;  // fallback unless discovery is disabled
 } facemgr_cfg_override_t;
 
 struct facemgr_cfg_rule_s {
-    facemgr_cfg_match_t match;
-    facemgr_cfg_override_t override;
+  facemgr_cfg_match_t match;
+  facemgr_cfg_override_t override;
 };
 
-int facemgr_cfg_override_initialize(facemgr_cfg_override_t * override)
-{
-    override->is_face_type = false;
-    override->face_type = FACEMGR_FACE_TYPE_UNDEFINED;
+int facemgr_cfg_override_initialize(facemgr_cfg_override_t *override) {
+  override->is_face_type = false;
+  override->face_type = FACEMGR_FACE_TYPE_UNDEFINED;
 
-    override->is_ignore = false;
-    override->ignore = false;
+  override->is_ignore = false;
+  override->ignore = false;
 
-    override->is_discovery = false;
-    override->discovery = false;
+  override->is_discovery = false;
+  override->discovery = false;
 
-    override->is_ipv4 = false;
-    override->ipv6 = false;
-    override->is_ipv6 = false;
-    override->ipv6 = false;
+  override->is_ipv4 = false;
+  override->ipv6 = false;
+  override->is_ipv6 = false;
+  override->ipv6 = false;
 
-    override->overlays.v4 = NULL;
-    override->overlays.v6 = NULL;
+  override->overlays.v4 = NULL;
+  override->overlays.v6 = NULL;
 
-    return 0;
+  return 0;
 }
 
-int facemgr_cfg_override_finalize(facemgr_cfg_override_t * override)
-{
-    if (override->overlays.v4) {
-        facemgr_cfg_overlay_free(override->overlays.v4);
-        override->overlays.v4 = NULL;
-    }
-    if (override->overlays.v6) {
-        facemgr_cfg_overlay_free(override->overlays.v6);
-        override->overlays.v6 = NULL;
-    }
+int facemgr_cfg_override_finalize(facemgr_cfg_override_t *override) {
+  if (override->overlays.v4) {
+    facemgr_cfg_overlay_free(override->overlays.v4);
+    override->overlays.v4 = NULL;
+  }
+  if (override->overlays.v6) {
+    facemgr_cfg_overlay_free(override->overlays.v6);
+    override->overlays.v6 = NULL;
+  }
 
-    return 0;
+  return 0;
 }
 
-
 /* Rule */
-facemgr_cfg_rule_t * facemgr_cfg_rule_create()
-{
-    facemgr_cfg_rule_t * rule = malloc(sizeof(facemgr_cfg_rule_t));
-    if (!rule)
-        return NULL;
+facemgr_cfg_rule_t *facemgr_cfg_rule_create() {
+  facemgr_cfg_rule_t *rule = malloc(sizeof(facemgr_cfg_rule_t));
+  if (!rule) return NULL;
 
-    int rc = facemgr_cfg_rule_initialize(rule);
-    if (rc < 0)
-        return NULL;
+  int rc = facemgr_cfg_rule_initialize(rule);
+  if (rc < 0) return NULL;
 
-    return rule;
+  return rule;
 }
 
-void facemgr_cfg_rule_free(facemgr_cfg_rule_t * rule)
-{
-    facemgr_cfg_rule_finalize(rule);
-    free(rule);
+void facemgr_cfg_rule_free(facemgr_cfg_rule_t *rule) {
+  facemgr_cfg_rule_finalize(rule);
+  free(rule);
 }
 
-int facemgr_cfg_rule_initialize(facemgr_cfg_rule_t * rule)
-{
-    rule->match.interface_name = NULL;
-    rule->match.interface_type = NETDEVICE_TYPE_UNDEFINED;
+int facemgr_cfg_rule_initialize(facemgr_cfg_rule_t *rule) {
+  rule->match.interface_name = NULL;
+  rule->match.interface_type = NETDEVICE_TYPE_UNDEFINED;
 
-    int rc = facemgr_cfg_override_initialize(&rule->override);
-    if (rc < 0)
-        return -1;
+  int rc = facemgr_cfg_override_initialize(&rule->override);
+  if (rc < 0) return -1;
 
-    return 0;
+  return 0;
 }
 
-int facemgr_cfg_rule_finalize(facemgr_cfg_rule_t * rule)
-{
-    if (rule->match.interface_name) {
-        free((void*)rule->match.interface_name);
-        rule->match.interface_name = NULL;
+int facemgr_cfg_rule_finalize(facemgr_cfg_rule_t *rule) {
+  if (rule->match.interface_name) {
+    free((void *)rule->match.interface_name);
+    rule->match.interface_name = NULL;
+  }
+  return facemgr_cfg_override_finalize(&rule->override);
+}
+
+void facemgr_cfg_rule_dump(facemgr_cfg_rule_t *rule) {
+  DEBUG("  <rule>");
+  DEBUG("    <match interface_name=%s interface_type=%s>",
+        rule->match.interface_name,
+        netdevice_type_str(rule->match.interface_type));
+  DEBUG("    <override>");
+  if (rule->override.is_face_type) {
+    DEBUG("      <face_type>%d</face_type>", rule->override.face_type);
+  }
+  if (rule->override.is_ignore) {
+    DEBUG("      <ignore>%d</ignore>", rule->override.ignore);
+  }
+  if (rule->override.is_discovery) {
+    DEBUG("      <discovery>%d</discovery>", rule->override.discovery);
+  }
+  if (rule->override.is_ipv4) {
+    DEBUG("      <ipv4>%d</ipv4>", rule->override.ipv4);
+  }
+  if (rule->override.is_ipv6) {
+    DEBUG("      <ipv6>%d</ipv6>", rule->override.ipv6);
+  }
+  DEBUG("      <overlays>");
+  if (rule->override.overlays.v4) {
+    DEBUG("        <ipv4>");
+    if (rule->override.overlays.v4->is_local_addr) {
+      char buf[MAXSZ_IP_ADDRESS];
+      ip_address_snprintf(buf, MAXSZ_IP_ADDRESS,
+                          &rule->override.overlays.v4->local_addr, AF_INET);
+      DEBUG("          <local_addr>%s</local_addr>", buf);
     }
-    return facemgr_cfg_override_finalize(&rule->override);
-}
-
-void facemgr_cfg_rule_dump(facemgr_cfg_rule_t * rule)
-{
-    DEBUG("  <rule>");
-    DEBUG("    <match interface_name=%s interface_type=%s>",
-            rule->match.interface_name,
-            netdevice_type_str[rule->match.interface_type]);
-    DEBUG("    <override>");
-    if (rule->override.is_face_type) {
-        DEBUG("      <face_type>%d</face_type>", rule->override.face_type);
+    if (rule->override.overlays.v4->is_local_port) {
+      DEBUG("          <local_port>%d</local_port>",
+            rule->override.overlays.v4->local_port);
     }
-    if (rule->override.is_ignore) {
-        DEBUG("      <ignore>%d</ignore>", rule->override.ignore);
+    if (rule->override.overlays.v4->is_remote_addr) {
+      char buf[MAXSZ_IP_ADDRESS];
+      ip_address_snprintf(buf, MAXSZ_IP_ADDRESS,
+                          &rule->override.overlays.v4->remote_addr, AF_INET);
+      DEBUG("          <remote_addr>%s</remote_addr>", buf);
     }
-    if (rule->override.is_discovery) {
-        DEBUG("      <discovery>%d</discovery>", rule->override.discovery);
+    if (rule->override.overlays.v4->is_remote_port) {
+      DEBUG("          <remote_port>%d</remote_port>",
+            rule->override.overlays.v4->remote_port);
     }
-    if (rule->override.is_ipv4) {
-        DEBUG("      <ipv4>%d</ipv4>", rule->override.ipv4);
+    DEBUG("        </ipv4>");
+  }
+  if (rule->override.overlays.v6) {
+    DEBUG("        <ipv6>");
+    if (rule->override.overlays.v6->is_local_addr) {
+      char buf[MAXSZ_IP_ADDRESS];
+      ip_address_snprintf(buf, MAXSZ_IP_ADDRESS,
+                          &rule->override.overlays.v6->local_addr, AF_INET6);
+      DEBUG("          <local_addr>%s</local_addr>", buf);
     }
-    if (rule->override.is_ipv6) {
-        DEBUG("      <ipv6>%d</ipv6>", rule->override.ipv6);
+    if (rule->override.overlays.v6->is_local_port) {
+      DEBUG("          <local_port>%d</local_port>",
+            rule->override.overlays.v6->local_port);
     }
-    DEBUG("      <overlays>");
-    if (rule->override.overlays.v4) {
-        DEBUG("        <ipv4>");
-        if (rule->override.overlays.v4->is_local_addr) {
-            char buf[MAXSZ_IP_ADDRESS];
-            ip_address_snprintf(buf, MAXSZ_IP_ADDRESS,
-                    &rule->override.overlays.v4->local_addr, AF_INET);
-            DEBUG("          <local_addr>%s</local_addr>", buf);
-        }
-        if (rule->override.overlays.v4->is_local_port) {
-            DEBUG("          <local_port>%d</local_port>",
-                    rule->override.overlays.v4->local_port);
-        }
-        if (rule->override.overlays.v4->is_remote_addr) {
-            char buf[MAXSZ_IP_ADDRESS];
-            ip_address_snprintf(buf, MAXSZ_IP_ADDRESS,
-                    &rule->override.overlays.v4->remote_addr, AF_INET);
-            DEBUG("          <remote_addr>%s</remote_addr>", buf);
-        }
-        if (rule->override.overlays.v4->is_remote_port) {
-            DEBUG("          <remote_port>%d</remote_port>",
-                    rule->override.overlays.v4->remote_port);
-        }
-        DEBUG("        </ipv4>");
+    if (rule->override.overlays.v6->is_remote_addr) {
+      char buf[MAXSZ_IP_ADDRESS];
+      ip_address_snprintf(buf, MAXSZ_IP_ADDRESS,
+                          &rule->override.overlays.v6->remote_addr, AF_INET6);
+      DEBUG("          <remote_addr>%s</remote_addr>", buf);
     }
-    if (rule->override.overlays.v6) {
-        DEBUG("        <ipv6>");
-        if (rule->override.overlays.v6->is_local_addr) {
-            char buf[MAXSZ_IP_ADDRESS];
-            ip_address_snprintf(buf, MAXSZ_IP_ADDRESS,
-                    &rule->override.overlays.v6->local_addr, AF_INET6);
-            DEBUG("          <local_addr>%s</local_addr>", buf);
-        }
-        if (rule->override.overlays.v6->is_local_port) {
-            DEBUG("          <local_port>%d</local_port>",
-                    rule->override.overlays.v6->local_port);
-        }
-        if (rule->override.overlays.v6->is_remote_addr) {
-            char buf[MAXSZ_IP_ADDRESS];
-            ip_address_snprintf(buf, MAXSZ_IP_ADDRESS,
-                    &rule->override.overlays.v6->remote_addr, AF_INET6);
-            DEBUG("          <remote_addr>%s</remote_addr>", buf);
-        }
-        if (rule->override.overlays.v6->is_remote_port) {
-            DEBUG("          <remote_port>%d</remote_port>",
-                    rule->override.overlays.v6->remote_port);
-        }
-        DEBUG("        </ipv6>");
+    if (rule->override.overlays.v6->is_remote_port) {
+      DEBUG("          <remote_port>%d</remote_port>",
+            rule->override.overlays.v6->remote_port);
     }
-    DEBUG("      </overlays>");
-    DEBUG("    </override>");
-    DEBUG("  </rule>");
+    DEBUG("        </ipv6>");
+  }
+  DEBUG("      </overlays>");
+  DEBUG("    </override>");
+  DEBUG("  </rule>");
 }
 
-int facemgr_cfg_rule_set_match(facemgr_cfg_rule_t * rule, const char * interface_name,
-        netdevice_type_t interface_type)
-{
-    rule->match.interface_name = interface_name ? strdup(interface_name) : NULL;
-    rule->match.interface_type = interface_type;
-    return 0;
+int facemgr_cfg_rule_set_match(facemgr_cfg_rule_t *rule,
+                               const char *interface_name,
+                               netdevice_type_t interface_type) {
+  rule->match.interface_name = interface_name ? strdup(interface_name) : NULL;
+  rule->match.interface_type = interface_type;
+  return 0;
 }
 
-int facemgr_cfg_rule_set_face_type(facemgr_cfg_rule_t * rule, facemgr_face_type_t * face_type)
-{
-    rule->override.is_face_type = true;
-    rule->override.face_type = *face_type;
-    return 0;
+int facemgr_cfg_rule_set_face_type(facemgr_cfg_rule_t *rule,
+                                   facemgr_face_type_t *face_type) {
+  rule->override.is_face_type = true;
+  rule->override.face_type = *face_type;
+  return 0;
 }
 
-int facemgr_cfg_rule_unset_face_type(facemgr_cfg_rule_t * rule)
-{
-    rule->override.is_face_type = false;
-    rule->override.face_type = FACEMGR_FACE_TYPE_UNDEFINED; /* optional */
-    return 0;
+int facemgr_cfg_rule_unset_face_type(facemgr_cfg_rule_t *rule) {
+  rule->override.is_face_type = false;
+  rule->override.face_type = FACEMGR_FACE_TYPE_UNDEFINED; /* optional */
+  return 0;
 }
 
-int facemgr_cfg_rule_set_discovery(facemgr_cfg_rule_t * rule, bool status)
-{
-    rule->override.is_discovery = true;
-    rule->override.discovery = status;
-    return 0;
+int facemgr_cfg_rule_set_discovery(facemgr_cfg_rule_t *rule, bool status) {
+  rule->override.is_discovery = true;
+  rule->override.discovery = status;
+  return 0;
 }
 
-int facemgr_cfg_rule_unset_discovery(facemgr_cfg_rule_t * rule)
-{
-    rule->override.is_discovery = false;
-    return 0;
+int facemgr_cfg_rule_unset_discovery(facemgr_cfg_rule_t *rule) {
+  rule->override.is_discovery = false;
+  return 0;
 }
 
-int facemgr_cfg_rule_set_ignore(facemgr_cfg_rule_t * rule, bool status)
-{
-    rule->override.is_ignore = true;
-    rule->override.ignore = status;
-    return 0;
+int facemgr_cfg_rule_set_ignore(facemgr_cfg_rule_t *rule, bool status) {
+  rule->override.is_ignore = true;
+  rule->override.ignore = status;
+  return 0;
 }
 
-int facemgr_cfg_rule_unset_ignore(facemgr_cfg_rule_t * rule)
-{
-    rule->override.is_ignore = false;
-    return 0;
+int facemgr_cfg_rule_unset_ignore(facemgr_cfg_rule_t *rule) {
+  rule->override.is_ignore = false;
+  return 0;
 }
 
-int facemgr_cfg_rule_set_ipv4(facemgr_cfg_rule_t * rule, bool status)
-{
-    rule->override.is_ipv4 = true;
-    rule->override.ipv4 = status;
-    return 0;
+int facemgr_cfg_rule_set_ipv4(facemgr_cfg_rule_t *rule, bool status) {
+  rule->override.is_ipv4 = true;
+  rule->override.ipv4 = status;
+  return 0;
 }
 
-int facemgr_cfg_rule_unset_ipv4(facemgr_cfg_rule_t * rule)
-{
-    rule->override.is_ipv4 = false;
-    return 0;
+int facemgr_cfg_rule_unset_ipv4(facemgr_cfg_rule_t *rule) {
+  rule->override.is_ipv4 = false;
+  return 0;
 }
 
-int facemgr_cfg_rule_set_ipv6(facemgr_cfg_rule_t * rule, bool status)
-{
-    rule->override.is_ipv6 = true;
-    rule->override.ipv6 = status;
-    return 0;
+int facemgr_cfg_rule_set_ipv6(facemgr_cfg_rule_t *rule, bool status) {
+  rule->override.is_ipv6 = true;
+  rule->override.ipv6 = status;
+  return 0;
 }
 
-int facemgr_cfg_rule_unset_ipv6(facemgr_cfg_rule_t * rule)
-{
-    rule->override.is_ipv6 = false;
-    return 0;
+int facemgr_cfg_rule_unset_ipv6(facemgr_cfg_rule_t *rule) {
+  rule->override.is_ipv6 = false;
+  return 0;
 }
 
-int facemgr_cfg_rule_set_overlay(facemgr_cfg_rule_t * rule, int family,
-    ip_address_t * local_addr, uint16_t local_port,
-    ip_address_t * remote_addr, uint16_t remote_port) {
-    if ((family != AF_INET) && (family != AF_INET6))
-        return -1;
+int facemgr_cfg_rule_set_overlay(facemgr_cfg_rule_t *rule, int family,
+                                 ip_address_t *local_addr, uint16_t local_port,
+                                 ip_address_t *remote_addr,
+                                 uint16_t remote_port) {
+  if ((family != AF_INET) && (family != AF_INET6)) return -1;
 
-    facemgr_cfg_overlay_t * overlay = facemgr_cfg_overlay_create();
-    if (local_addr) {
-        overlay->is_local_addr = true;
-        overlay->local_addr = *local_addr;
-    }
-    if (IS_VALID_PORT(local_port)) {
-        overlay->is_local_port = true;
-        overlay->local_port = local_port;
-    }
-    if (remote_addr) {
-        overlay->is_remote_addr = true;
-        overlay->remote_addr = *remote_addr;
-    }
-    if (IS_VALID_PORT(remote_port)) {
-        overlay->is_remote_port = true;
-        overlay->remote_port = remote_port;
-    }
+  facemgr_cfg_overlay_t *overlay = facemgr_cfg_overlay_create();
+  if (local_addr) {
+    overlay->is_local_addr = true;
+    overlay->local_addr = *local_addr;
+  }
+  if (IS_VALID_PORT(local_port)) {
+    overlay->is_local_port = true;
+    overlay->local_port = local_port;
+  }
+  if (remote_addr) {
+    overlay->is_remote_addr = true;
+    overlay->remote_addr = *remote_addr;
+  }
+  if (IS_VALID_PORT(remote_port)) {
+    overlay->is_remote_port = true;
+    overlay->remote_port = remote_port;
+  }
 
-    switch(family) {
-        case AF_INET:
-            rule->override.overlays.v4 = overlay;
-            break;
+  switch (family) {
+    case AF_INET:
+      rule->override.overlays.v4 = overlay;
+      break;
 
-        case AF_INET6:
-            rule->override.overlays.v6 = overlay;
-            break;
+    case AF_INET6:
+      rule->override.overlays.v6 = overlay;
+      break;
 
-        default:
-            return -1;
-    }
+    default:
+      return -1;
+  }
 
-    return 0;
+  return 0;
 }
 
-int facemgr_rule_unset_overlay(facemgr_cfg_rule_t * rule, int family)
-{
-    if ((family != AF_INET) && (family != AF_INET6) && (family != AF_UNSPEC))
-        return -1;
+int facemgr_rule_unset_overlay(facemgr_cfg_rule_t *rule, int family) {
+  if ((family != AF_INET) && (family != AF_INET6) && (family != AF_UNSPEC))
+    return -1;
 
-    if ((family == AF_UNSPEC) || (family == AF_INET)) {
-        if (rule->override.overlays.v4) {
-            facemgr_cfg_overlay_free(rule->override.overlays.v4);
-            rule->override.overlays.v4 = NULL;
-        }
-    }
-    if ((family == AF_UNSPEC) || (family == AF_INET6)) {
-        if (rule->override.overlays.v6) {
-            facemgr_cfg_overlay_free(rule->override.overlays.v6);
-            rule->override.overlays.v6 = NULL;
-        }
+  if ((family == AF_UNSPEC) || (family == AF_INET)) {
+    if (rule->override.overlays.v4) {
+      facemgr_cfg_overlay_free(rule->override.overlays.v4);
+      rule->override.overlays.v4 = NULL;
     }
-    return 0;
-}
-
-int facemgr_cfg_rule_cmp(const facemgr_cfg_rule_t * r1, const facemgr_cfg_rule_t * r2)
-{
-    /*
-     * We implement a lexicographic order on the tuple (interface_name,
-     * interface_type)
-     */
-
-    /* We need to handle NULL cases out of strcmp */
-    if (!r1->match.interface_name) {
-        if (r2->match.interface_name)
-            return 1;
-        else
-            goto BOTH_NULL;
-    } else {
-        if (!r2->match.interface_name)
-            return -1;
+  }
+  if ((family == AF_UNSPEC) || (family == AF_INET6)) {
+    if (rule->override.overlays.v6) {
+      facemgr_cfg_overlay_free(rule->override.overlays.v6);
+      rule->override.overlays.v6 = NULL;
     }
-
-
-    /* Only if both are non-NULL, we proceed to strcmp */
-    int rc = strcmp(r1->match.interface_name, r2->match.interface_name);
-    if (rc != 0)
-        return rc;
+  }
+  return 0;
+}
+
+int facemgr_cfg_rule_cmp(const facemgr_cfg_rule_t *r1,
+                         const facemgr_cfg_rule_t *r2) {
+  /*
+   * We implement a lexicographic order on the tuple (interface_name,
+   * interface_type)
+   */
+
+  /* We need to handle NULL cases out of strcmp */
+  if (!r1->match.interface_name) {
+    if (r2->match.interface_name)
+      return 1;
+    else
+      goto BOTH_NULL;
+  } else {
+    if (!r2->match.interface_name) return -1;
+  }
+
+  /* Only if both are non-NULL, we proceed to strcmp */
+  int rc = strcmp(r1->match.interface_name, r2->match.interface_name);
+  if (rc != 0) return rc;
 
 BOTH_NULL:
-    return r1->match.interface_type - r2->match.interface_type;
+  return r1->match.interface_type - r2->match.interface_type;
 }
 
 /* General */
 
 TYPEDEF_SET_H(facemgr_cfg_rule_set, facemgr_cfg_rule_t *);
-TYPEDEF_SET(facemgr_cfg_rule_set, facemgr_cfg_rule_t *, facemgr_cfg_rule_cmp, generic_snprintf);
+TYPEDEF_SET(facemgr_cfg_rule_set, facemgr_cfg_rule_t *, facemgr_cfg_rule_cmp,
+            generic_snprintf);
 
 struct facemgr_cfg_s {
-    facemgr_cfg_override_t global;
-    facemgr_cfg_rule_set_t * rule_set;
-    facelet_array_t * static_facelets;
-    //log_cfg_t log;
+  facemgr_cfg_override_t global;
+  facemgr_cfg_rule_set_t *rule_set;
+  facelet_array_t *static_facelets;
+  // log_cfg_t log;
 };
 
-facemgr_cfg_t * facemgr_cfg_create()
-{
-    facemgr_cfg_t * cfg = malloc(sizeof(facemgr_cfg_t));
-    if (!cfg) {
-        ERROR("[facemgr_cfg_create] Error allocating face manager configuration");
-        goto ERR_MALLOC;
-    }
+facemgr_cfg_t *facemgr_cfg_create() {
+  facemgr_cfg_t *cfg = malloc(sizeof(facemgr_cfg_t));
+  if (!cfg) {
+    ERROR("[facemgr_cfg_create] Error allocating face manager configuration");
+    goto ERR_MALLOC;
+  }
 
-    int rc = facemgr_cfg_initialize(cfg);
-    if (rc < 0) {
-        ERROR("[facemgr_cfg_create] Error initializing face manager configuration");
-        goto ERR_INIT;
-    }
+  int rc = facemgr_cfg_initialize(cfg);
+  if (rc < 0) {
+    ERROR("[facemgr_cfg_create] Error initializing face manager configuration");
+    goto ERR_INIT;
+  }
 
-    return cfg;
+  return cfg;
 
 ERR_INIT:
-        free(cfg);
+  free(cfg);
 ERR_MALLOC:
-    return NULL;
+  return NULL;
 }
 
-void facemgr_cfg_free(facemgr_cfg_t * cfg)
-{
-    facemgr_cfg_finalize(cfg);
-    free(cfg);
+void facemgr_cfg_free(facemgr_cfg_t *cfg) {
+  facemgr_cfg_finalize(cfg);
+  free(cfg);
 }
 
-int facemgr_cfg_initialize(facemgr_cfg_t * cfg)
-{
-    int rc = facemgr_cfg_override_initialize(&cfg->global);
-    if (rc < 0) {
-        ERROR("[facemgr_cfg_initialize] Error initializing global values");
-        goto ERR_OVERRIDE;
-    }
+int facemgr_cfg_initialize(facemgr_cfg_t *cfg) {
+  int rc = facemgr_cfg_override_initialize(&cfg->global);
+  if (rc < 0) {
+    ERROR("[facemgr_cfg_initialize] Error initializing global values");
+    goto ERR_OVERRIDE;
+  }
 
-    cfg->rule_set = facemgr_cfg_rule_set_create();
-    if (!cfg->rule_set) {
-        ERROR("[facemgr_cfg_initialize] Error creating rule set");
-        goto ERR_RULE_SET;
-    }
+  cfg->rule_set = facemgr_cfg_rule_set_create();
+  if (!cfg->rule_set) {
+    ERROR("[facemgr_cfg_initialize] Error creating rule set");
+    goto ERR_RULE_SET;
+  }
 
-    cfg->static_facelets = facelet_array_create(cfg->static_facelets);
-    if (!cfg->static_facelets) {
-        ERROR("[facemgr_cfg_initialize] Error creating static facelet set");
-        goto ERR_STATIC;
-    }
+  cfg->static_facelets = facelet_array_create();
+  if (!cfg->static_facelets) {
+    ERROR("[facemgr_cfg_initialize] Error creating static facelet set");
+    goto ERR_STATIC;
+  }
 
-    return 0;
+  return 0;
 
 ERR_STATIC:
-    facemgr_cfg_rule_set_free(cfg->rule_set);
+  facemgr_cfg_rule_set_free(cfg->rule_set);
 ERR_RULE_SET:
-    facemgr_cfg_override_finalize(&cfg->global);
+  facemgr_cfg_override_finalize(&cfg->global);
 ERR_OVERRIDE:
-    return -1;
-}
-
-int facemgr_cfg_finalize(facemgr_cfg_t * cfg)
-{
-    /* TODO Free all rules */
-    facemgr_cfg_rule_t ** rule_array;
-    int n = facemgr_cfg_rule_set_get_array(cfg->rule_set, &rule_array);
-    if (n < 0) {
-        ERROR("[facemgr_cfg_finalize] Could not retrieve rule set array from configuration");
-    } else {
-        for (unsigned i = 0; i < n; i++) {
-            facemgr_cfg_rule_t * rule = rule_array[i];
-            if (facemgr_cfg_rule_set_remove(cfg->rule_set, rule, NULL) < 0) {
-                ERROR("[facemgr_cfg_finalize] Could not remove rule from set");
-            }
-            facemgr_cfg_rule_free(rule);
-        }
-        free(rule_array);
+  return -1;
+}
+
+int facemgr_cfg_finalize(facemgr_cfg_t *cfg) {
+  /* TODO Free all rules */
+  facemgr_cfg_rule_t **rule_array;
+  int n = facemgr_cfg_rule_set_get_array(cfg->rule_set, &rule_array);
+  if (n < 0) {
+    ERROR(
+        "[facemgr_cfg_finalize] Could not retrieve rule set array from "
+        "configuration");
+  } else {
+    for (unsigned i = 0; i < n; i++) {
+      facemgr_cfg_rule_t *rule = rule_array[i];
+      if (!rule) continue; /* Should not occur */
+      if (facemgr_cfg_rule_set_remove(cfg->rule_set, rule, NULL) < 0) {
+        ERROR("[facemgr_cfg_finalize] Could not remove rule from set");
+      }
+      facemgr_cfg_rule_free(rule);
     }
-    facemgr_cfg_rule_set_free(cfg->rule_set);
-
-    /* Free all facelets from static array */
-    for (unsigned i = 0; i < facelet_array_len(cfg->static_facelets); i++) {
-        facelet_t * facelet;
-        if (facelet_array_get_index(cfg->static_facelets, i, &facelet) < 0) {
-            ERROR("[facemgr_cfg_finalize] Error getting facelet in array");
-            continue;
-        }
-        if (facelet_array_remove_index(cfg->static_facelets, i, NULL)) {
-            ERROR("[facemgr_cfg_finalize] Could not purge facelet from static set");
-        }
-        facelet_free(facelet);
+    free(rule_array);
+  }
+  facemgr_cfg_rule_set_free(cfg->rule_set);
+
+  /* Free all facelets from static array */
+  for (unsigned i = 0; i < facelet_array_len(cfg->static_facelets); i++) {
+    facelet_t *facelet;
+    if (facelet_array_get_index(cfg->static_facelets, i, &facelet) < 0) {
+      ERROR("[facemgr_cfg_finalize] Error getting facelet in array");
+      continue;
     }
+    if (facelet_array_remove_index(cfg->static_facelets, i, NULL)) {
+      ERROR("[facemgr_cfg_finalize] Could not purge facelet from static set");
+    }
+    facelet_free(facelet);
+  }
 
-    facelet_array_free(cfg->static_facelets);
+  facelet_array_free(cfg->static_facelets);
 
-    return facemgr_cfg_override_finalize(&cfg->global);
+  return facemgr_cfg_override_finalize(&cfg->global);
 }
 
-void facemgr_cfg_dump(facemgr_cfg_t * cfg)
-{
-    return; /* NOT IMPLEMENTED */
-}
+void facemgr_cfg_dump(facemgr_cfg_t *cfg) { return; /* NOT IMPLEMENTED */ }
 
 /* General */
-int facemgr_cfg_set_face_type(facemgr_cfg_t * cfg, facemgr_face_type_t * face_type)
-{
-    cfg->global.is_face_type = true;
-    cfg->global.face_type = *face_type;
-    return 0;
-}
-
-int facemgr_cfg_unset_face_type(facemgr_cfg_t * cfg)
-{
-    cfg->global.is_face_type = false;
-    cfg->global.face_type = FACEMGR_FACE_TYPE_UNDEFINED; /* optional */
-    return 0;
-}
-
-int facemgr_cfg_set_discovery(facemgr_cfg_t * cfg, bool status)
-{
-    cfg->global.is_discovery = true;
-    cfg->global.discovery = status;
-    return 0;
-}
-
-int facemgr_cfg_unset_discovery(facemgr_cfg_t * cfg)
-{
-    cfg->global.is_discovery = false;
-    return 0;
-}
-
-int facemgr_cfg_set_ipv4(facemgr_cfg_t * cfg, bool status)
-{
-    cfg->global.is_ipv4 = true;
-    cfg->global.ipv4 = status;
-    DEBUG("<global>");
-    DEBUG("      <ipv4>%d</ipv4>", cfg->global.ipv4);
-    DEBUG("</global>");
-    return 0;
-}
-
-int facemgr_cfg_unset_ipv4(facemgr_cfg_t * cfg)
-{
-    cfg->global.is_ipv4 = false;
-    return 0;
-}
-
-int facemgr_cfg_set_ipv6(facemgr_cfg_t * cfg, bool status)
-{
-    cfg->global.is_ipv6 = true;
-    cfg->global.ipv6 = status;
-    DEBUG("<global>");
-    DEBUG("      <ipv6>%d</ipv6>", cfg->global.ipv6);
-    DEBUG("</global>");
-    return 0;
-}
-
-int facemgr_cfg_unset_ipv6(facemgr_cfg_t * cfg)
-{
-    cfg->global.is_ipv6 = false;
-    return 0;
-}
-
-int facemgr_cfg_set_overlay(facemgr_cfg_t * cfg, int family,
-    ip_address_t * local_addr, uint16_t local_port,
-    ip_address_t * remote_addr, uint16_t remote_port)
-{
-    if ((family != AF_INET) && (family != AF_INET6))
-        return -1;
-
-    facemgr_cfg_overlay_t * overlay = facemgr_cfg_overlay_create();
-    if (local_addr) {
-        overlay->is_local_addr = true;
-        overlay->local_addr = *local_addr;
+int facemgr_cfg_set_face_type(facemgr_cfg_t *cfg,
+                              facemgr_face_type_t *face_type) {
+  cfg->global.is_face_type = true;
+  cfg->global.face_type = *face_type;
+  return 0;
+}
+
+int facemgr_cfg_unset_face_type(facemgr_cfg_t *cfg) {
+  cfg->global.is_face_type = false;
+  cfg->global.face_type = FACEMGR_FACE_TYPE_UNDEFINED; /* optional */
+  return 0;
+}
+
+int facemgr_cfg_set_discovery(facemgr_cfg_t *cfg, bool status) {
+  cfg->global.is_discovery = true;
+  cfg->global.discovery = status;
+  return 0;
+}
+
+int facemgr_cfg_unset_discovery(facemgr_cfg_t *cfg) {
+  cfg->global.is_discovery = false;
+  return 0;
+}
+
+int facemgr_cfg_set_ipv4(facemgr_cfg_t *cfg, bool status) {
+  cfg->global.is_ipv4 = true;
+  cfg->global.ipv4 = status;
+  DEBUG("<global>");
+  DEBUG("      <ipv4>%d</ipv4>", cfg->global.ipv4);
+  DEBUG("</global>");
+  return 0;
+}
+
+int facemgr_cfg_unset_ipv4(facemgr_cfg_t *cfg) {
+  cfg->global.is_ipv4 = false;
+  return 0;
+}
+
+int facemgr_cfg_set_ipv6(facemgr_cfg_t *cfg, bool status) {
+  cfg->global.is_ipv6 = true;
+  cfg->global.ipv6 = status;
+  DEBUG("<global>");
+  DEBUG("      <ipv6>%d</ipv6>", cfg->global.ipv6);
+  DEBUG("</global>");
+  return 0;
+}
+
+int facemgr_cfg_unset_ipv6(facemgr_cfg_t *cfg) {
+  cfg->global.is_ipv6 = false;
+  return 0;
+}
+
+int facemgr_cfg_set_overlay(facemgr_cfg_t *cfg, int family,
+                            ip_address_t *local_addr, uint16_t local_port,
+                            ip_address_t *remote_addr, uint16_t remote_port) {
+  if ((family != AF_INET) && (family != AF_INET6)) return -1;
+
+  facemgr_cfg_overlay_t *overlay = facemgr_cfg_overlay_create();
+  if (local_addr) {
+    overlay->is_local_addr = true;
+    overlay->local_addr = *local_addr;
+  }
+  if (IS_VALID_PORT(local_port)) {
+    overlay->is_local_port = true;
+    overlay->local_port = local_port;
+  }
+  if (remote_addr) {
+    overlay->is_remote_addr = true;
+    overlay->remote_addr = *remote_addr;
+  }
+  if (IS_VALID_PORT(remote_port)) {
+    overlay->is_remote_port = true;
+    overlay->remote_port = remote_port;
+  }
+
+  DEBUG("facemgr_cfg_set_overlay");
+
+  switch (family) {
+    case AF_INET:
+      cfg->global.overlays.v4 = overlay;
+      break;
+
+    case AF_INET6:
+      cfg->global.overlays.v6 = overlay;
+      break;
+
+    default:
+      return -1;
+  }
+
+  DEBUG("<global>");
+  DEBUG("  <overlay>");
+  if (overlay) {
+    DEBUG("    <ipv4>");
+    if (overlay->is_local_addr) {
+      char buf[MAXSZ_IP_ADDRESS];
+      ip_address_snprintf(buf, MAXSZ_IP_ADDRESS, &overlay->local_addr, AF_INET);
+      DEBUG("      <local_addr>%s</local_addr>", buf);
     }
-    if (IS_VALID_PORT(local_port)) {
-        overlay->is_local_port = true;
-        overlay->local_port = local_port;
+    if (overlay->is_local_port) {
+      DEBUG("      <local_port>%d</local_port>", overlay->local_port);
     }
-    if (remote_addr) {
-        overlay->is_remote_addr = true;
-        overlay->remote_addr = *remote_addr;
-    }
-    if (IS_VALID_PORT(remote_port)) {
-        overlay->is_remote_port = true;
-        overlay->remote_port = remote_port;
-    }
-
-    DEBUG("facemgr_cfg_set_overlay");
-
-    switch(family) {
-        case AF_INET:
-            cfg->global.overlays.v4 = overlay;
-            break;
-
-        case AF_INET6:
-            cfg->global.overlays.v6 = overlay;
-            break;
-
-        default:
-            return -1;
+    if (overlay->is_remote_addr) {
+      char buf[MAXSZ_IP_ADDRESS];
+      ip_address_snprintf(buf, MAXSZ_IP_ADDRESS, &overlay->remote_addr,
+                          AF_INET);
+      DEBUG("      <remote_addr>%s</remote_addr>", buf);
     }
-
-    DEBUG("<global>");
-    DEBUG("  <overlay>");
-    if (overlay) {
-        DEBUG("    <ipv4>");
-        if (overlay->is_local_addr) {
-            char buf[MAXSZ_IP_ADDRESS];
-            ip_address_snprintf(buf, MAXSZ_IP_ADDRESS,
-                    &overlay->local_addr, AF_INET);
-            DEBUG("      <local_addr>%s</local_addr>", buf);
-        }
-        if (overlay->is_local_port) {
-            DEBUG("      <local_port>%d</local_port>",
-                    overlay->local_port);
-        }
-        if (overlay->is_remote_addr) {
-            char buf[MAXSZ_IP_ADDRESS];
-            ip_address_snprintf(buf, MAXSZ_IP_ADDRESS,
-                    &overlay->remote_addr, AF_INET);
-            DEBUG("      <remote_addr>%s</remote_addr>", buf);
-        }
-        if (overlay->is_remote_port) {
-            DEBUG("      <remote_port>%d</remote_port>",
-                    overlay->remote_port);
-        }
-        DEBUG("    </ipv4>");
+    if (overlay->is_remote_port) {
+      DEBUG("      <remote_port>%d</remote_port>", overlay->remote_port);
     }
-    DEBUG("  </overlay>");
-    DEBUG("</global>");
+    DEBUG("    </ipv4>");
+  }
+  DEBUG("  </overlay>");
+  DEBUG("</global>");
 
-    return 0;
+  return 0;
 }
 
-int facemgr_cfg_unset_overlay(facemgr_cfg_t * cfg, int family)
-{
-    if ((family != AF_INET) && (family != AF_INET6) && (family != AF_UNSPEC))
-        return -1;
+int facemgr_cfg_unset_overlay(facemgr_cfg_t *cfg, int family) {
+  if ((family != AF_INET) && (family != AF_INET6) && (family != AF_UNSPEC))
+    return -1;
 
-    if ((family == AF_UNSPEC) || (family == AF_INET)) {
-        if (cfg->global.overlays.v4) {
-            facemgr_cfg_overlay_free(cfg->global.overlays.v4);
-            cfg->global.overlays.v4 = NULL;
-        }
+  if ((family == AF_UNSPEC) || (family == AF_INET)) {
+    if (cfg->global.overlays.v4) {
+      facemgr_cfg_overlay_free(cfg->global.overlays.v4);
+      cfg->global.overlays.v4 = NULL;
     }
-    if ((family == AF_UNSPEC) || (family == AF_INET6)) {
-        if (cfg->global.overlays.v6) {
-            facemgr_cfg_overlay_free(cfg->global.overlays.v6);
-            cfg->global.overlays.v6 = NULL;
-        }
+  }
+  if ((family == AF_UNSPEC) || (family == AF_INET6)) {
+    if (cfg->global.overlays.v6) {
+      facemgr_cfg_overlay_free(cfg->global.overlays.v6);
+      cfg->global.overlays.v6 = NULL;
     }
-    return 0;
+  }
+  return 0;
 }
 
-int facemgr_cfg_add_rule(facemgr_cfg_t * cfg, facemgr_cfg_rule_t * rule)
-{
-    facemgr_cfg_rule_dump(rule);
-    return facemgr_cfg_rule_set_add(cfg->rule_set, rule);
+int facemgr_cfg_add_rule(facemgr_cfg_t *cfg, facemgr_cfg_rule_t *rule) {
+  facemgr_cfg_rule_dump(rule);
+  return facemgr_cfg_rule_set_add(cfg->rule_set, rule);
 }
 
-int facemgr_cfg_del_rule(facemgr_cfg_t * cfg, facemgr_cfg_rule_t * rule)
-{
-    return facemgr_cfg_rule_set_remove(cfg->rule_set, rule, NULL);
+int facemgr_cfg_del_rule(facemgr_cfg_t *cfg, facemgr_cfg_rule_t *rule) {
+  return facemgr_cfg_rule_set_remove(cfg->rule_set, rule, NULL);
 }
 
-int facemgr_cfg_get_rule(const facemgr_cfg_t * cfg, const char * interface_name,
-        netdevice_type_t interface_type, facemgr_cfg_rule_t ** rule) {
-    facemgr_cfg_rule_t rule_search = {
-        .match = {
-            .interface_name = interface_name,
-            .interface_type = interface_type,
-        },
-    };
-    return facemgr_cfg_rule_set_get(cfg->rule_set, &rule_search, rule);
+int facemgr_cfg_get_rule(const facemgr_cfg_t *cfg, const char *interface_name,
+                         netdevice_type_t interface_type,
+                         facemgr_cfg_rule_t **rule) {
+  facemgr_cfg_rule_t rule_search = {
+      .match =
+          {
+              .interface_name = interface_name,
+              .interface_type = interface_type,
+          },
+  };
+  return facemgr_cfg_rule_set_get(cfg->rule_set, &rule_search, rule);
 }
 
 /* Query API */
@@ -709,506 +661,476 @@ int facemgr_cfg_get_rule(const facemgr_cfg_t * cfg, const char * interface_name,
  * TODO:
  *  - until we have proper indexes we loop through the whole structure
  */
-int facemgr_cfg_get_override(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        facemgr_cfg_override_t ** override)
-{
-    if (!netdevice) {
-        *override = NULL;
-        return 0;
-    }
-
-    facemgr_cfg_rule_t **rule_array;
-    int rc = facemgr_cfg_rule_set_get_array(cfg->rule_set, &rule_array);
-    if (rc < 0) {
-        ERROR("facemgr_cfg_rule_set_get_array failed");
-        return rc;
-    }
-    for (unsigned i = 0; i < rc; i++) {
-        const char * interface_name = rule_array[i]->match.interface_name;
-        /* Check match for interface name */
-        if (interface_name && (strcmp(interface_name, netdevice->name) != 0))
-            continue;
-        /* Check match for interface type */
-        if (rule_array[i]->match.interface_type != NETDEVICE_TYPE_UNDEFINED) {
-//#ifdef __ANDROID__
-            if (netdevice_type != rule_array[i]->match.interface_type)
-                continue;
-//#else
-//            ERROR("Match on interface type is currently not implemented");
-//            goto ERR_ARRAY;
-//#endif /* __ANDROID__ */
-        }
-        /* Found match... do we have an override for face_type */
-        *override = &rule_array[i]->override;
-        goto FOUND;
-    }
-
+int facemgr_cfg_get_override(const facemgr_cfg_t *cfg,
+                             const netdevice_t *netdevice,
+                             netdevice_type_t netdevice_type,
+                             facemgr_cfg_override_t **override) {
+  if (!netdevice) {
     *override = NULL;
-
-FOUND:
-    free(rule_array);
     return 0;
-
-//#ifndef __ANDROID__
-//ERR_ARRAY:
-//    free(rule_array);
-//    return -1;
-//#endif /* __ANDROID__ */
-}
-
-int facemgr_cfg_get_face_type(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        facemgr_face_type_t * face_type)
-{
-    facemgr_cfg_override_t * override;
-    int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type,
-            &override);
-    if (rc < 0) {
-        ERROR("get override failed");
-        return rc;
+  }
+
+  facemgr_cfg_rule_t **rule_array;
+  int rc = facemgr_cfg_rule_set_get_array(cfg->rule_set, &rule_array);
+  if (rc < 0) {
+    ERROR("facemgr_cfg_rule_set_get_array failed");
+    return rc;
+  }
+  for (unsigned i = 0; i < rc; i++) {
+    facemgr_cfg_rule_t *rule = rule_array[i];
+    if (!rule) continue; /* Should not occur */
+    const char *interface_name = rule->match.interface_name;
+    /* Check match for interface name */
+    if (interface_name && (strcmp(interface_name, netdevice->name) != 0))
+      continue;
+    /* Check match for interface type */
+    if (rule->match.interface_type != NETDEVICE_TYPE_UNDEFINED) {
+      //#ifdef __ANDROID__
+      if (netdevice_type != rule->match.interface_type) continue;
+      //#else
+      //            ERROR("Match on interface type is currently not
+      //            implemented"); goto ERR_ARRAY;
+      //#endif /* __ANDROID__ */
     }
+    /* Found match... do we have an override for face_type */
+    *override = &rule->override;
+    goto FOUND;
+  }
 
-    if ((override) && (override->is_face_type)) {
-        *face_type = override->face_type;
-        return 0;
-    }
-
-    *face_type = cfg->global.is_face_type
-        ? cfg->global.face_type
-        : FACEMGR_FACE_TYPE_DEFAULT;
-
-    return 0;
-}
-
-int facemgr_cfg_get_discovery(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        bool * discovery)
-{
-    facemgr_cfg_override_t * override;
-    int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type,
-            &override);
-    if (rc < 0)
-        return rc;
-
-    if ((override) && (override->is_discovery)) {
-        *discovery = override->discovery;
-        return 0;
-    }
-
-    *discovery = cfg->global.is_discovery
-        ? cfg->global.discovery
-        : FACEMGR_CFG_DEFAULT_DISCOVERY;
-    return 0;
-}
-
-int facemgr_cfg_get_ipv4(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        bool * ipv4)
-{
-    facemgr_cfg_override_t * override;
-    int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type,
-            &override);
-    if (rc < 0)
-        return rc;
+  *override = NULL;
 
-    if ((override) && (override->is_ipv4)) {
-        *ipv4 = override->ipv4;
-        return 0;
-    }
-
-    *ipv4 = cfg->global.is_ipv4
-        ? cfg->global.ipv4
-        : FACEMGR_CFG_DEFAULT_IPV4;
-    return 0;
-}
-
-int facemgr_cfg_get_ipv6(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        bool * ipv6)
-{
-    facemgr_cfg_override_t * override;
-    int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type,
-            &override);
-    if (rc < 0)
-        return rc;
-
-    if ((override) && (override->is_ipv6)) {
-        *ipv6 = override->ipv6;
-        return 0;
-    }
-
-    *ipv6 = cfg->global.is_ipv6
-        ? cfg->global.ipv6
-        : FACEMGR_CFG_DEFAULT_IPV6;
+FOUND:
+  free(rule_array);
+  return 0;
+
+  //#ifndef __ANDROID__
+  // ERR_ARRAY:
+  //    free(rule_array);
+  //    return -1;
+  //#endif /* __ANDROID__ */
+}
+
+int facemgr_cfg_get_face_type(const facemgr_cfg_t *cfg,
+                              const netdevice_t *netdevice,
+                              netdevice_type_t netdevice_type,
+                              facemgr_face_type_t *face_type) {
+  facemgr_cfg_override_t *override;
+  int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type, &override);
+  if (rc < 0) {
+    ERROR("get override failed");
+    return rc;
+  }
+
+  if ((override) && (override->is_face_type)) {
+    *face_type = override->face_type;
     return 0;
-}
+  }
 
-int facemgr_cfg_get_ignore(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        bool * ignore)
-{
-    facemgr_cfg_override_t * override;
-    int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type,
-            &override);
-    if (rc < 0)
-        return rc;
+  *face_type = cfg->global.is_face_type ? cfg->global.face_type
+                                        : FACEMGR_FACE_TYPE_DEFAULT;
 
-    if ((override) && (override->is_ignore)) {
-        *ignore = override->ignore;
-        return 0;
-    }
-
-    assert (!cfg->global.is_ignore);
-
-    *ignore = (netdevice && (netdevice->name[0] != '\0') && strcmp(netdevice->name, "lo") == 0);
-
-    return 0;
+  return 0;
 }
 
-int facemgr_cfg_get_overlay_local_addr(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        int family, ip_address_t * addr)
-{
-    facemgr_cfg_override_t * override;
-    int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type,
-            &override);
-    if (rc < 0)
-        return rc;
-
-    switch (family) {
-        case AF_INET:
-            if ((override) && (override->overlays.v4) && (override->overlays.v4->is_local_addr)) {
-                *addr = override->overlays.v4->local_addr;
-                return 0;
-            }
-            if ((cfg->global.overlays.v4) && (cfg->global.overlays.v4->is_local_addr)) {
-                *addr = cfg->global.overlays.v4->local_addr;
-                return 0;
-            }
-            break;
-        case AF_INET6:
-            if ((override) && (override->overlays.v6) && (override->overlays.v6->is_local_addr)) {
-                *addr = override->overlays.v6->local_addr;
-                return 0;
-            }
-            if ((cfg->global.overlays.v6) && (cfg->global.overlays.v6->is_local_addr)) {
-                *addr = cfg->global.overlays.v6->local_addr;
-                return 0;
-            }
-            break;
-        case AF_UNSPEC:
-            break;
-        default:
-            return -1;
-    }
+int facemgr_cfg_get_discovery(const facemgr_cfg_t *cfg,
+                              const netdevice_t *netdevice,
+                              netdevice_type_t netdevice_type,
+                              bool *discovery) {
+  facemgr_cfg_override_t *override;
+  int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type, &override);
+  if (rc < 0) return rc;
 
-    *addr = IP_ADDRESS_EMPTY;
+  if ((override) && (override->is_discovery)) {
+    *discovery = override->discovery;
     return 0;
-}
-
-int facemgr_cfg_get_overlay_local_port(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        int family, u16 * port)
-{
-    facemgr_cfg_override_t * override;
-    int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type,
-            &override);
-    if (rc < 0)
-        return rc;
-
-    switch (family) {
-        case AF_INET:
-            if ((override) && (override->overlays.v4) && (override->overlays.v4->is_local_port)) {
-                *port = override->overlays.v4->local_port;
-                return 0;
-            }
-            if ((cfg->global.overlays.v4) && (cfg->global.overlays.v4->is_local_port)) {
-                *port = cfg->global.overlays.v4->local_port;
-                return 0;
-            }
-            break;
-        case AF_INET6:
-            if ((override) && (override->overlays.v6) && (override->overlays.v6->is_local_port)) {
-                *port = override->overlays.v6->local_port;
-                return 0;
-            }
-            if ((cfg->global.overlays.v6) && (cfg->global.overlays.v6->is_local_port)) {
-                *port = cfg->global.overlays.v6->local_port;
-                return 0;
-            }
-            break;
-        case AF_UNSPEC:
-            break;
-        default:
-            return -1;
-    }
+  }
 
-    *port = HICN_DEFAULT_PORT;
-    return 0;
+  *discovery = cfg->global.is_discovery ? cfg->global.discovery
+                                        : FACEMGR_CFG_DEFAULT_DISCOVERY;
+  return 0;
 }
 
-int facemgr_cfg_get_overlay_remote_addr(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        int family, ip_address_t * addr)
-{
-    facemgr_cfg_override_t * override;
-    int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type,
-            &override);
-    if (rc < 0)
-        return rc;
-
-    switch (family) {
-        case AF_INET:
-            if ((override) && (override->overlays.v4) && (override->overlays.v4->is_remote_addr)) {
-                DEBUG("remote addr v4 from override");
-                *addr = override->overlays.v4->remote_addr;
-                return 0;
-            }
-            if ((cfg->global.overlays.v4) && (cfg->global.overlays.v4->is_remote_addr)) {
-                DEBUG("remote addr v4 from global");
-                *addr = cfg->global.overlays.v4->remote_addr;
-                return 0;
-            }
-            break;
-        case AF_INET6:
-            if ((override) && (override->overlays.v6) && (override->overlays.v6->is_remote_addr)) {
-                DEBUG("remote addr v6 from override");
-                *addr = override->overlays.v6->remote_addr;
-                return 0;
-            }
-            if ((cfg->global.overlays.v6) && (cfg->global.overlays.v6->is_remote_addr)) {
-                DEBUG("remote addr v6 from global");
-                *addr = cfg->global.overlays.v6->remote_addr;
-                return 0;
-            }
-            break;
-        case AF_UNSPEC:
-            break;
-        default:
-            return -1;
-    }
+int facemgr_cfg_get_ipv4(const facemgr_cfg_t *cfg, const netdevice_t *netdevice,
+                         netdevice_type_t netdevice_type, bool *ipv4) {
+  facemgr_cfg_override_t *override;
+  int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type, &override);
+  if (rc < 0) return rc;
 
-    DEBUG("remote addr empty");
-    *addr = IP_ADDRESS_EMPTY;
+  if ((override) && (override->is_ipv4)) {
+    *ipv4 = override->ipv4;
     return 0;
-}
-
-int facemgr_cfg_get_overlay_remote_port(const facemgr_cfg_t * cfg,
-        const netdevice_t * netdevice, netdevice_type_t netdevice_type,
-        int family, u16 * port)
-{
-    facemgr_cfg_override_t * override;
-    int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type,
-            &override);
-    if (rc < 0)
-        return rc;
-
-    switch (family) {
-        case AF_INET:
-            if ((override) && (override->overlays.v4) && (override->overlays.v4->is_remote_port)) {
-                *port = override->overlays.v4->remote_port;
-                return 0;
-            }
-            if ((cfg->global.overlays.v4) && (cfg->global.overlays.v4->is_remote_port)) {
-                *port = cfg->global.overlays.v4->remote_port;
-                return 0;
-            }
-            break;
-        case AF_INET6:
-            if ((override) && (override->overlays.v6) && (override->overlays.v6->is_remote_port)) {
-                *port = override->overlays.v6->remote_port;
-                return 0;
-            }
-            if ((cfg->global.overlays.v6) && (cfg->global.overlays.v6->is_remote_port)) {
-                *port = cfg->global.overlays.v6->remote_port;
-                return 0;
-            }
-            break;
-        case AF_UNSPEC:
-            break;
-        default:
-            return -1;
-    }
+  }
 
-    *port = HICN_DEFAULT_PORT;
-    return 0;
+  *ipv4 = cfg->global.is_ipv4 ? cfg->global.ipv4 : FACEMGR_CFG_DEFAULT_IPV4;
+  return 0;
 }
 
-int facemgr_cfg_rule_get(const facemgr_cfg_t * cfg, const netdevice_t netdevice, netdevice_type_t
-        netdevice_type, facemgr_cfg_rule_t ** rule)
-{
-    facemgr_cfg_rule_t **rule_array;
-    *rule = NULL;
-    int n = facemgr_cfg_rule_set_get_array(cfg->rule_set, &rule_array);
-    if (n < 0) {
-        ERROR("facemgr_cfg_rule_set_get_array failed");
-        return n;
-    }
-    for (unsigned i = 0; i < n; i++) {
-        const char * interface_name = rule_array[i]->match.interface_name;
-        /* Check match for interface name */
-        if (netdevice.name[0] != '\0') {
-            if (!interface_name)
-                continue;
-            if (strcmp(netdevice.name, interface_name) != 0)
-                continue;
-        } else {
-            if (interface_name && interface_name[0] != '\0')
-                continue;
-        }
-
-        /* Check match for netdevice_type */
-        if (netdevice_type != rule_array[i]->match.interface_type)
-            continue;
-
-        /* Found */
-        *rule = rule_array[i];
-        break;
-    }
-    return 0;
-}
+int facemgr_cfg_get_ipv6(const facemgr_cfg_t *cfg, const netdevice_t *netdevice,
+                         netdevice_type_t netdevice_type, bool *ipv6) {
+  facemgr_cfg_override_t *override;
+  int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type, &override);
+  if (rc < 0) return rc;
 
-int facemgr_cfg_rule_get_face_type(const facemgr_cfg_rule_t * rule,
-        facemgr_face_type_t * face_type)
-{
-    if (!rule->override.is_face_type)
-        return -1;
-    *face_type = rule->override.face_type;
+  if ((override) && (override->is_ipv6)) {
+    *ipv6 = override->ipv6;
     return 0;
-}
+  }
 
-int facemgr_cfg_rule_get_discovery(const facemgr_cfg_rule_t * rule, bool * discovery)
-{
-    if (!rule->override.is_discovery)
-        return -1;
-    *discovery = rule->override.discovery;
-    return 0;
+  *ipv6 = cfg->global.is_ipv6 ? cfg->global.ipv6 : FACEMGR_CFG_DEFAULT_IPV6;
+  return 0;
 }
 
-int facemgr_cfg_rule_get_ignore(const facemgr_cfg_rule_t * rule, bool * ignore)
-{
-    if (!rule->override.is_ignore)
-        return -1;
-    *ignore = rule->override.ignore;
-    return 0;
-}
+int facemgr_cfg_get_ignore(const facemgr_cfg_t *cfg,
+                           const netdevice_t *netdevice,
+                           netdevice_type_t netdevice_type, bool *ignore) {
+  facemgr_cfg_override_t *override;
+  int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type, &override);
+  if (rc < 0) return rc;
 
-int facemgr_cfg_rule_get_ipv4(const facemgr_cfg_rule_t * rule, bool * ipv4)
-{
-    if (!rule->override.is_ipv4)
-        return -1;
-    *ipv4 = rule->override.ipv4;
+  if ((override) && (override->is_ignore)) {
+    *ignore = override->ignore;
     return 0;
-}
+  }
 
-int facemgr_cfg_rule_get_ipv6(const facemgr_cfg_rule_t * rule, bool * ipv6)
-{
-    if (!rule->override.is_ipv6)
-        return -1;
-    *ipv6 = rule->override.ipv6;
-    return 0;
-}
+  assert(!cfg->global.is_ignore);
 
-int facemgr_cfg_rule_get_overlay_local_addr(const facemgr_cfg_rule_t * rule, int family,
-        ip_address_t * addr)
-{
-    facemgr_cfg_overlay_t * overlay = NULL;
-    switch(family) {
-        case AF_INET:
-            overlay = rule->override.overlays.v4;
-            break;
-        case AF_INET6:
-            overlay = rule->override.overlays.v6;
-            break;
-        default:
-            return -1;
-    }
-    if (!overlay->is_local_addr)
-        return -1;
-    *addr = overlay->local_addr;
-    return 0;
-}
+  *ignore = (netdevice && (netdevice->name[0] != '\0') &&
+             strcmp(netdevice->name, "lo") == 0);
 
-int facemgr_cfg_rule_get_overlay_local_port(const facemgr_cfg_rule_t * rule, int family,
-        uint16_t * port)
-{
-    facemgr_cfg_overlay_t * overlay = NULL;
-    switch(family) {
-        case AF_INET:
-            overlay = rule->override.overlays.v4;
-            break;
-        case AF_INET6:
-            overlay = rule->override.overlays.v6;
-            break;
-        default:
-            return -1;
-    }
-    if (!overlay->is_local_port)
-        return -1;
-    *port = overlay->local_port;
-    return 0;
+  return 0;
 }
 
-int facemgr_cfg_rule_get_overlay_remote_addr(const facemgr_cfg_rule_t * rule, int family,
-        ip_address_t * addr)
-{
-    facemgr_cfg_overlay_t * overlay = NULL;
-    switch(family) {
-        case AF_INET:
-            overlay = rule->override.overlays.v4;
-            break;
-        case AF_INET6:
-            overlay = rule->override.overlays.v6;
-            break;
-        default:
-            return -1;
-    }
-    if (!overlay->is_remote_addr)
-        return -1;
-    *addr = overlay->remote_addr;
-    return 0;
-}
+int facemgr_cfg_get_overlay_local_addr(const facemgr_cfg_t *cfg,
+                                       const netdevice_t *netdevice,
+                                       netdevice_type_t netdevice_type,
+                                       int family, ip_address_t *addr) {
+  facemgr_cfg_override_t *override;
+  int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type, &override);
+  if (rc < 0) return rc;
 
-int facemgr_cfg_rule_get_overlay_remote_port(const facemgr_cfg_rule_t * rule, int family,
-        uint16_t * port)
-{
-    facemgr_cfg_overlay_t * overlay = NULL;
-    switch(family) {
-        case AF_INET:
-            overlay = rule->override.overlays.v4;
-            break;
-        case AF_INET6:
-            overlay = rule->override.overlays.v6;
-            break;
-        default:
-            return -1;
+  switch (family) {
+    case AF_INET:
+      if ((override) && (override->overlays.v4) &&
+          (override->overlays.v4->is_local_addr)) {
+        *addr = override->overlays.v4->local_addr;
+        return 0;
+      }
+      if ((cfg->global.overlays.v4) &&
+          (cfg->global.overlays.v4->is_local_addr)) {
+        *addr = cfg->global.overlays.v4->local_addr;
+        return 0;
+      }
+      break;
+    case AF_INET6:
+      if ((override) && (override->overlays.v6) &&
+          (override->overlays.v6->is_local_addr)) {
+        *addr = override->overlays.v6->local_addr;
+        return 0;
+      }
+      if ((cfg->global.overlays.v6) &&
+          (cfg->global.overlays.v6->is_local_addr)) {
+        *addr = cfg->global.overlays.v6->local_addr;
+        return 0;
+      }
+      break;
+    case AF_UNSPEC:
+      break;
+    default:
+      return -1;
+  }
+
+  *addr = IP_ADDRESS_EMPTY;
+  return 0;
+}
+
+int facemgr_cfg_get_overlay_local_port(const facemgr_cfg_t *cfg,
+                                       const netdevice_t *netdevice,
+                                       netdevice_type_t netdevice_type,
+                                       int family, u16 *port) {
+  facemgr_cfg_override_t *override;
+  int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type, &override);
+  if (rc < 0) return rc;
+
+  switch (family) {
+    case AF_INET:
+      if ((override) && (override->overlays.v4) &&
+          (override->overlays.v4->is_local_port)) {
+        *port = override->overlays.v4->local_port;
+        return 0;
+      }
+      if ((cfg->global.overlays.v4) &&
+          (cfg->global.overlays.v4->is_local_port)) {
+        *port = cfg->global.overlays.v4->local_port;
+        return 0;
+      }
+      break;
+    case AF_INET6:
+      if ((override) && (override->overlays.v6) &&
+          (override->overlays.v6->is_local_port)) {
+        *port = override->overlays.v6->local_port;
+        return 0;
+      }
+      if ((cfg->global.overlays.v6) &&
+          (cfg->global.overlays.v6->is_local_port)) {
+        *port = cfg->global.overlays.v6->local_port;
+        return 0;
+      }
+      break;
+    case AF_UNSPEC:
+      break;
+    default:
+      return -1;
+  }
+
+  *port = HICN_DEFAULT_PORT;
+  return 0;
+}
+
+int facemgr_cfg_get_overlay_remote_addr(const facemgr_cfg_t *cfg,
+                                        const netdevice_t *netdevice,
+                                        netdevice_type_t netdevice_type,
+                                        int family, ip_address_t *addr) {
+  facemgr_cfg_override_t *override;
+  int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type, &override);
+  if (rc < 0) return rc;
+
+  switch (family) {
+    case AF_INET:
+      if ((override) && (override->overlays.v4) &&
+          (override->overlays.v4->is_remote_addr)) {
+        DEBUG("remote addr v4 from override");
+        *addr = override->overlays.v4->remote_addr;
+        return 0;
+      }
+      if ((cfg->global.overlays.v4) &&
+          (cfg->global.overlays.v4->is_remote_addr)) {
+        DEBUG("remote addr v4 from global");
+        *addr = cfg->global.overlays.v4->remote_addr;
+        return 0;
+      }
+      break;
+    case AF_INET6:
+      if ((override) && (override->overlays.v6) &&
+          (override->overlays.v6->is_remote_addr)) {
+        DEBUG("remote addr v6 from override");
+        *addr = override->overlays.v6->remote_addr;
+        return 0;
+      }
+      if ((cfg->global.overlays.v6) &&
+          (cfg->global.overlays.v6->is_remote_addr)) {
+        DEBUG("remote addr v6 from global");
+        *addr = cfg->global.overlays.v6->remote_addr;
+        return 0;
+      }
+      break;
+    case AF_UNSPEC:
+      break;
+    default:
+      return -1;
+  }
+
+  DEBUG("remote addr empty");
+  *addr = IP_ADDRESS_EMPTY;
+  return 0;
+}
+
+int facemgr_cfg_get_overlay_remote_port(const facemgr_cfg_t *cfg,
+                                        const netdevice_t *netdevice,
+                                        netdevice_type_t netdevice_type,
+                                        int family, u16 *port) {
+  facemgr_cfg_override_t *override;
+  int rc = facemgr_cfg_get_override(cfg, netdevice, netdevice_type, &override);
+  if (rc < 0) return rc;
+
+  switch (family) {
+    case AF_INET:
+      if ((override) && (override->overlays.v4) &&
+          (override->overlays.v4->is_remote_port)) {
+        *port = override->overlays.v4->remote_port;
+        return 0;
+      }
+      if ((cfg->global.overlays.v4) &&
+          (cfg->global.overlays.v4->is_remote_port)) {
+        *port = cfg->global.overlays.v4->remote_port;
+        return 0;
+      }
+      break;
+    case AF_INET6:
+      if ((override) && (override->overlays.v6) &&
+          (override->overlays.v6->is_remote_port)) {
+        *port = override->overlays.v6->remote_port;
+        return 0;
+      }
+      if ((cfg->global.overlays.v6) &&
+          (cfg->global.overlays.v6->is_remote_port)) {
+        *port = cfg->global.overlays.v6->remote_port;
+        return 0;
+      }
+      break;
+    case AF_UNSPEC:
+      break;
+    default:
+      return -1;
+  }
+
+  *port = HICN_DEFAULT_PORT;
+  return 0;
+}
+
+int facemgr_cfg_rule_get(const facemgr_cfg_t *cfg, const netdevice_t netdevice,
+                         netdevice_type_t netdevice_type,
+                         facemgr_cfg_rule_t **rule_p) {
+  facemgr_cfg_rule_t **rule_array;
+  *rule_p = NULL;
+  int n = facemgr_cfg_rule_set_get_array(cfg->rule_set, &rule_array);
+  if (n < 0) {
+    ERROR("facemgr_cfg_rule_set_get_array failed");
+    return n;
+  }
+  for (unsigned i = 0; i < n; i++) {
+    facemgr_cfg_rule_t *rule = rule_array[i];
+    if (!rule) continue; /* Should not occur */
+    const char *interface_name = rule->match.interface_name;
+    /* Check match for interface name */
+    if (netdevice.name[0] != '\0') {
+      if (!interface_name) continue;
+      if (strcmp(netdevice.name, interface_name) != 0) continue;
+    } else {
+      if (interface_name && interface_name[0] != '\0') continue;
     }
-    if (!overlay->is_remote_port)
-        return -1;
-    *port = overlay->remote_port;
-    return 0;
-}
 
-int facemgr_cfg_add_static_facelet(facemgr_cfg_t * cfg, facelet_t * facelet)
-{
-    char buf[MAXSZ_FACELET];
-    facelet_snprintf(buf, MAXSZ_FACELET, facelet);
-    DEBUG("STATIC FACELET: %s", buf);
-    return facelet_array_add(cfg->static_facelets, facelet);
-}
-
-int facemgr_cfg_remove_static_facelet(facemgr_cfg_t * cfg, facelet_t * facelet,
-        facelet_t ** removed_facelet)
-{
-    return facelet_array_remove(cfg->static_facelets, facelet, removed_facelet);
-}
-
-int facemgr_cfg_get_static_facelet_array(const facemgr_cfg_t * cfg, facelet_t *** array)
-{
-    if (facelet_array_get_elements(cfg->static_facelets, array) < 0) {
-        ERROR("[facemgr_cfg_get_static_facelet_array] Error getting array elements");
-        return -1;
-    }
-    return (int)facelet_array_len(cfg->static_facelets);
+    /* Check match for netdevice_type */
+    if (netdevice_type != rule->match.interface_type) continue;
+
+    /* Found */
+    *rule_p = rule;
+    break;
+  }
+  return 0;
+}
+
+int facemgr_cfg_rule_get_face_type(const facemgr_cfg_rule_t *rule,
+                                   facemgr_face_type_t *face_type) {
+  if (!rule->override.is_face_type) return -1;
+  *face_type = rule->override.face_type;
+  return 0;
+}
+
+int facemgr_cfg_rule_get_discovery(const facemgr_cfg_rule_t *rule,
+                                   bool *discovery) {
+  if (!rule->override.is_discovery) return -1;
+  *discovery = rule->override.discovery;
+  return 0;
+}
+
+int facemgr_cfg_rule_get_ignore(const facemgr_cfg_rule_t *rule, bool *ignore) {
+  if (!rule->override.is_ignore) return -1;
+  *ignore = rule->override.ignore;
+  return 0;
+}
+
+int facemgr_cfg_rule_get_ipv4(const facemgr_cfg_rule_t *rule, bool *ipv4) {
+  if (!rule->override.is_ipv4) return -1;
+  *ipv4 = rule->override.ipv4;
+  return 0;
+}
+
+int facemgr_cfg_rule_get_ipv6(const facemgr_cfg_rule_t *rule, bool *ipv6) {
+  if (!rule->override.is_ipv6) return -1;
+  *ipv6 = rule->override.ipv6;
+  return 0;
+}
+
+int facemgr_cfg_rule_get_overlay_local_addr(const facemgr_cfg_rule_t *rule,
+                                            int family, ip_address_t *addr) {
+  facemgr_cfg_overlay_t *overlay = NULL;
+  switch (family) {
+    case AF_INET:
+      overlay = rule->override.overlays.v4;
+      break;
+    case AF_INET6:
+      overlay = rule->override.overlays.v6;
+      break;
+    default:
+      return -1;
+  }
+  if (!overlay->is_local_addr) return -1;
+  *addr = overlay->local_addr;
+  return 0;
+}
+
+int facemgr_cfg_rule_get_overlay_local_port(const facemgr_cfg_rule_t *rule,
+                                            int family, uint16_t *port) {
+  facemgr_cfg_overlay_t *overlay = NULL;
+  switch (family) {
+    case AF_INET:
+      overlay = rule->override.overlays.v4;
+      break;
+    case AF_INET6:
+      overlay = rule->override.overlays.v6;
+      break;
+    default:
+      return -1;
+  }
+  if (!overlay->is_local_port) return -1;
+  *port = overlay->local_port;
+  return 0;
+}
+
+int facemgr_cfg_rule_get_overlay_remote_addr(const facemgr_cfg_rule_t *rule,
+                                             int family, ip_address_t *addr) {
+  facemgr_cfg_overlay_t *overlay = NULL;
+  switch (family) {
+    case AF_INET:
+      overlay = rule->override.overlays.v4;
+      break;
+    case AF_INET6:
+      overlay = rule->override.overlays.v6;
+      break;
+    default:
+      return -1;
+  }
+  if (!overlay->is_remote_addr) return -1;
+  *addr = overlay->remote_addr;
+  return 0;
+}
+
+int facemgr_cfg_rule_get_overlay_remote_port(const facemgr_cfg_rule_t *rule,
+                                             int family, uint16_t *port) {
+  facemgr_cfg_overlay_t *overlay = NULL;
+  switch (family) {
+    case AF_INET:
+      overlay = rule->override.overlays.v4;
+      break;
+    case AF_INET6:
+      overlay = rule->override.overlays.v6;
+      break;
+    default:
+      return -1;
+  }
+  if (!overlay->is_remote_port) return -1;
+  *port = overlay->remote_port;
+  return 0;
+}
+
+int facemgr_cfg_add_static_facelet(facemgr_cfg_t *cfg, facelet_t *facelet) {
+  char buf[MAXSZ_FACELET];
+  facelet_snprintf(buf, MAXSZ_FACELET, facelet);
+  DEBUG("STATIC FACELET: %s", buf);
+  return facelet_array_add(cfg->static_facelets, facelet);
+}
+
+int facemgr_cfg_remove_static_facelet(facemgr_cfg_t *cfg, facelet_t *facelet,
+                                      facelet_t **removed_facelet) {
+  return facelet_array_remove(cfg->static_facelets, facelet, removed_facelet);
+}
+
+int facemgr_cfg_get_static_facelet_array(const facemgr_cfg_t *cfg,
+                                         facelet_t ***array) {
+  if (facelet_array_get_elements(cfg->static_facelets, array) < 0) {
+    ERROR(
+        "[facemgr_cfg_get_static_facelet_array] Error getting array elements");
+    return -1;
+  }
+  return (int)facelet_array_len(cfg->static_facelets);
 }
diff --git a/ctrl/facemgr/src/cfg_file.c b/ctrl/facemgr/src/cfg_file.c
index cb1ded1c9..966e35816 100644
--- a/ctrl/facemgr/src/cfg_file.c
+++ b/ctrl/facemgr/src/cfg_file.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -18,338 +18,311 @@
  * \brief Implementation of configuration file parsing
  */
 
-#include <unistd.h> // access
+#include <unistd.h>  // access
 #include <libconfig.h>
 
 #include <hicn/ctrl/route.h>
 
 #include "cfg_file.h"
 
-#define ARRAYSIZE(x) (sizeof(x)/sizeof(*x))
+#define ARRAYSIZE(x) (sizeof(x) / sizeof(*x))
 
-static const char * DEFAULT_CFGFILES[] = {
+static const char *DEFAULT_CFGFILES[] = {
     "/etc/facemgr.conf",
     "~/facemgr.conf",
 };
 
-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;
-        }
+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;
+  }
+  return -1;
 }
 
-int
-parse_config_global(facemgr_cfg_t * cfg, config_setting_t * setting)
-{
-    /* - face_type */
-
-    const char *face_type_str;
-    facemgr_face_type_t face_type;
-    if (config_setting_lookup_string(setting, "face_type", &face_type_str)) {
-        if (strcasecmp(face_type_str, "auto") == 0) {
-            face_type = FACEMGR_FACE_TYPE_DEFAULT;
-        } else
-        if (strcasecmp(face_type_str, "native-udp") == 0) {
-            face_type = FACEMGR_FACE_TYPE_NATIVE_UDP;
-        } else
-        if (strcasecmp(face_type_str, "native-tcp") == 0) {
-            face_type = FACEMGR_FACE_TYPE_NATIVE_TCP;
-        } else
-        if (strcasecmp(face_type_str, "overlay-udp") == 0) {
-            face_type = FACEMGR_FACE_TYPE_OVERLAY_UDP;
-        } else
-        if (strcasecmp(face_type_str, "overlay-tcp") == 0) {
-            face_type = FACEMGR_FACE_TYPE_OVERLAY_TCP;
-        } else {
-            ERROR("Invalid face type in section 'global'");
-            return -1;
-        }
-
-        int rc = facemgr_cfg_set_face_type(cfg, &face_type);
-        if (rc < 0)
-            goto ERR;
+int parse_config_global(facemgr_cfg_t *cfg, config_setting_t *setting) {
+  /* - face_type */
+
+  const char *face_type_str;
+  facemgr_face_type_t face_type;
+  if (config_setting_lookup_string(setting, "face_type", &face_type_str)) {
+    if (strcasecmp(face_type_str, "auto") == 0) {
+      face_type = FACEMGR_FACE_TYPE_DEFAULT;
+    } else if (strcasecmp(face_type_str, "native-udp") == 0) {
+      face_type = FACEMGR_FACE_TYPE_NATIVE_UDP;
+    } else if (strcasecmp(face_type_str, "native-tcp") == 0) {
+      face_type = FACEMGR_FACE_TYPE_NATIVE_TCP;
+    } else if (strcasecmp(face_type_str, "overlay-udp") == 0) {
+      face_type = FACEMGR_FACE_TYPE_OVERLAY_UDP;
+    } else if (strcasecmp(face_type_str, "overlay-tcp") == 0) {
+      face_type = FACEMGR_FACE_TYPE_OVERLAY_TCP;
+    } else {
+      ERROR("Invalid face type in section 'global'");
+      return -1;
     }
 
-    /* - disable_discovery */
-
-    int disable_discovery;
-    if (config_setting_lookup_bool(setting, "disable_discovery",
-                &disable_discovery)) {
-        int rc = facemgr_cfg_set_discovery(cfg, !disable_discovery);
-        if (rc < 0)
-            goto ERR;
-    }
-
-    /* - disable_ipv4 */
-
-    int disable_ipv4;
-    if (config_setting_lookup_bool(setting, "disable_ipv4",
-                &disable_ipv4)) {
-        int rc = facemgr_cfg_set_ipv4(cfg, !disable_ipv4);
-        if (rc < 0)
-            goto ERR;
-    }
-
-    /* - disable ipv6 */
-
-    int disable_ipv6;
-    if (config_setting_lookup_bool(setting, "disable_ipv6",
-                &disable_ipv6)) {
-        int rc = facemgr_cfg_set_ipv6(cfg, !disable_ipv6);
-        if (rc < 0)
-            goto ERR;
+    int rc = facemgr_cfg_set_face_type(cfg, &face_type);
+    if (rc < 0) goto ERR;
+  }
+
+  /* - disable_discovery */
+
+  int disable_discovery;
+  if (config_setting_lookup_bool(setting, "disable_discovery",
+                                 &disable_discovery)) {
+    int rc = facemgr_cfg_set_discovery(cfg, !disable_discovery);
+    if (rc < 0) goto ERR;
+  }
+
+  /* - disable_ipv4 */
+
+  int disable_ipv4;
+  if (config_setting_lookup_bool(setting, "disable_ipv4", &disable_ipv4)) {
+    int rc = facemgr_cfg_set_ipv4(cfg, !disable_ipv4);
+    if (rc < 0) goto ERR;
+  }
+
+  /* - disable ipv6 */
+
+  int disable_ipv6;
+  if (config_setting_lookup_bool(setting, "disable_ipv6", &disable_ipv6)) {
+    int rc = facemgr_cfg_set_ipv6(cfg, !disable_ipv6);
+    if (rc < 0) goto ERR;
+  }
+
+  /* - overlay */
+  config_setting_t *overlay = config_setting_get_member(setting, "overlay");
+  if (overlay) {
+    /* ipv4 */
+    config_setting_t *overlay_v4 = config_setting_get_member(overlay, "ipv4");
+    if (overlay_v4) {
+      const char *local_addr_str, *remote_addr_str;
+      ip_address_t local_addr = IP_ADDRESS_EMPTY;
+      ip_address_t remote_addr = IP_ADDRESS_EMPTY;
+      ip_address_t *local_addr_p = NULL;
+      ip_address_t *remote_addr_p = NULL;
+      int local_port = 0;
+      int remote_port = 0;
+
+      if (config_setting_lookup_string(overlay_v4, "local_addr",
+                                       &local_addr_str)) {
+        if (ip_address_pton(local_addr_str, &local_addr) < 0) {
+          ERROR("Error parsing v4 local addr");
+          goto ERR;
+        }
+        local_addr_p = &local_addr;
+      }
+
+      if (config_setting_lookup_int(overlay_v4, "local_port", &local_port)) {
+        if (!IS_VALID_PORT(local_port)) goto ERR;
+      }
+
+      if (config_setting_lookup_string(overlay_v4, "remote_addr",
+                                       &remote_addr_str)) {
+        if (ip_address_pton(remote_addr_str, &remote_addr) < 0) {
+          ERROR("Error parsing v4 remote addr");
+          goto ERR;
+        }
+        remote_addr_p = &remote_addr;
+      }
+
+      if (config_setting_lookup_int(overlay_v4, "remote_port", &remote_port)) {
+        if (!IS_VALID_PORT(remote_port)) goto ERR;
+      }
+      int rc = facemgr_cfg_set_overlay(cfg, AF_INET, local_addr_p, local_port,
+                                       remote_addr_p, remote_port);
+      if (rc < 0) goto ERR;
     }
 
-    /* - overlay */
-    config_setting_t *overlay = config_setting_get_member(setting, "overlay");
-    if (overlay) {
-
-        /* ipv4 */
-        config_setting_t *overlay_v4 = config_setting_get_member(overlay, "ipv4");
-        if (overlay_v4) {
-            const char * local_addr_str, * remote_addr_str;
-            ip_address_t local_addr = IP_ADDRESS_EMPTY;
-            ip_address_t remote_addr = IP_ADDRESS_EMPTY;
-            ip_address_t * local_addr_p = NULL;
-            ip_address_t * remote_addr_p = NULL;
-            int local_port = 0;
-            int remote_port = 0;
-
-            if (config_setting_lookup_string(overlay_v4, "local_addr", &local_addr_str)) {
-                if (ip_address_pton(local_addr_str, &local_addr) < 0) {
-                    ERROR("Error parsing v4 local addr");
-                    goto ERR;
-                }
-                local_addr_p = &local_addr;
-            }
-
-            if (config_setting_lookup_int(overlay_v4, "local_port", &local_port)) {
-                if (!IS_VALID_PORT(local_port))
-                    goto ERR;
-            }
-
-            if (config_setting_lookup_string(overlay_v4, "remote_addr", &remote_addr_str)) {
-                if (ip_address_pton(remote_addr_str, &remote_addr) < 0) {
-                    ERROR("Error parsing v4 remote addr");
-                    goto ERR;
-                }
-                remote_addr_p = &remote_addr;
-            }
-
-            if (config_setting_lookup_int(overlay_v4, "remote_port", &remote_port)) {
-                if (!IS_VALID_PORT(remote_port))
-                    goto ERR;
-            }
-            int rc = facemgr_cfg_set_overlay(cfg, AF_INET,
-                    local_addr_p, local_port,
-                    remote_addr_p, remote_port);
-            if (rc < 0)
-                goto ERR;
+    /* ipv6 */
+    config_setting_t *overlay_v6 = config_setting_get_member(overlay, "ipv6");
+    if (overlay_v6) {
+      const char *local_addr_str, *remote_addr_str;
+      ip_address_t local_addr = IP_ADDRESS_EMPTY;
+      ip_address_t remote_addr = IP_ADDRESS_EMPTY;
+      ip_address_t *local_addr_p = NULL;
+      ip_address_t *remote_addr_p = NULL;
+      int local_port = 0;
+      int remote_port = 0;
+
+      if (config_setting_lookup_string(overlay_v6, "local_addr",
+                                       &local_addr_str)) {
+        if (ip_address_pton(local_addr_str, &local_addr) < 0) {
+          ERROR("Error parsing v6 local addr");
+          goto ERR;
         }
-
-        /* ipv6 */
-        config_setting_t *overlay_v6 = config_setting_get_member(overlay, "ipv6");
-        if (overlay_v6) {
-            const char * local_addr_str, * remote_addr_str;
-            ip_address_t local_addr = IP_ADDRESS_EMPTY;
-            ip_address_t remote_addr = IP_ADDRESS_EMPTY;
-            ip_address_t * local_addr_p = NULL;
-            ip_address_t * remote_addr_p = NULL;
-            int local_port = 0;
-            int remote_port = 0;
-
-            if (config_setting_lookup_string(overlay_v6, "local_addr", &local_addr_str)) {
-                if (ip_address_pton(local_addr_str, &local_addr) < 0) {
-                    ERROR("Error parsing v6 local addr");
-                    goto ERR;
-                }
-                local_addr_p = &local_addr;
-            }
-
-            if (config_setting_lookup_int(overlay_v6, "local_port", &local_port)) {
-                if (!IS_VALID_PORT(local_port))
-                    goto ERR;
-            }
-
-            if (config_setting_lookup_string(overlay_v6, "remote_addr", &remote_addr_str)) {
-                if (ip_address_pton(remote_addr_str, &remote_addr) < 0) {
-                    ERROR("Error parsing v6 remote addr");
-                    goto ERR;
-                }
-                remote_addr_p = &remote_addr;
-            }
-
-            if (config_setting_lookup_int(overlay_v6, "remote_port", &remote_port)) {
-                if (!IS_VALID_PORT(remote_port))
-                    goto ERR;
-            }
-            int rc = facemgr_cfg_set_overlay(cfg, AF_INET6,
-                    local_addr_p, local_port,
-                    remote_addr_p, remote_port);
-            if (rc < 0)
-                goto ERR;
+        local_addr_p = &local_addr;
+      }
+
+      if (config_setting_lookup_int(overlay_v6, "local_port", &local_port)) {
+        if (!IS_VALID_PORT(local_port)) goto ERR;
+      }
+
+      if (config_setting_lookup_string(overlay_v6, "remote_addr",
+                                       &remote_addr_str)) {
+        if (ip_address_pton(remote_addr_str, &remote_addr) < 0) {
+          ERROR("Error parsing v6 remote addr");
+          goto ERR;
         }
+        remote_addr_p = &remote_addr;
+      }
+
+      if (config_setting_lookup_int(overlay_v6, "remote_port", &remote_port)) {
+        if (!IS_VALID_PORT(remote_port)) goto ERR;
+      }
+      int rc = facemgr_cfg_set_overlay(cfg, AF_INET6, local_addr_p, local_port,
+                                       remote_addr_p, remote_port);
+      if (rc < 0) goto ERR;
+    }
 
-    } /* overlay */
+  } /* overlay */
 
-    return 0;
+  return 0;
 
 ERR:
-    return -1;
+  return -1;
 }
 
-int
-parse_config_rules(facemgr_cfg_t * cfg, config_setting_t * setting)
-{
-    /* List of match-override tuples */
-    facemgr_cfg_rule_t * rule;
+int parse_config_rules(facemgr_cfg_t *cfg, config_setting_t *setting) {
+  /* List of match-override tuples */
+  facemgr_cfg_rule_t *rule;
 
-    int count = config_setting_length(setting);
-    for (unsigned i = 0; i < count; ++i) {
-        config_setting_t * rule_setting = config_setting_get_elem(setting, i);
+  int count = config_setting_length(setting);
+  for (unsigned i = 0; i < count; ++i) {
+    config_setting_t *rule_setting = config_setting_get_elem(setting, i);
 
-        /* Sanity check */
+    /* Sanity check */
 
-        config_setting_t * match_setting = config_setting_get_member(rule_setting, "match");
-        if (!match_setting) {
-            ERROR("Missing match section in rule #%d", i);
-            goto ERR_CHECK;
-        }
+    config_setting_t *match_setting =
+        config_setting_get_member(rule_setting, "match");
+    if (!match_setting) {
+      ERROR("Missing match section in rule #%d", i);
+      goto ERR_CHECK;
+    }
 
-        config_setting_t * override_setting = config_setting_get_member(rule_setting, "override");
-        if (!override_setting) {
-            ERROR("Missing override section in rule #%d", i);
-            goto ERR_CHECK;
-        }
+    config_setting_t *override_setting =
+        config_setting_get_member(rule_setting, "override");
+    if (!override_setting) {
+      ERROR("Missing override section in rule #%d", i);
+      goto ERR_CHECK;
+    }
 
-        rule = facemgr_cfg_rule_create();
-        if (!rule)
-            goto ERR_RULE;
-
-        /* Parse match */
-
-        const char * interface_name = NULL;
-        config_setting_lookup_string(match_setting, "interface_name", &interface_name);
-
-        const char * interface_type_str;
-        netdevice_type_t interface_type = NETDEVICE_TYPE_UNDEFINED;
-        if (config_setting_lookup_string(match_setting, "interface_type", &interface_type_str)) {
-            if (strcasecmp(interface_type_str, "wired") == 0) {
-                interface_type = NETDEVICE_TYPE_WIRED;
-            } else
-            if (strcasecmp(interface_type_str, "wifi") == 0) {
-                interface_type = NETDEVICE_TYPE_WIFI;
-            } else
-            if (strcasecmp(interface_type_str, "cellular") == 0) {
-                interface_type = NETDEVICE_TYPE_CELLULAR;
-            } else {
-                ERROR("Unknown interface type in rule #%d", i);
-                goto ERR;
-            }
-        }
+    rule = facemgr_cfg_rule_create();
+    if (!rule) goto ERR_RULE;
+
+    /* Parse match */
+
+    const char *interface_name = NULL;
+    config_setting_lookup_string(match_setting, "interface_name",
+                                 &interface_name);
+
+    const char *interface_type_str;
+    netdevice_type_t interface_type = NETDEVICE_TYPE_UNDEFINED;
+    if (config_setting_lookup_string(match_setting, "interface_type",
+                                     &interface_type_str)) {
+      if (strcasecmp(interface_type_str, "wired") == 0) {
+        interface_type = NETDEVICE_TYPE_WIRED;
+      } else if (strcasecmp(interface_type_str, "wifi") == 0) {
+        interface_type = NETDEVICE_TYPE_WIFI;
+      } else if (strcasecmp(interface_type_str, "cellular") == 0) {
+        interface_type = NETDEVICE_TYPE_CELLULAR;
+      } else {
+        ERROR("Unknown interface type in rule #%d", i);
+        goto ERR;
+      }
+    }
 
-        if ((!interface_name) && (interface_type == NETDEVICE_TYPE_UNDEFINED)) {
-            ERROR("Empty match section in rule #%d", i);
-            goto ERR;
-        }
+    if ((!interface_name) && (interface_type == NETDEVICE_TYPE_UNDEFINED)) {
+      ERROR("Empty match section in rule #%d", i);
+      goto ERR;
+    }
 
-        /* Associate match to rule */
+    /* Associate match to rule */
 
-        int rc = facemgr_cfg_rule_set_match(rule, interface_name, interface_type);
-        if (rc < 0)
-            goto ERR;
+    int rc = facemgr_cfg_rule_set_match(rule, interface_name, interface_type);
+    if (rc < 0) goto ERR;
 
-        /* Parse override */
+    /* Parse override */
 
-        /* - face_type */
+    /* - face_type */
 
-        const char *face_type_str;
-        facemgr_face_type_t face_type;
-        if (config_setting_lookup_string(override_setting, "face_type", &face_type_str)) {
-            if (strcasecmp(face_type_str, "auto")) {
-                /* We currently hardcode different behaviours based on the OS */
+    const char *face_type_str;
+    facemgr_face_type_t face_type;
+    if (config_setting_lookup_string(override_setting, "face_type",
+                                     &face_type_str)) {
+      if (strcasecmp(face_type_str, "auto")) {
+        /* We currently hardcode different behaviours based on the OS */
 #ifdef __ANDROID__
-                face_type = FACEMGR_FACE_TYPE_OVERLAY_UDP;
+        face_type = FACEMGR_FACE_TYPE_OVERLAY_UDP;
 #else
-                face_type = FACEMGR_FACE_TYPE_NATIVE_TCP;
+        face_type = FACEMGR_FACE_TYPE_NATIVE_TCP;
 #endif
-            } else
-            if (strcasecmp(face_type_str, "native-udp") == 0) {
-                face_type = FACEMGR_FACE_TYPE_NATIVE_UDP;
-            } else
-            if (strcasecmp(face_type_str, "native-tcp") == 0) {
-                face_type = FACEMGR_FACE_TYPE_NATIVE_TCP;
-            } else
-            if (strcasecmp(face_type_str, "overlay-udp") == 0) {
-                face_type = FACEMGR_FACE_TYPE_OVERLAY_UDP;
-            } else
-            if (strcasecmp(face_type_str, "overlay-tcp") == 0) {
-                face_type = FACEMGR_FACE_TYPE_OVERLAY_TCP;
-            } else {
-                ERROR("Invalid face type in section 'global'");
-                return -1;
-            }
+      } else if (strcasecmp(face_type_str, "native-udp") == 0) {
+        face_type = FACEMGR_FACE_TYPE_NATIVE_UDP;
+      } else if (strcasecmp(face_type_str, "native-tcp") == 0) {
+        face_type = FACEMGR_FACE_TYPE_NATIVE_TCP;
+      } else if (strcasecmp(face_type_str, "overlay-udp") == 0) {
+        face_type = FACEMGR_FACE_TYPE_OVERLAY_UDP;
+      } else if (strcasecmp(face_type_str, "overlay-tcp") == 0) {
+        face_type = FACEMGR_FACE_TYPE_OVERLAY_TCP;
+      } else {
+        ERROR("Invalid face type in section 'global'");
+        return -1;
+      }
 
-            int rc = facemgr_cfg_rule_set_face_type(rule, &face_type);
-            if (rc < 0)
-                goto ERR;
-        }
+      int rc = facemgr_cfg_rule_set_face_type(rule, &face_type);
+      if (rc < 0) goto ERR;
+    }
 
-        /* - disable_discovery */
+    /* - disable_discovery */
 
-        int disable_discovery;
-        if (config_setting_lookup_bool(override_setting, "disable_discovery",
-                    &disable_discovery)) {
-            int rc = facemgr_cfg_rule_set_discovery(rule, !disable_discovery);
-            if (rc < 0)
-                goto ERR;
-        }
+    int disable_discovery;
+    if (config_setting_lookup_bool(override_setting, "disable_discovery",
+                                   &disable_discovery)) {
+      int rc = facemgr_cfg_rule_set_discovery(rule, !disable_discovery);
+      if (rc < 0) goto ERR;
+    }
 
-        /* - disable_ipv4 */
+    /* - disable_ipv4 */
 
-        int disable_ipv4;
-        if (config_setting_lookup_bool(override_setting, "disable_ipv4",
-                    &disable_ipv4)) {
-            INFO("Ignored setting 'disable_ipv4' in rule #%d (not implemented).", i);
+    int disable_ipv4;
+    if (config_setting_lookup_bool(override_setting, "disable_ipv4",
+                                   &disable_ipv4)) {
+      INFO("Ignored setting 'disable_ipv4' in rule #%d (not implemented).", i);
 #if 0
             int rc = facemgr_cfg_rule_set_ipv4(rule, !disable_ipv4);
             if (rc < 0)
                 goto ERR;
 #endif
-        }
+    }
 
-        /* - disable ipv6 */
+    /* - disable ipv6 */
 
-        int disable_ipv6;
-        if (config_setting_lookup_bool(override_setting, "disable_ipv6",
-                    &disable_ipv6)) {
-            INFO("Ignored setting 'disable_ipv6' in rule #%d (not implemented).", i);
+    int disable_ipv6;
+    if (config_setting_lookup_bool(override_setting, "disable_ipv6",
+                                   &disable_ipv6)) {
+      INFO("Ignored setting 'disable_ipv6' in rule #%d (not implemented).", i);
 #if 0
             int rc = facemgr_cfg_rule_set_ipv6(rule, !disable_ipv6);
             if (rc < 0)
                 goto ERR;
 #endif
-        }
+    }
 
-        /* - ignore */
-        int ignore;
-        if (config_setting_lookup_bool(override_setting, "ignore", &ignore)) {
-            int rc = facemgr_cfg_rule_set_ignore(rule, !!ignore);
-            if (rc < 0)
-                goto ERR;
-        }
+    /* - ignore */
+    int ignore;
+    if (config_setting_lookup_bool(override_setting, "ignore", &ignore)) {
+      int rc = facemgr_cfg_rule_set_ignore(rule, !!ignore);
+      if (rc < 0) goto ERR;
+    }
 
-        /* - tags */
-        config_setting_t *tag_settings = config_setting_get_member(override_setting, "tags");
-        if (tag_settings) {
-            INFO("Ignored setting 'tags' in rule #%d (not implemented).", i);
+    /* - tags */
+    config_setting_t *tag_settings =
+        config_setting_get_member(override_setting, "tags");
+    if (tag_settings) {
+      INFO("Ignored setting 'tags' in rule #%d (not implemented).", i);
 #if 0
             policy_tags_t tags = POLICY_TAGS_EMPTY;
             for (unsigned j = 0; j < config_setting_length(tag_settings); j++) {
@@ -370,361 +343,337 @@ parse_config_rules(facemgr_cfg_t * cfg, config_setting_t * setting)
             DEBUG("Added tags tags=%s", tags_str);
 #endif
 #endif
+    }
+
+    /* - overlay */
+    config_setting_t *overlay =
+        config_setting_get_member(override_setting, "overlay");
+    if (overlay) {
+      /* ipv4 */
+      config_setting_t *overlay_v4 = config_setting_get_member(overlay, "ipv4");
+      if (overlay_v4) {
+        const char *local_addr_str, *remote_addr_str;
+        ip_address_t local_addr = IP_ADDRESS_EMPTY;
+        ip_address_t remote_addr = IP_ADDRESS_EMPTY;
+        ip_address_t *local_addr_p = NULL;
+        ip_address_t *remote_addr_p = NULL;
+        int local_port = 0;
+        int remote_port = 0;
+
+        if (config_setting_lookup_string(overlay_v4, "local_addr",
+                                         &local_addr_str)) {
+          ip_address_pton(local_addr_str, &local_addr);
+          local_addr_p = &local_addr;
         }
 
-        /* - overlay */
-        config_setting_t *overlay = config_setting_get_member(override_setting, "overlay");
-        if (overlay) {
-
-            /* ipv4 */
-            config_setting_t *overlay_v4 = config_setting_get_member(overlay, "ipv4");
-            if (overlay_v4) {
-                const char * local_addr_str, * remote_addr_str;
-                ip_address_t local_addr = IP_ADDRESS_EMPTY;
-                ip_address_t remote_addr = IP_ADDRESS_EMPTY;
-                ip_address_t * local_addr_p = NULL;
-                ip_address_t * remote_addr_p = NULL;
-                int local_port = 0;
-                int remote_port = 0;
-
-                if (config_setting_lookup_string(overlay_v4, "local_addr", &local_addr_str)) {
-                    ip_address_pton(local_addr_str, &local_addr);
-                    local_addr_p = &local_addr;
-                }
-
-                if (config_setting_lookup_int(overlay_v4, "local_port", &local_port)) {
-                    if (!IS_VALID_PORT(local_port))
-                        goto ERR;
-                }
-
-                if (config_setting_lookup_string(overlay_v4, "remote_addr", &remote_addr_str)) {
-                    ip_address_pton(remote_addr_str, &remote_addr);
-                    remote_addr_p = &remote_addr;
-                }
-
-                if (config_setting_lookup_int(overlay_v4, "remote_port", &remote_port)) {
-                    if (!IS_VALID_PORT(remote_port))
-                        goto ERR;
-                }
-                int rc = facemgr_cfg_rule_set_overlay(rule, AF_INET,
-                        local_addr_p, local_port,
-                        remote_addr_p, remote_port);
-                if (rc < 0)
-                    goto ERR;
-            }
+        if (config_setting_lookup_int(overlay_v4, "local_port", &local_port)) {
+          if (!IS_VALID_PORT(local_port)) goto ERR;
+        }
 
-            /* ipv6 */
-            config_setting_t *overlay_v6 = config_setting_get_member(overlay, "ipv6");
-            if (overlay_v6) {
-                const char * local_addr_str, * remote_addr_str;
-                ip_address_t local_addr = IP_ADDRESS_EMPTY;
-                ip_address_t remote_addr = IP_ADDRESS_EMPTY;
-                ip_address_t * local_addr_p = NULL;
-                ip_address_t * remote_addr_p = NULL;
-                int local_port = 0;
-                int remote_port = 0;
-
-                if (config_setting_lookup_string(overlay_v6, "local_addr", &local_addr_str)) {
-                    ip_address_pton(local_addr_str, &local_addr);
-                    local_addr_p = &local_addr;
-                }
-
-                if (config_setting_lookup_int(overlay_v6, "local_port", &local_port)) {
-                    if (!IS_VALID_PORT(local_port))
-                        goto ERR;
-                }
-
-                if (config_setting_lookup_string(overlay_v6, "remote_addr", &remote_addr_str)) {
-                    ip_address_pton(remote_addr_str, &remote_addr);
-                    remote_addr_p = &remote_addr;
-                }
-
-                if (config_setting_lookup_int(overlay_v6, "remote_port", &remote_port)) {
-                    if (!IS_VALID_PORT(remote_port))
-                        goto ERR;
-                }
-                int rc = facemgr_cfg_rule_set_overlay(rule, AF_INET6,
-                        local_addr_p, local_port,
-                        remote_addr_p, remote_port);
-                if (rc < 0)
-                    goto ERR;
-            }
+        if (config_setting_lookup_string(overlay_v4, "remote_addr",
+                                         &remote_addr_str)) {
+          ip_address_pton(remote_addr_str, &remote_addr);
+          remote_addr_p = &remote_addr;
+        }
 
-        } /* overlay */
+        if (config_setting_lookup_int(overlay_v4, "remote_port",
+                                      &remote_port)) {
+          if (!IS_VALID_PORT(remote_port)) goto ERR;
+        }
+        int rc = facemgr_cfg_rule_set_overlay(rule, AF_INET, local_addr_p,
+                                              local_port, remote_addr_p,
+                                              remote_port);
+        if (rc < 0) goto ERR;
+      }
+
+      /* ipv6 */
+      config_setting_t *overlay_v6 = config_setting_get_member(overlay, "ipv6");
+      if (overlay_v6) {
+        const char *local_addr_str, *remote_addr_str;
+        ip_address_t local_addr = IP_ADDRESS_EMPTY;
+        ip_address_t remote_addr = IP_ADDRESS_EMPTY;
+        ip_address_t *local_addr_p = NULL;
+        ip_address_t *remote_addr_p = NULL;
+        int local_port = 0;
+        int remote_port = 0;
 
-        /* Add newly created rule */
+        if (config_setting_lookup_string(overlay_v6, "local_addr",
+                                         &local_addr_str)) {
+          ip_address_pton(local_addr_str, &local_addr);
+          local_addr_p = &local_addr;
+        }
 
-        rc = facemgr_cfg_add_rule(cfg, rule);
-        if (rc < 0)
-            goto ERR;
-    }
-    return 0;
+        if (config_setting_lookup_int(overlay_v6, "local_port", &local_port)) {
+          if (!IS_VALID_PORT(local_port)) goto ERR;
+        }
+
+        if (config_setting_lookup_string(overlay_v6, "remote_addr",
+                                         &remote_addr_str)) {
+          ip_address_pton(remote_addr_str, &remote_addr);
+          remote_addr_p = &remote_addr;
+        }
+
+        if (config_setting_lookup_int(overlay_v6, "remote_port",
+                                      &remote_port)) {
+          if (!IS_VALID_PORT(remote_port)) goto ERR;
+        }
+        int rc = facemgr_cfg_rule_set_overlay(rule, AF_INET6, local_addr_p,
+                                              local_port, remote_addr_p,
+                                              remote_port);
+        if (rc < 0) goto ERR;
+      }
+
+    } /* overlay */
+
+    /* Add newly created rule */
+
+    rc = facemgr_cfg_add_rule(cfg, rule);
+    if (rc < 0) goto ERR;
+  }
+  return 0;
 
 ERR:
-    facemgr_cfg_rule_free(rule);
+  facemgr_cfg_rule_free(rule);
 ERR_RULE:
 ERR_CHECK:
-    return -1;
+  return -1;
 }
 
-int parse_config_static_facelets(facemgr_cfg_t * cfg, config_setting_t * setting)
-{
-    int count = config_setting_length(setting);
-    for (unsigned i = 0; i < count; ++i) {
-        config_setting_t * static_setting = config_setting_get_elem(setting, i);
-
-        const char *face_type_str;
-        facemgr_face_type_t face_type;
-        const char * family_str;
-        int family;
-        const char * remote_addr_str;
-        ip_address_t remote_addr = IP_ADDRESS_EMPTY;
-        int remote_port = 0;
-        const char * interface_name;
-        const char * interface_type_str;
-
-        facelet_t * facelet = facelet_create();
-
-        /* Face type */
-        if (config_setting_lookup_string(static_setting, "face_type", &face_type_str)) {
-            if (strcasecmp(face_type_str, "auto") == 0) {
-                face_type = FACEMGR_FACE_TYPE_DEFAULT;
-            } else
-            if (strcasecmp(face_type_str, "native-udp") == 0) {
-                face_type = FACEMGR_FACE_TYPE_NATIVE_UDP;
-            } else
-            if (strcasecmp(face_type_str, "native-tcp") == 0) {
-                face_type = FACEMGR_FACE_TYPE_NATIVE_TCP;
-            } else
-            if (strcasecmp(face_type_str, "overlay-udp") == 0) {
-                face_type = FACEMGR_FACE_TYPE_OVERLAY_UDP;
-            } else
-            if (strcasecmp(face_type_str, "overlay-tcp") == 0) {
-                face_type = FACEMGR_FACE_TYPE_OVERLAY_TCP;
-            } else {
-                ERROR("Invalid face type in section 'global'");
-                goto ERR_FACELET;
-            }
+int parse_config_static_facelets(facemgr_cfg_t *cfg,
+                                 config_setting_t *setting) {
+  int count = config_setting_length(setting);
+  for (unsigned i = 0; i < count; ++i) {
+    config_setting_t *static_setting = config_setting_get_elem(setting, i);
 
-            int rc = facelet_set_face_type(facelet, face_type);
-            if (rc < 0)
-                goto ERR_FACELET;
-        }
+    const char *face_type_str;
+    facemgr_face_type_t face_type;
+    const char *family_str;
+    int family;
+    const char *remote_addr_str;
+    ip_address_t remote_addr = IP_ADDRESS_EMPTY;
+    int remote_port = 0;
+    const char *interface_name;
+    const char *interface_type_str;
+
+    facelet_t *facelet = facelet_create();
+
+    /* Face type */
+    if (config_setting_lookup_string(static_setting, "face_type",
+                                     &face_type_str)) {
+      if (strcasecmp(face_type_str, "auto") == 0) {
+        face_type = FACEMGR_FACE_TYPE_DEFAULT;
+      } else if (strcasecmp(face_type_str, "native-udp") == 0) {
+        face_type = FACEMGR_FACE_TYPE_NATIVE_UDP;
+      } else if (strcasecmp(face_type_str, "native-tcp") == 0) {
+        face_type = FACEMGR_FACE_TYPE_NATIVE_TCP;
+      } else if (strcasecmp(face_type_str, "overlay-udp") == 0) {
+        face_type = FACEMGR_FACE_TYPE_OVERLAY_UDP;
+      } else if (strcasecmp(face_type_str, "overlay-tcp") == 0) {
+        face_type = FACEMGR_FACE_TYPE_OVERLAY_TCP;
+      } else {
+        ERROR("Invalid face type in section 'global'");
+        goto ERR_FACELET;
+      }
+
+      int rc = facelet_set_face_type(facelet, face_type);
+      if (rc < 0) goto ERR_FACELET;
+    }
 
-        /* Family */
-        if (config_setting_lookup_string(static_setting, "family", &family_str)) {
-            if (strcasecmp(family_str, "AF_INET") == 0) {
-                family = AF_INET;
-            } else
-            if (strcasecmp(family_str, "AF_INET6") == 0) {
-                family = AF_INET6;
-            } else {
-                ERROR("Invalid family in section 'static', items #%d", i+1);
-                goto ERR_FACELET;
-            }
-            int rc = facelet_set_family(facelet, family);
-            if (rc < 0)
-                goto ERR_FACELET;
-        }
+    /* Family */
+    if (config_setting_lookup_string(static_setting, "family", &family_str)) {
+      if (strcasecmp(family_str, "AF_INET") == 0) {
+        family = AF_INET;
+      } else if (strcasecmp(family_str, "AF_INET6") == 0) {
+        family = AF_INET6;
+      } else {
+        ERROR("Invalid family in section 'static', items #%d", i + 1);
+        goto ERR_FACELET;
+      }
+      int rc = facelet_set_family(facelet, family);
+      if (rc < 0) goto ERR_FACELET;
+    }
 
-        /* Remote address */
-        if (config_setting_lookup_string(static_setting, "remote_addr", &remote_addr_str)) {
-            if (ip_address_pton(remote_addr_str, &remote_addr) < 0) {
-                ERROR("Error parsing v4 remote addr");
-                goto ERR_FACELET;
-            }
+    /* Remote address */
+    if (config_setting_lookup_string(static_setting, "remote_addr",
+                                     &remote_addr_str)) {
+      if (ip_address_pton(remote_addr_str, &remote_addr) < 0) {
+        ERROR("Error parsing v4 remote addr");
+        goto ERR_FACELET;
+      }
 
-            int rc = facelet_set_remote_addr(facelet, remote_addr);
-            if (rc < 0)
-                goto ERR_FACELET;
-        }
+      int rc = facelet_set_remote_addr(facelet, remote_addr);
+      if (rc < 0) goto ERR_FACELET;
+    }
 
-        /* Remote port */
-        if (config_setting_lookup_int(static_setting, "remote_port", &remote_port)) {
-            if (!IS_VALID_PORT(remote_port))
-                goto ERR_FACELET;
-            int rc = facelet_set_remote_port(facelet, remote_port);
-            if (rc < 0)
-                goto ERR_FACELET;
-        }
+    /* Remote port */
+    if (config_setting_lookup_int(static_setting, "remote_port",
+                                  &remote_port)) {
+      if (!IS_VALID_PORT(remote_port)) goto ERR_FACELET;
+      int rc = facelet_set_remote_port(facelet, remote_port);
+      if (rc < 0) goto ERR_FACELET;
+    }
 
-        /* Interface name */
-        if (config_setting_lookup_string(static_setting, "interface_name", &interface_name)) {
-            netdevice_t netdevice;
-            /* Warning: interface might not exist when we create the facelet */
-            snprintf(netdevice.name, IFNAMSIZ, "%s", interface_name);
-            netdevice.index = 0;
-            int rc = facelet_set_netdevice(facelet, netdevice);
-            if (rc < 0)
-                goto ERR_FACELET;
-        }
+    /* Interface name */
+    if (config_setting_lookup_string(static_setting, "interface_name",
+                                     &interface_name)) {
+      netdevice_t netdevice;
+      /* Warning: interface might not exist when we create the facelet */
+      snprintf(netdevice.name, IFNAMSIZ, "%s", interface_name);
+      netdevice.index = 0;
+      int rc = facelet_set_netdevice(facelet, netdevice);
+      if (rc < 0) goto ERR_FACELET;
+    }
 
-        /* Interface type */
-        netdevice_type_t interface_type = NETDEVICE_TYPE_UNDEFINED;
-        if (config_setting_lookup_string(static_setting, "interface_type", &interface_type_str)) {
-            if (strcasecmp(interface_type_str, "wired") == 0) {
-                interface_type = NETDEVICE_TYPE_WIRED;
-            } else
-            if (strcasecmp(interface_type_str, "wifi") == 0) {
-                interface_type = NETDEVICE_TYPE_WIFI;
-            } else
-            if (strcasecmp(interface_type_str, "cellular") == 0) {
-                interface_type = NETDEVICE_TYPE_CELLULAR;
-            } else {
-                ERROR("Unknown interface type in rule #%d", i);
-                goto ERR_FACELET;
-            }
+    /* Interface type */
+    netdevice_type_t interface_type = NETDEVICE_TYPE_UNDEFINED;
+    if (config_setting_lookup_string(static_setting, "interface_type",
+                                     &interface_type_str)) {
+      if (strcasecmp(interface_type_str, "wired") == 0) {
+        interface_type = NETDEVICE_TYPE_WIRED;
+      } else if (strcasecmp(interface_type_str, "wifi") == 0) {
+        interface_type = NETDEVICE_TYPE_WIFI;
+      } else if (strcasecmp(interface_type_str, "cellular") == 0) {
+        interface_type = NETDEVICE_TYPE_CELLULAR;
+      } else {
+        ERROR("Unknown interface type in rule #%d", i);
+        goto ERR_FACELET;
+      }
+
+      int rc = facelet_set_netdevice_type(facelet, interface_type);
+      if (rc < 0) goto ERR_FACELET;
+    }
 
-            int rc = facelet_set_netdevice_type(facelet, interface_type);
-            if (rc < 0)
-                goto ERR_FACELET;
+    /* Routes */
+    config_setting_t *routes_static_setting =
+        config_setting_get_member(static_setting, "routes");
+    if (routes_static_setting) {
+      /* ... */
+      int count_routes = config_setting_length(routes_static_setting);
+      for (unsigned j = 0; j < count_routes; ++j) {
+        config_setting_t *route_static_setting =
+            config_setting_get_elem(routes_static_setting, j);
+
+        const char *prefix_str;
+        ip_prefix_t prefix;
+        int cost = 0; /* default */
+
+        if (config_setting_lookup_string(route_static_setting, "prefix",
+                                         &prefix_str)) {
+          if (ip_prefix_pton(prefix_str, &prefix) < 0) {
+            ERROR("Error parsing prefix in route #%d, rule #%d", j, i);
+            goto ERR_FACELET;
+          }
+        } else {
+          ERROR("Cannot add route without prefix");
+          goto ERR_FACELET;
         }
 
-        /* Routes */
-        config_setting_t * routes_static_setting = config_setting_get_member(static_setting, "routes");
-        if (routes_static_setting) {
-            /* ... */
-            int count_routes = config_setting_length(routes_static_setting);
-            for (unsigned j = 0; j < count_routes; ++j) {
-                config_setting_t * route_static_setting = config_setting_get_elem(routes_static_setting, j);
-
-                const char * prefix_str;
-                ip_prefix_t prefix;
-                int cost = 0; /* default */
-
-                if (config_setting_lookup_string(route_static_setting, "prefix", &prefix_str)) {
-                    if (ip_prefix_pton(prefix_str, &prefix) < 0) {
-                        ERROR("Error parsing prefix in route #%d, rule #%d", j, i);
-                        goto ERR_FACELET;
-                    }
-                } else {
-                    ERROR("Cannot add route without prefix");
-                    goto ERR_FACELET;
-                }
-
-                config_setting_lookup_int(static_setting, "cost", &cost);
-
-                hicn_route_t * route = hicn_route_create(&prefix, 0, cost);
-                if (!route) {
-                    ERROR("Could not create hICN route");
-                    goto ERR_FACELET;
-                }
-
-                int rc = facelet_add_route(facelet, route);
-                if (rc < 0) {
-                    ERROR("Could not add route to facelet");
-                    goto ERR_ROUTE;
-                }
-
-                continue;
-
-ERR_ROUTE:
-                hicn_route_free(route);
-                goto ERR_FACELET;
-            }
+        config_setting_lookup_int(static_setting, "cost", &cost);
+
+        hicn_route_t *route = hicn_route_create(&prefix, 0, cost);
+        if (!route) {
+          ERROR("Could not create hICN route");
+          goto ERR_FACELET;
         }
 
-        if (facemgr_cfg_add_static_facelet(cfg, facelet) < 0) {
-            ERROR("Could not add static facelet to configuration");
-            goto ERR_FACELET;
+        int rc = facelet_add_route(facelet, route);
+        if (rc < 0) {
+          ERROR("Could not add route to facelet");
+          goto ERR_ROUTE;
         }
 
         continue;
 
-ERR_FACELET:
-        facelet_free(facelet);
-        return -1;
+      ERR_ROUTE:
+        hicn_route_free(route);
+        goto ERR_FACELET;
+      }
+    }
 
-        }
-    return 0;
+    if (facemgr_cfg_add_static_facelet(cfg, facelet) < 0) {
+      ERROR("Could not add static facelet to configuration");
+      goto ERR_FACELET;
+    }
+
+    continue;
+
+  ERR_FACELET:
+    facelet_free(facelet);
+    return -1;
+  }
+  return 0;
 }
 
 /* Currently not using facemgr_cfg_t */
-int
-parse_config_log(facemgr_cfg_t * cfg, config_setting_t * setting)
-{
-    const char *log_level_str;
-    if (config_setting_lookup_string(setting, "log_level", &log_level_str)) {
-        if (strcasecmp(log_level_str, "FATAL") == 0) {
-            log_conf.log_level = LOG_FATAL;
-        } else
-        if (strcasecmp(log_level_str, "ERROR") == 0) {
-            log_conf.log_level = LOG_ERROR;
-        } else
-        if (strcasecmp(log_level_str, "WARN") == 0) {
-            log_conf.log_level = LOG_WARN;
-        } else
-        if (strcasecmp(log_level_str, "INFO") == 0) {
-            log_conf.log_level = LOG_INFO;
-        } else
-        if (strcasecmp(log_level_str, "DEBUG") == 0) {
-            log_conf.log_level = LOG_DEBUG;
-        } else
-        if (strcasecmp(log_level_str, "TRACE") == 0) {
-            log_conf.log_level = LOG_TRACE;
-        } else {
-            ERROR("Invalid log level in section 'log'");
-            return -1;
-        }
+int parse_config_log(facemgr_cfg_t *cfg, config_setting_t *setting) {
+  const char *log_level_str;
+  if (config_setting_lookup_string(setting, "log_level", &log_level_str)) {
+    if (strcasecmp(log_level_str, "FATAL") == 0) {
+      log_conf.log_level = LOG_FATAL;
+    } else if (strcasecmp(log_level_str, "ERROR") == 0) {
+      log_conf.log_level = LOG_ERROR;
+    } else if (strcasecmp(log_level_str, "WARN") == 0) {
+      log_conf.log_level = LOG_WARN;
+    } else if (strcasecmp(log_level_str, "INFO") == 0) {
+      log_conf.log_level = LOG_INFO;
+    } else if (strcasecmp(log_level_str, "DEBUG") == 0) {
+      log_conf.log_level = LOG_DEBUG;
+    } else if (strcasecmp(log_level_str, "TRACE") == 0) {
+      log_conf.log_level = LOG_TRACE;
+    } else {
+      ERROR("Invalid log level in section 'log'");
+      return -1;
     }
-    return 0;
+  }
+  return 0;
 }
 
-int
-parse_config_file(const char * cfgpath, facemgr_cfg_t * cfg)
-{
-    /* Reading configuration file */
-    config_t cfgfile;
-    config_setting_t *setting;
+int parse_config_file(const char *cfgpath, facemgr_cfg_t *cfg) {
+  /* Reading configuration file */
+  config_t cfgfile;
+  config_setting_t *setting;
 
-    config_init(&cfgfile);
+  config_init(&cfgfile);
 
-    /* Read the file. If there is an error, report it and exit. */
-    if(!config_read_file(&cfgfile, cfgpath))
-        goto ERR_FILE;
+  /* Read the file. If there is an error, report it and exit. */
+  if (!config_read_file(&cfgfile, cfgpath)) goto ERR_FILE;
 
-    setting = config_lookup(&cfgfile, "global");
-    if (setting) {
-        int rc = parse_config_global(cfg, setting);
-        if (rc < 0)
-            goto ERR_PARSE;
-    }
+  setting = config_lookup(&cfgfile, "global");
+  if (setting) {
+    int rc = parse_config_global(cfg, setting);
+    if (rc < 0) goto ERR_PARSE;
+  }
 
-    setting = config_lookup(&cfgfile, "rules");
-    if (setting) {
-        int rc = parse_config_rules(cfg, setting);
-        if (rc < 0)
-            goto ERR_PARSE;
-    }
+  setting = config_lookup(&cfgfile, "rules");
+  if (setting) {
+    int rc = parse_config_rules(cfg, setting);
+    if (rc < 0) goto ERR_PARSE;
+  }
 
-    setting = config_lookup(&cfgfile, "static");
-    if (setting) {
-        int rc = parse_config_static_facelets(cfg, setting);
-        if (rc < 0)
-            goto ERR_PARSE;
-    }
+  setting = config_lookup(&cfgfile, "static");
+  if (setting) {
+    int rc = parse_config_static_facelets(cfg, setting);
+    if (rc < 0) goto ERR_PARSE;
+  }
 
-    setting = config_lookup(&cfgfile, "log");
-    if (setting) {
-        int rc = parse_config_log(cfg, setting);
-        if (rc < 0)
-            goto ERR_PARSE;
-    }
+  setting = config_lookup(&cfgfile, "log");
+  if (setting) {
+    int rc = parse_config_log(cfg, setting);
+    if (rc < 0) goto ERR_PARSE;
+  }
 
-    config_destroy(&cfgfile);
-    return 0;
+  config_destroy(&cfgfile);
+  return 0;
 
 ERR_FILE:
-    ERROR("Could not read configuration file %s", cfgpath);
-    fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfgfile),
-            config_error_line(&cfgfile), config_error_text(&cfgfile));
-    config_destroy(&cfgfile);
-    exit(EXIT_FAILURE);
-    return -1;
+  ERROR("Could not read configuration file %s", cfgpath);
+  fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfgfile),
+          config_error_line(&cfgfile), config_error_text(&cfgfile));
+  config_destroy(&cfgfile);
+  return -1;
 ERR_PARSE:
-    fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfgfile),
-            config_error_line(&cfgfile), config_error_text(&cfgfile));
-    config_destroy(&cfgfile);
-    return -1;
+  fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfgfile),
+          config_error_line(&cfgfile), config_error_text(&cfgfile));
+  config_destroy(&cfgfile);
+  return -1;
 }
-
diff --git a/ctrl/facemgr/src/cfg_file.h b/ctrl/facemgr/src/cfg_file.h
index dfce041d8..fea6a84a6 100644
--- a/ctrl/facemgr/src/cfg_file.h
+++ b/ctrl/facemgr/src/cfg_file.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -28,7 +28,7 @@
  * \param [in] f - File name
  * \return 0 in case of success, -1 otherwise.
  */
-int probe_cfgfile(char * f);
+int probe_cfgfile(char* f);
 
 /**
  * \brief Parses the provided configuration file into the facemgr configuration
@@ -37,6 +37,6 @@ int probe_cfgfile(char * f);
  * \param [out] cfg - Pre-allocated configuration data structure
  * \return 0 in case of success, -1 otherwise.
  */
-int parse_config_file(const char * cfgpath, facemgr_cfg_t * cfg);
+int parse_config_file(const char* cfgpath, facemgr_cfg_t* cfg);
 
 #endif /* FACEMGR_CFG_FILE_H */
diff --git a/ctrl/facemgr/src/common.h b/ctrl/facemgr/src/common.h
index 56bd706f1..2fda668c8 100644
--- a/ctrl/facemgr/src/common.h
+++ b/ctrl/facemgr/src/common.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -32,71 +32,58 @@
 
 /* Dump with indent */
 #define INDENT(n, fmt) "%*s" fmt, n, ""
-#define printfi(n, fmt, ...) printf(INDENT(n*4, fmt), ##__VA_ARGS__)
+#define printfi(n, fmt, ...) printf(INDENT(n * 4, fmt), ##__VA_ARGS__)
 
 #define _unused(x) ((void)(x))
 
 /* Random strings */
 
-static inline
-void rand_str(char *dest, size_t length) {
-    char charset[] = "0123456789"
-                     "abcdefghijklmnopqrstuvwxyz"
-                     "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-
-    while (length-- > 0) {
-        size_t index = (double) rand() / RAND_MAX * (sizeof charset - 1);
-        *dest++ = charset[index];
-    }
-    *dest = '\0';
+static inline void rand_str(char *dest, size_t length) {
+  char charset[] =
+      "0123456789"
+      "abcdefghijklmnopqrstuvwxyz"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+  while (length-- > 0) {
+    size_t index = (double)rand() / RAND_MAX * (sizeof charset - 1);
+    *dest++ = charset[index];
+  }
+  *dest = '\0';
 }
 
 /* Boilerplate code */
 
-#define NO_INITIALIZE(NAME)                                             \
-int                                                                     \
-NAME ## _initialize(NAME ## _t * obj) {                                 \
-    return 0;                                             \
-}
-
-#define NO_FINALIZE(NAME)                                               \
-int                                                                     \
-NAME ## _finalize(NAME ## _t * obj) {                                   \
-    return 0;                                             \
-}
-
-#define AUTOGENERATE_CREATE_FREE(NAME)                                  \
-                                                                        \
-NAME ## _t *                                                            \
-NAME ## _create()                                                       \
-{                                                                       \
-    NAME ## _t * obj  = malloc(sizeof(NAME ## _t));                     \
-    if (!obj)                                                           \
-        goto ERR_MALLOC;                                                \
-                                                                        \
-    if (NAME ## _initialize(obj) < 0)                                   \
-        goto ERR_INIT;                                                  \
-                                                                        \
-    return obj;                                                         \
-                                                                        \
-ERR_INIT:                                                               \
-    free(obj);                                                          \
-ERR_MALLOC:                                                             \
-    return NULL;                                                        \
-}                                                                       \
-                                                                        \
-void                                                                    \
-NAME ## _free(NAME ## _t * obj)                                         \
-{                                                                       \
-    if (NAME ## _finalize(obj) < 0)                                     \
-        (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 *);                                       \
+#define NO_INITIALIZE(NAME) \
+  int NAME##_initialize(NAME##_t *obj) { return 0; }
+
+#define NO_FINALIZE(NAME) \
+  int NAME##_finalize(NAME##_t *obj) { return 0; }
+
+#define AUTOGENERATE_CREATE_FREE(NAME)               \
+                                                     \
+  NAME##_t *NAME##_create() {                        \
+    NAME##_t *obj = malloc(sizeof(NAME##_t));        \
+    if (!obj) goto ERR_MALLOC;                       \
+                                                     \
+    if (NAME##_initialize(obj) < 0) goto ERR_INIT;   \
+                                                     \
+    return obj;                                      \
+                                                     \
+  ERR_INIT:                                          \
+    free(obj);                                       \
+  ERR_MALLOC:                                        \
+    return NULL;                                     \
+  }                                                  \
+                                                     \
+  void NAME##_free(NAME##_t *obj) {                  \
+    if (NAME##_finalize(obj) < 0) (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
index 4dcea6e1f..36ce5f561 100644
--- a/ctrl/facemgr/src/error.c
+++ b/ctrl/facemgr/src/error.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,8 +21,7 @@
 #include "error.h"
 
 const char *FACEMGR_ERROR_STRING[] = {
-#define _(a,b,c) [b] = c,
-  foreach_facemgr_error
+#define _(a, b, c) [b] = c,
+    foreach_facemgr_error
 #undef _
 };
-
diff --git a/ctrl/facemgr/src/error.h b/ctrl/facemgr/src/error.h
index a0d76b3e5..7fadea49f 100644
--- a/ctrl/facemgr/src/error.h
+++ b/ctrl/facemgr/src/error.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,15 +16,13 @@
 #ifndef FACEMGR_ERROR_H
 #define FACEMGR_ERROR_H
 
-#define foreach_facemgr_error                           \
-_(NONE,         0,      "OK")                           \
-
+#define foreach_facemgr_error _(NONE, 0, "OK")
 
 typedef enum {
-#define _(a,b,c) FACEMGR_ERROR_##a = (-b),
-    foreach_facemgr_error
+#define _(a, b, c) FACEMGR_ERROR_##a = (-b),
+  foreach_facemgr_error
 #undef _
-    FACEMGR_ERROR_N,
+      FACEMGR_ERROR_N,
 } facemgr_error_t;
 
 extern const char *HICN_LIB_ERROR_STRING[];
diff --git a/ctrl/facemgr/src/facelet.c b/ctrl/facemgr/src/facelet.c
index 9e9f3f67f..609950f75 100644
--- a/ctrl/facemgr/src/facelet.c
+++ b/ctrl/facemgr/src/facelet.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -20,7 +20,7 @@
 
 #include <assert.h>
 #include <stdbool.h>
-#include <hicn/ctrl/face.h>
+#include <hicn/face.h>
 #include <hicn/ctrl/route.h>
 #include <hicn/facemgr/cfg.h>
 #include <hicn/facemgr/facelet.h>
@@ -32,152 +32,132 @@
 TYPEDEF_SET_H(route_set, hicn_route_t *);
 TYPEDEF_SET(route_set, hicn_route_t *, hicn_route_cmp, generic_snprintf);
 
-const char * face_type_layer_str[] = {
-#define _(x) [FACE_TYPE_LAYER_ ## x] = STRINGIZE(x),
+const char *face_type_layer_str[] = {
+#define _(x) [FACE_TYPE_LAYER_##x] = STRINGIZE(x),
     foreach_face_type_layer
 #undef _
 };
 
-const char * face_type_encap_str[] = {
-#define _(x) [FACE_TYPE_ENCAP_ ## x] = STRINGIZE(x),
+const char *face_type_encap_str[] = {
+#define _(x) [FACE_TYPE_ENCAP_##x] = STRINGIZE(x),
     foreach_face_type_encap
 #undef _
 };
 
-const char * facelet_status_str[] = {
-#define _(x) [FACELET_STATUS_ ## x] = STRINGIZE(x),
+const char *facelet_status_str[] = {
+#define _(x) [FACELET_STATUS_##x] = STRINGIZE(x),
     foreach_facelet_status
 #undef _
 };
 
-const char * facelet_error_reason_str[] = {
-#define _(x) [FACELET_ERROR_REASON_ ## x] = STRINGIZE(x),
+const char *facelet_error_reason_str[] = {
+#define _(x) [FACELET_ERROR_REASON_##x] = STRINGIZE(x),
     foreach_facelet_error_reason
 #undef _
 };
 
 /* Facelet attribute status */
 
-const char * facelet_attr_status_str[] = {
-#define _(x, str) [FACELET_ATTR_STATUS_ ## x] = STRINGIZE(x),
+const char *facelet_attr_status_str[] = {
+#define _(x, str) [FACELET_ATTR_STATUS_##x] = STRINGIZE(x),
     foreach_facelet_attr_status
 #undef _
 };
 
-const char * facelet_attr_status_str_short[] = {
-#define _(x, str) [FACELET_ATTR_STATUS_ ## x] = STRINGIZE(str),
+const char *facelet_attr_status_str_short[] = {
+#define _(x, str) [FACELET_ATTR_STATUS_##x] = STRINGIZE(str),
     foreach_facelet_attr_status
 #undef _
 };
 
-
 /* Facelet */
 
 struct facelet_s {
-    unsigned id;
+  unsigned id;
 
 #define _(TYPE, NAME) TYPE NAME;
-    foreach_facelet_attr
+  foreach_facelet_attr
 #undef _
-#define _(TYPE, NAME) facelet_attr_status_t NAME ## _status;
-    foreach_facelet_attr
+#define _(TYPE, NAME) facelet_attr_status_t NAME##_status;
+      foreach_facelet_attr
 #undef _
 
+          facelet_status_t status;
+  int error;
 
+  facelet_event_t event;
 
-    facelet_status_t status;
-    int error;
-
-    facelet_event_t event;
-
-    route_set_t * routes;
-    bool routes_done;
+  route_set_t *routes;
+  bool routes_done;
 
-    bool bj_done;
-    bool au_done;
+  bool bj_done;
 };
 
-const char * facelet_event_str[] = {
-#define _(x) [FACELET_EVENT_ ## x] = STRINGIZE(x),
-foreach_facelet_event
+const char *facelet_event_str[] = {
+#define _(x) [FACELET_EVENT_##x] = STRINGIZE(x),
+    foreach_facelet_event
 #undef _
 };
 
-facelet_t *
-facelet_create()
-{
-    facelet_t * facelet = calloc(1, sizeof(facelet_t));
-    if (!facelet)
-        goto ERR_MALLOC;
-
-    facelet->id = 0;
-
-    facelet->netdevice_status = FACELET_ATTR_STATUS_UNSET;
-    facelet->netdevice_type_status = FACELET_ATTR_STATUS_UNSET;
-    facelet->family_status = FACELET_ATTR_STATUS_UNSET;
-    facelet->local_addr_status = FACELET_ATTR_STATUS_UNSET;
-    facelet->local_port_status = FACELET_ATTR_STATUS_UNSET;
-    facelet->remote_addr_status = FACELET_ATTR_STATUS_UNSET;
-    facelet->remote_port_status = FACELET_ATTR_STATUS_UNSET;
-    facelet->admin_state_status = FACELET_ATTR_STATUS_UNSET;
-    facelet->state_status = FACELET_ATTR_STATUS_UNSET;
+facelet_t *facelet_create() {
+  facelet_t *facelet = calloc(1, sizeof(facelet_t));
+  if (!facelet) goto ERR_MALLOC;
+
+  facelet->id = 0;
+
+  facelet->netdevice_status = FACELET_ATTR_STATUS_UNSET;
+  facelet->netdevice_type_status = FACELET_ATTR_STATUS_UNSET;
+  facelet->family_status = FACELET_ATTR_STATUS_UNSET;
+  facelet->local_addr_status = FACELET_ATTR_STATUS_UNSET;
+  facelet->local_port_status = FACELET_ATTR_STATUS_UNSET;
+  facelet->remote_addr_status = FACELET_ATTR_STATUS_UNSET;
+  facelet->remote_port_status = FACELET_ATTR_STATUS_UNSET;
+  facelet->admin_state_status = FACELET_ATTR_STATUS_UNSET;
+  facelet->state_status = FACELET_ATTR_STATUS_UNSET;
 #ifdef WITH_POLICY
-    facelet->priority_status = FACELET_ATTR_STATUS_UNSET;
+  facelet->priority_status = FACELET_ATTR_STATUS_UNSET;
 #endif /* WITH_POLICY */
-    facelet->face_type_status = FACELET_ATTR_STATUS_UNSET;
+  facelet->face_type_status = FACELET_ATTR_STATUS_UNSET;
 
-    facelet->status = FACELET_STATUS_UNDEFINED;
-    facelet->error = 0;
+  facelet->status = FACELET_STATUS_UNDEFINED;
+  facelet->error = 0;
 
-    facelet->bj_done = false;
-    facelet->au_done = false;
+  facelet->bj_done = false;
 
-    facelet->event = FACELET_EVENT_UNDEFINED;
+  facelet->event = FACELET_EVENT_UNDEFINED;
 
-    facelet->routes = route_set_create();
-    if (!facelet->routes) {
-        ERROR("[facelet_create] Cannot create route set");
-        goto ERR_ROUTE_SET;
-    }
-    facelet->routes_done = false;
+  facelet->routes = route_set_create();
+  if (!facelet->routes) {
+    ERROR("[facelet_create] Cannot create route set");
+    goto ERR_ROUTE_SET;
+  }
+  facelet->routes_done = false;
 
-    return facelet;
+  return facelet;
 
 ERR_ROUTE_SET:
-    free(facelet);
+  free(facelet);
 ERR_MALLOC:
-    return NULL;
+  return NULL;
 }
 
-unsigned
-facelet_get_id(facelet_t * facelet)
-{
-    return facelet->id;
-}
+unsigned facelet_get_id(facelet_t *facelet) { return facelet->id; }
 
-void
-facelet_set_id(facelet_t * facelet, unsigned id)
-{
-    facelet->id = id;
-}
+void facelet_set_id(facelet_t *facelet, unsigned id) { facelet->id = id; }
 
-facelet_t *
-facelet_create_from_netdevice(netdevice_t * netdevice)
-{
-    facelet_t * facelet = facelet_create();
-    if (!facelet)
-        goto ERR_FACELET;
+facelet_t *facelet_create_from_netdevice(netdevice_t *netdevice) {
+  facelet_t *facelet = facelet_create();
+  if (!facelet) goto ERR_FACELET;
 
-    int rc = facelet_set_netdevice(facelet, *netdevice);
-    if (rc < 0)
-        goto ERR_NETDEV;
+  int rc = facelet_set_netdevice(facelet, *netdevice);
+  if (rc < 0) goto ERR_NETDEV;
 
-    return facelet;
+  return facelet;
 
 ERR_NETDEV:
-    facelet_free(facelet);
+  facelet_free(facelet);
 ERR_FACELET:
-    return NULL;
+  return NULL;
 }
 
 /**
@@ -186,368 +166,339 @@ ERR_FACELET:
  * \param [in] facelet - Pointer to the facelet to verify
  * \return 0 in case of success, -1 otherwise
  */
-int
-facelet_validate_face(const facelet_t * facelet)
-{
-    if (!facelet_has_face_type(facelet))
-        return false;
-    switch(facelet->face_type.layer) {
-        case FACE_TYPE_LAYER_4:
-            if (!facelet_has_remote_port(facelet))
-                return false;
-            if (!facelet_has_remote_addr(facelet))
-                return false;
-        case FACE_TYPE_LAYER_3:
-            if (!facelet_has_local_port(facelet))
-                return false;
-            if (!facelet_has_local_addr(facelet))
-                return false;
-            if (!facelet_has_netdevice(facelet))
-                return false;
-            return true;
-
-        default:
-            return false; /* Error */
-    }
-    // FIXME Not implemented
-    return 0;
+int facelet_validate_face(const facelet_t *facelet) {
+  if (!facelet_has_face_type(facelet)) return false;
+
+  switch (facelet->face_type.layer) {
+    case FACE_TYPE_LAYER_4:
+      if (!facelet_has_remote_port(facelet)) return false;
+      if (!facelet_has_remote_addr(facelet)) return false;
+    case FACE_TYPE_LAYER_3:
+      if (!facelet_has_local_port(facelet)) return false;
+      if (!facelet_has_local_addr(facelet)) return false;
+      if (!facelet_has_netdevice(facelet)) return false;
+      break;
+
+    default:
+      return false;
+  }
+
+  return true;
 }
 
-
-netdevice_type_t
-netdevice_type_from_face_tags(const face_t * face)
-{
-    policy_tags_t tags = face->tags;
-    if (policy_tags_has(tags, POLICY_TAG_WIRED))
-        return NETDEVICE_TYPE_WIRED;
-    else if (policy_tags_has(tags, POLICY_TAG_WIFI))
-        return NETDEVICE_TYPE_WIFI;
-    else if (policy_tags_has(tags, POLICY_TAG_CELLULAR))
-        return NETDEVICE_TYPE_CELLULAR;
-    return NETDEVICE_TYPE_UNDEFINED;
+netdevice_type_t netdevice_type_from_face_tags(const face_t *face) {
+#ifdef WITH_POLICY
+  policy_tags_t tags = face->tags;
+  if (policy_tags_has(tags, POLICY_TAG_WIRED))
+    return NETDEVICE_TYPE_WIRED;
+  else if (policy_tags_has(tags, POLICY_TAG_WIFI))
+    return NETDEVICE_TYPE_WIFI;
+  else if (policy_tags_has(tags, POLICY_TAG_CELLULAR))
+    return NETDEVICE_TYPE_CELLULAR;
+#endif /* WITH_POLICY */
+  return NETDEVICE_TYPE_UNDEFINED;
 }
 
-facelet_t *
-facelet_create_from_face(face_t * face)
-{
-    facelet_t * facelet = malloc(sizeof(facelet_t));
-    if (!facelet)
-        goto ERR_MALLOC;
+facelet_t *facelet_create_from_face(face_t *face) {
+  facelet_t *facelet = malloc(sizeof(facelet_t));
+  if (!facelet) goto ERR_MALLOC;
 
-    facelet->id = 0;
+  facelet->id = 0;
 
-    /* Go through the face attributes to update the local representation */
+  /* Go through the face attributes to update the local representation */
 
-    /* Attribute : netdevice */
-    /* NOTE index is not set */
-    if (IS_VALID_NETDEVICE(face->netdevice)) {
-        /* /!\ A face has only the netdevice name */
-        netdevice_set_name(&facelet->netdevice, face->netdevice.name);
-        facelet->netdevice_status = FACELET_ATTR_STATUS_CLEAN;
+  /* Attribute : netdevice */
+  /* NOTE index is not set */
+  if (IS_VALID_NETDEVICE(face->netdevice)) {
+    /* /!\ A face has only the netdevice name */
+    netdevice_set_name(&facelet->netdevice, face->netdevice.name);
+    facelet->netdevice_status = FACELET_ATTR_STATUS_CLEAN;
+  } else {
+    facelet->netdevice_status = FACELET_ATTR_STATUS_UNSET;
+  }
+
+  /* Attribute : netdevice_type */
+  facelet->netdevice_type = netdevice_type_from_face_tags(face);
+  if (facelet->netdevice_type != NETDEVICE_TYPE_UNDEFINED) {
+    facelet->netdevice_type_status = FACELET_ATTR_STATUS_CLEAN;
+  } else {
+    facelet->netdevice_type = NETDEVICE_TYPE_UNDEFINED;
+    facelet->netdevice_type_status = FACELET_ATTR_STATUS_UNSET;
+  }
+
+  /* Attribute : family */
+  if (IS_VALID_FAMILY(face->family)) {
+    facelet->family = face->family;
+    facelet->family_status = FACELET_ATTR_STATUS_CLEAN;
+
+    /* Attribute : local_addr  */
+    if (ip_address_cmp(&face->local_addr, &IP_ADDRESS_EMPTY, face->family) !=
+        0) {
+      facelet->local_addr = face->local_addr;
+      facelet->local_addr_status = FACELET_ATTR_STATUS_CLEAN;
     } else {
-        facelet->netdevice_status = FACELET_ATTR_STATUS_UNSET;
+      facelet->local_addr_status = FACELET_ATTR_STATUS_UNSET;
     }
 
-    /* Attribute : netdevice_type */
-    facelet->netdevice_type = netdevice_type_from_face_tags(face);
-    if (facelet->netdevice_type != NETDEVICE_TYPE_UNDEFINED) {
-        facelet->netdevice_type_status = FACELET_ATTR_STATUS_CLEAN;
+    /* Attribute : local_port  */
+    if (IS_VALID_PORT(face->local_port)) {
+      facelet->local_port = face->local_port;
+      facelet->local_port_status = FACELET_ATTR_STATUS_CLEAN;
     } else {
-        facelet->netdevice_type = NETDEVICE_TYPE_UNDEFINED;
-        facelet->netdevice_type_status = FACELET_ATTR_STATUS_UNSET;
+      facelet->local_port_status = FACELET_ATTR_STATUS_UNSET;
     }
 
-    /* Attribute : family */
-    if (IS_VALID_FAMILY(face->family)) {
-        facelet->family = face->family;
-        facelet->family_status = FACELET_ATTR_STATUS_CLEAN;
-
-        /* Attribute : local_addr  */
-        if (ip_address_cmp(&face->local_addr, &IP_ADDRESS_EMPTY, face->family) != 0) {
-            facelet->local_addr = face->local_addr;
-            facelet->local_addr_status = FACELET_ATTR_STATUS_CLEAN;
-        } else {
-            facelet->local_addr_status = FACELET_ATTR_STATUS_UNSET;
-        }
-
-        /* Attribute : local_port  */
-        if (IS_VALID_PORT(face->local_port)) {
-            facelet->local_port = face->local_port;
-            facelet->local_port_status = FACELET_ATTR_STATUS_CLEAN;
-        } else {
-            facelet->local_port_status = FACELET_ATTR_STATUS_UNSET;
-        }
-
-        /* Attribute : remote_addr  */
-        if (ip_address_cmp(&face->remote_addr, &IP_ADDRESS_EMPTY, face->family) != 0) {
-            facelet->remote_addr = face->remote_addr;
-            facelet->remote_addr_status = FACELET_ATTR_STATUS_CLEAN;
-        } else {
-            facelet->remote_addr_status = FACELET_ATTR_STATUS_UNSET;
-        }
-
-        /* Attribute : remote_port  */
-        if (IS_VALID_PORT(face->remote_port)) {
-            facelet->remote_port = face->remote_port;
-            facelet->remote_port_status = FACELET_ATTR_STATUS_CLEAN;
-        } else {
-            facelet->remote_port_status = FACELET_ATTR_STATUS_UNSET;
-        }
-
+    /* Attribute : remote_addr  */
+    if (ip_address_cmp(&face->remote_addr, &IP_ADDRESS_EMPTY, face->family) !=
+        0) {
+      facelet->remote_addr = face->remote_addr;
+      facelet->remote_addr_status = FACELET_ATTR_STATUS_CLEAN;
     } else {
-        facelet->family_status = FACELET_ATTR_STATUS_UNSET;
-        facelet->local_addr_status = FACELET_ATTR_STATUS_UNSET;
-        facelet->local_port_status = FACELET_ATTR_STATUS_UNSET;
-        facelet->remote_addr_status = FACELET_ATTR_STATUS_UNSET;
-        facelet->remote_port_status = FACELET_ATTR_STATUS_UNSET;
+      facelet->remote_addr_status = FACELET_ATTR_STATUS_UNSET;
     }
 
-    /* Attribute : admin_state */
-    if ((face->admin_state == FACE_STATE_UP) ||
-            (face->admin_state == FACE_STATE_DOWN)) {
-        facelet->admin_state = face->admin_state;
-        facelet->admin_state_status = FACELET_ATTR_STATUS_CLEAN;
+    /* Attribute : remote_port  */
+    if (IS_VALID_PORT(face->remote_port)) {
+      facelet->remote_port = face->remote_port;
+      facelet->remote_port_status = FACELET_ATTR_STATUS_CLEAN;
     } else {
-        facelet->admin_state_status = FACELET_ATTR_STATUS_UNSET;
+      facelet->remote_port_status = FACELET_ATTR_STATUS_UNSET;
     }
 
-    /* Attribute : state */
-    if ((face->state == FACE_STATE_UP) ||
-            (face->state == FACE_STATE_DOWN)) {
-        facelet->state = face->state;
-        facelet->state_status = FACELET_ATTR_STATUS_CLEAN;
-    } else {
-        facelet->state_status = FACELET_ATTR_STATUS_UNSET;
-    }
+  } else {
+    facelet->family_status = FACELET_ATTR_STATUS_UNSET;
+    facelet->local_addr_status = FACELET_ATTR_STATUS_UNSET;
+    facelet->local_port_status = FACELET_ATTR_STATUS_UNSET;
+    facelet->remote_addr_status = FACELET_ATTR_STATUS_UNSET;
+    facelet->remote_port_status = FACELET_ATTR_STATUS_UNSET;
+  }
+
+  /* Attribute : admin_state */
+  if ((face->admin_state == FACE_STATE_UP) ||
+      (face->admin_state == FACE_STATE_DOWN)) {
+    facelet->admin_state = face->admin_state;
+    facelet->admin_state_status = FACELET_ATTR_STATUS_CLEAN;
+  } else {
+    facelet->admin_state_status = FACELET_ATTR_STATUS_UNSET;
+  }
+
+  /* Attribute : state */
+  if ((face->state == FACE_STATE_UP) || (face->state == FACE_STATE_DOWN)) {
+    facelet->state = face->state;
+    facelet->state_status = FACELET_ATTR_STATUS_CLEAN;
+  } else {
+    facelet->state_status = FACELET_ATTR_STATUS_UNSET;
+  }
 
 #ifdef WITH_POLICY
-    /* Attribute : priority */
-    if (face->priority > 0) {
-        facelet->priority = face->priority;
-        facelet->priority_status = FACELET_ATTR_STATUS_CLEAN;
-    } else {
-        facelet->priority_status = FACELET_ATTR_STATUS_UNSET;
-    }
+  /* Attribute : priority */
+  if (face->priority > 0) {
+    facelet->priority = face->priority;
+    facelet->priority_status = FACELET_ATTR_STATUS_CLEAN;
+  } else {
+    facelet->priority_status = FACELET_ATTR_STATUS_UNSET;
+  }
 #endif /* WITH_POLICY */
 
-    /* Attribute : face_type */
-    if ((face->type != FACE_TYPE_UNDEFINED) && (face->type != FACE_TYPE_N)) {
-        switch(face->type) {
-            case FACE_TYPE_UDP:
-                facelet->face_type = FACEMGR_FACE_TYPE_OVERLAY_UDP;
-                break;
-            case FACE_TYPE_TCP:
-                facelet->face_type = FACEMGR_FACE_TYPE_OVERLAY_TCP;
-                break;
-            case FACE_TYPE_HICN:
-                facelet->face_type = FACEMGR_FACE_TYPE_NATIVE_TCP;
-                break;
-            default:
-                ERROR("[facelet_create_from_face] Face type not (yet) implemented");
-                goto ERR_FACE;
-        }
-        facelet->face_type_status = FACELET_ATTR_STATUS_CLEAN;
-    } else {
-        facelet->face_type_status = FACELET_ATTR_STATUS_UNSET;
+  /* Attribute : face_type */
+  if ((face->type != FACE_TYPE_UNDEFINED) && (face->type != FACE_TYPE_N)) {
+    switch (face->type) {
+      case FACE_TYPE_UDP:
+        facelet->face_type = FACEMGR_FACE_TYPE_OVERLAY_UDP;
+        break;
+      case FACE_TYPE_TCP:
+        facelet->face_type = FACEMGR_FACE_TYPE_OVERLAY_TCP;
+        break;
+      case FACE_TYPE_HICN:
+        facelet->face_type = FACEMGR_FACE_TYPE_NATIVE_TCP;
+        break;
+      default:
+        ERROR("[facelet_create_from_face] Face type not (yet) implemented");
+        goto ERR_FACE;
     }
+    facelet->face_type_status = FACELET_ATTR_STATUS_CLEAN;
+  } else {
+    facelet->face_type_status = FACELET_ATTR_STATUS_UNSET;
+  }
 
-    /* Status */
-    facelet->status = FACELET_STATUS_CLEAN;
-    facelet->error = 0;
+  /* Status */
+  facelet->status = FACELET_STATUS_CLEAN;
+  facelet->error = 0;
 
-    /* TODO Consistency check between face type and found attributes */
-    if (facelet_validate_face(facelet) < 0) {
-        ERROR("[facelet_create_from_face] Cannot validate face");
-        goto ERR_FACE;
-    }
+  /* TODO Consistency check between face type and found attributes */
+  if (facelet_validate_face(facelet) < 0) {
+    ERROR("[facelet_create_from_face] Cannot validate face");
+    goto ERR_FACE;
+  }
 
-    facelet->bj_done = false;
-    facelet->au_done = false;
+  facelet->bj_done = false;
 
-    facelet->event = FACELET_EVENT_UNDEFINED;
+  facelet->event = FACELET_EVENT_UNDEFINED;
 
-    /* We need to get route set */
-    facelet->routes = route_set_create();
-    if (!facelet->routes) {
-        ERROR("[facelet_create_from_face] Cannot create route set");
-        goto ERR_ROUTE_SET;
-    }
-    facelet->routes_done = false;
+  /* We need to get route set */
+  facelet->routes = route_set_create();
+  if (!facelet->routes) {
+    ERROR("[facelet_create_from_face] Cannot create route set");
+    goto ERR_ROUTE_SET;
+  }
+  facelet->routes_done = false;
 
-    return facelet;
+  return facelet;
 
 ERR_ROUTE_SET:
 ERR_FACE:
-    free(facelet);
+  free(facelet);
 ERR_MALLOC:
-    return NULL;
+  return NULL;
 }
 
+void facelet_free(facelet_t *facelet) {
+  /* Workaround: investigate how routes could be NULL */
+  if (!facelet->routes) return;
 
-void
-facelet_free(facelet_t * facelet)
-{
-    /* Free up routes */
-    route_set_clear(facelet->routes);
-    route_set_free(facelet->routes);
-    free(facelet);
+  /* Free up routes */
+  route_set_clear(facelet->routes);
+  route_set_free(facelet->routes);
+  free(facelet);
 }
 
-facelet_t *
-facelet_dup(const facelet_t * current_facelet)
-{
-    facelet_t * facelet = facelet_create();
-    if (!facelet)
-        goto ERR_CREATE;
+facelet_t *facelet_dup(const facelet_t *current_facelet) {
+  facelet_t *facelet = facelet_create();
+  if (!facelet) goto ERR_CREATE;
 
-#define _(TYPE, NAME) facelet-> NAME = current_facelet-> NAME;
-    foreach_facelet_attr
+#define _(TYPE, NAME) facelet->NAME = current_facelet->NAME;
+  foreach_facelet_attr
 #undef _
-#define _(TYPE, NAME) facelet-> NAME ## _status = current_facelet-> NAME ## _status;
-    foreach_facelet_attr
+#define _(TYPE, NAME) facelet->NAME##_status = current_facelet->NAME##_status;
+      foreach_facelet_attr
 #undef _
 
-    facelet->status = current_facelet->status;
-    facelet->event = current_facelet->event;
-
-    facelet->bj_done = current_facelet->bj_done;
-    facelet->au_done = current_facelet->au_done;
-
-    /* Routes */
-    hicn_route_t ** route_array;
-    int n = route_set_get_array(current_facelet->routes, &route_array);
-    if (n < 0) {
-        ERROR("[facelet_free] Error getting route set associated to facelet");
-    } else {
-        for (unsigned i = 0; i < n; i++) {
-            hicn_route_t * route = route_array[i];
-            hicn_route_t * new_route = hicn_route_dup(route);
-            if (!new_route)
-                goto ERR_ROUTE;
-            route_set_add(facelet->routes, new_route);
-        }
+          facelet->status = current_facelet->status;
+  facelet->event = current_facelet->event;
+
+  facelet->bj_done = current_facelet->bj_done;
+
+  /* Routes */
+  hicn_route_t **route_array;
+  int n = route_set_get_array(current_facelet->routes, &route_array);
+  if (n < 0) {
+    ERROR("[facelet_free] Error getting route set associated to facelet");
+  } else {
+    for (unsigned i = 0; i < n; i++) {
+      hicn_route_t *route = route_array[i];
+      if (!route) continue; /* Should not occur */
+      hicn_route_t *new_route = hicn_route_dup(route);
+      if (!new_route) goto ERR_ROUTE;
+      route_set_add(facelet->routes, new_route);
     }
-    free(route_array);
+  }
+  free(route_array);
 
-    return facelet;
+  return facelet;
 
 ERR_ROUTE:
-    /* This will free all routes */
-    facelet_free(facelet);
+  /* This will free all routes */
+  facelet_free(facelet);
 ERR_CREATE:
-    return NULL;
+  return NULL;
 }
 
-int
-facelet_cmp(const facelet_t * f1, const facelet_t * f2)
-{
-    /*
-     * Under the assumption we only create a face per physical interface, a
-     * facelet is uniquely identified by its netdevice attribute, and address
-     * family if any.
-     *
-     * Because of additional static faces, we introduce a unique facelet id
-     *
-     * This function is mostly used for lookups into the cache, and the face
-     * thus needs to have a netdevice associated, and optionally, an address
-     * family.
-     *
-     * For other situations, the `facelet_match` function is more appropriate.
+int facelet_cmp(const facelet_t *f1, const facelet_t *f2) {
+  /*
+   * Under the assumption we only create a face per physical interface, a
+   * facelet is uniquely identified by its netdevice attribute, and address
+   * family if any.
+   *
+   * Because of additional static faces, we introduce a unique facelet id
+   *
+   * This function is mostly used for lookups into the cache, and the face
+   * thus needs to have a netdevice associated, and optionally, an address
+   * family.
+   *
+   * For other situations, the `facelet_match` function is more appropriate.
+   */
+
+  if (f1->id != f2->id) return f1->id > f2->id ? 1 : -1;
+
+  if ((f1->netdevice_status != FACELET_ATTR_STATUS_UNSET) &&
+      (f2->netdevice_status != FACELET_ATTR_STATUS_UNSET)) {
+    int rc = netdevice_cmp(&f1->netdevice, &f2->netdevice);
+    if (rc != 0) return rc;
+
+  } else {
+    /* Both unset : we might have the face without netdevice due to hicn
+     * light not returning it currently, but we cannot skip it in the match
+     * otherwise we cannot distinguish with other faces except matching on
+     * other fields which might unfortunately not be determined yet...
      */
+    return (f1->netdevice_status == FACELET_ATTR_STATUS_UNSET) ? -1 : 1;
+  }
 
-    if (f1->id != f2->id)
-        return f1->id > f2->id ?  1 : -1;
-
-    if ((f1->netdevice_status != FACELET_ATTR_STATUS_UNSET) &&
-            (f2->netdevice_status != FACELET_ATTR_STATUS_UNSET)) {
-        int rc = netdevice_cmp(&f1->netdevice, &f2->netdevice);
-        if (rc != 0)
-            return rc;
-
-    } else {
-        /* Both unset : we might have the face without netdevice due to hicn
-         * light not returning it currently, but we cannot skip it in the match
-         * otherwise we cannot distinguish with other faces except matching on
-         * other fields which might unfortunately not be determined yet...
-         */
-        return (f1->netdevice_status == FACELET_ATTR_STATUS_UNSET) ? -1 : 1;
-    }
-
-    assert(f1->family_status != FACELET_ATTR_STATUS_UNSET);
-    assert(f2->family_status != FACELET_ATTR_STATUS_UNSET);
+  assert(f1->family_status != FACELET_ATTR_STATUS_UNSET);
+  assert(f2->family_status != FACELET_ATTR_STATUS_UNSET);
 
-    if ((f1->family == AF_UNSPEC) || (f2->family == AF_UNSPEC))
-        return 0;
-    int diff = f1->family - f2->family;
-    return (diff > 0) ? 1  :
-           (diff < 0) ? -1 : 0;
+  if ((f1->family == AF_UNSPEC) || (f2->family == AF_UNSPEC)) return 0;
+  int diff = f1->family - f2->family;
+  return (diff > 0) ? 1 : (diff < 0) ? -1 : 0;
 }
 
 /*
  * If the match has a field set, then the facelet only matches iif it has the
  * same field set, and both values are equal
  */
-#define EQUALS_ATTRIBUTE(TYPE, NAME)                                            \
-do {                                                                            \
-    if (facelet_has_ ## NAME(facelet1)) {                                       \
-        if (facelet_has_ ## NAME(facelet2)) {                                   \
-            TYPE NAME ## 1;                                                     \
-            TYPE NAME ## 2;                                                     \
-            if (facelet_get_ ## NAME (facelet1, & NAME ## 1) < 0)               \
-                return false;                                                   \
-            if (facelet_get_ ## NAME (facelet2, & NAME ## 2) < 0)               \
-                return false;                                                   \
-            if (memcmp(& NAME ## 1, & NAME ## 2, sizeof(TYPE)) != 0)            \
-                return false;                                                   \
-        } else {                                                                \
-            return false;                                                       \
-        }                                                                       \
-    } else {                                                                    \
-        if (facelet_has_ ## NAME(facelet2)) {                                   \
-            return false;                                                       \
-        }                                                                       \
-    }                                                                           \
-} while(0)
-
-bool
-facelet_equals(const facelet_t * facelet1, const facelet_t * facelet2)
-{
+#define EQUALS_ATTRIBUTE(TYPE, NAME)                                     \
+  do {                                                                   \
+    if (facelet_has_##NAME(facelet1)) {                                  \
+      if (facelet_has_##NAME(facelet2)) {                                \
+        TYPE NAME##1;                                                    \
+        TYPE NAME##2;                                                    \
+        if (facelet_get_##NAME(facelet1, &NAME##1) < 0) return false;    \
+        if (facelet_get_##NAME(facelet2, &NAME##2) < 0) return false;    \
+        if (memcmp(&NAME##1, &NAME##2, sizeof(TYPE)) != 0) return false; \
+      } else {                                                           \
+        return false;                                                    \
+      }                                                                  \
+    } else {                                                             \
+      if (facelet_has_##NAME(facelet2)) {                                \
+        return false;                                                    \
+      }                                                                  \
+    }                                                                    \
+  } while (0)
+
+bool facelet_equals(const facelet_t *facelet1, const facelet_t *facelet2) {
 #define _(TYPE, NAME) EQUALS_ATTRIBUTE(TYPE, NAME);
-    foreach_facelet_attr
+  foreach_facelet_attr
 #undef _
-    return true;
+      return true;
 }
 
 /*
  * If the match has a field set, then the facelet only matches iif it has the
  * same field set, and both values are equal
  */
-#define MATCH_ATTRIBUTE(TYPE, NAME)                                             \
-do {                                                                            \
-    if (facelet_match->NAME ## _status == FACELET_ATTR_STATUS_CLEAN) {          \
-        if (facelet_has_ ## NAME(facelet_match)) {                              \
-            TYPE NAME;                                                          \
-            TYPE NAME ## _match;                                                \
-            if (!facelet_has_ ## NAME(facelet)) {                               \
-                continue; /* return false; */                                   \
-            }                                                                   \
-            if (facelet_get_ ## NAME (facelet, & NAME) < 0)                     \
-                return false;                                                   \
-            if (facelet_get_ ## NAME (facelet_match, & NAME ## _match) < 0)     \
-                return false;                                                   \
-            if (memcmp(& NAME, & NAME ## _match, sizeof(NAME)) != 0) {          \
-                return false;                                                   \
-            }                                                                   \
-        }                                                                       \
-    }                                                                           \
-} while(0)
+#define MATCH_ATTRIBUTE(TYPE, NAME)                                  \
+  do {                                                               \
+    if (facelet_match->NAME##_status == FACELET_ATTR_STATUS_CLEAN) { \
+      if (facelet_has_##NAME(facelet_match)) {                       \
+        TYPE NAME;                                                   \
+        TYPE NAME##_match;                                           \
+        if (!facelet_has_##NAME(facelet)) {                          \
+          continue; /* return false; */                              \
+        }                                                            \
+        if (facelet_get_##NAME(facelet, &NAME) < 0) return false;    \
+        if (facelet_get_##NAME(facelet_match, &NAME##_match) < 0)    \
+          return false;                                              \
+        if (memcmp(&NAME, &NAME##_match, sizeof(NAME)) != 0) {       \
+          return false;                                              \
+        }                                                            \
+      }                                                              \
+    }                                                                \
+  } while (0)
 
 /* facelet_match is the incoming one */
-bool
-facelet_match(const facelet_t * facelet, const facelet_t * facelet_match)
-{
+bool facelet_match(const facelet_t *facelet, const facelet_t *facelet_match) {
 #define _(TYPE, NAME) MATCH_ATTRIBUTE(TYPE, NAME);
-    foreach_facelet_attr
+  foreach_facelet_attr
 #undef _
 
 #if 0
@@ -557,117 +508,101 @@ facelet_match(const facelet_t * facelet, const facelet_t * facelet_match)
     facelet_snprintf(facelet_s, MAXSZ_FACELET, facelet);
     DEBUG("         WITH %s", facelet_s);
 #endif
-    return true;
+      return true;
 }
 
-bool facelet_has_key(const facelet_t * facelet) {
-    return (facelet_has_netdevice(facelet) && facelet_has_family(facelet));
+bool facelet_has_key(const facelet_t *facelet) {
+  return (facelet_has_netdevice(facelet) && facelet_has_family(facelet));
 }
 
 /*
  * Implementation note:
  * - facelet_set_* is equivalent to merge with a CLEAN remote attribute
  */
-#define FACELET_ACCESSORS(TYPE, NAME)                                           \
-bool                                                                            \
-facelet_has_ ## NAME(const facelet_t * facelet)                                 \
-{                                                                               \
-    assert(facelet);                                                            \
-    assert(facelet->NAME ## _status != FACELET_ATTR_STATUS_UNDEFINED);          \
-    assert(facelet->NAME ## _status != FACELET_ATTR_STATUS_N);                  \
-    return ((facelet-> NAME ## _status != FACELET_ATTR_STATUS_UNSET));          \
-}                                                                               \
-                                                                                \
-facelet_attr_status_t                                                           \
-facelet_get_ ## NAME ## _status(const facelet_t * facelet)                      \
-{                                                                               \
-    return (facelet->NAME ## _status);                                          \
-}                                                                               \
-                                                                                \
-void                                                                            \
-facelet_set_ ## NAME ## _status(facelet_t * facelet,                            \
-        facelet_attr_status_t status)                                           \
-{                                                                               \
-    facelet->NAME ## _status = status;                                          \
-}                                                                               \
-                                                                                \
-int                                                                             \
-facelet_get_ ## NAME(const facelet_t * facelet, TYPE * NAME)                    \
-{                                                                               \
-    assert(facelet);                                                            \
-    if (!facelet_has_ ## NAME(facelet))                                         \
-        return -1;                                                              \
-    *NAME = facelet-> NAME;                                                     \
-    return 0;                                                                   \
-}                                                                               \
-                                                                                \
-int                                                                             \
-facelet_set_local_ ## NAME(facelet_t * facelet, TYPE NAME)                      \
-{                                                                               \
-    assert(facelet);                                                            \
-    switch(facelet->NAME ## _status) {                                          \
-        case FACELET_ATTR_STATUS_UNSET:                                         \
-        case FACELET_ATTR_STATUS_CLEAN:                                         \
-        case FACELET_ATTR_STATUS_DIRTY:                                         \
-        case FACELET_ATTR_STATUS_PENDING:                                       \
-            facelet-> NAME = NAME;                                              \
-            facelet->NAME ## _status = FACELET_ATTR_STATUS_DIRTY;               \
-            if (facelet->status == FACELET_STATUS_CLEAN)                        \
-                facelet->status = FACELET_STATUS_UPDATE;                        \
-            break;                                                              \
-        case FACELET_ATTR_STATUS_CONFLICT:                                      \
-            break;                                                              \
-        case FACELET_ATTR_STATUS_UNDEFINED:                                     \
-        case FACELET_ATTR_STATUS_N:                                             \
-            ERROR("Unexpected attribute status value");                         \
-            return -1;                                                          \
-    }                                                                           \
-    return 0;                                                                   \
-}                                                                               \
-                                                                                \
-int                                                                             \
-facelet_set_remote_ ## NAME(facelet_t * facelet, TYPE NAME)                     \
-{                                                                               \
-    assert(facelet);                                                            \
-    switch(facelet->NAME ## _status) {                                          \
-        case FACELET_ATTR_STATUS_UNSET:                                         \
-            facelet-> NAME = NAME;                                              \
-            facelet->NAME ## _status = FACELET_ATTR_STATUS_CLEAN;               \
-            break;                                                              \
-        case FACELET_ATTR_STATUS_CLEAN:                                         \
-            facelet->NAME = NAME;                                               \
-            break;                                                              \
-        case FACELET_ATTR_STATUS_DIRTY:                                         \
-            ERROR("Discarded remote value for status reasons");                 \
-            break;                                                              \
-        case FACELET_ATTR_STATUS_PENDING:                                       \
-            ERROR("Received remote value on pending attribute");                \
-            facelet->NAME ## _status = FACELET_ATTR_STATUS_CONFLICT;            \
-            /* We need to proceed to an update of the face */                   \
-            if (facelet->status != FACELET_STATUS_UPDATE)                       \
-                facelet->status = FACELET_STATUS_UPDATE;                        \
-            break;                                                              \
-        case FACELET_ATTR_STATUS_CONFLICT:                                      \
-            return -1;                                                          \
-        case FACELET_ATTR_STATUS_UNDEFINED:                                     \
-        case FACELET_ATTR_STATUS_N:                                             \
-            ERROR("Unexpected attribute status value");                         \
-            return -1;                                                          \
-    }                                                                           \
-    return 0;                                                                   \
-}                                                                               \
-                                                                                \
-int                                                                             \
-facelet_set_ ## NAME(facelet_t * facelet, TYPE NAME)                            \
-{                                                                               \
-    return facelet_set_local_ ## NAME(facelet, NAME);                           \
-}                                                                               \
-                                                                                \
-int                                                                             \
-facelet_unset_ ## NAME(facelet_t * facelet)                                     \
-{                                                                               \
-    return facelet->NAME ## _status = FACELET_ATTR_STATUS_UNSET;                \
-}
+#define FACELET_ACCESSORS(TYPE, NAME)                                \
+  bool facelet_has_##NAME(const facelet_t *facelet) {                \
+    assert(facelet);                                                 \
+    assert(facelet->NAME##_status != FACELET_ATTR_STATUS_UNDEFINED); \
+    assert(facelet->NAME##_status != FACELET_ATTR_STATUS_N);         \
+    return ((facelet->NAME##_status != FACELET_ATTR_STATUS_UNSET));  \
+  }                                                                  \
+                                                                     \
+  facelet_attr_status_t facelet_get_##NAME##_status(                 \
+      const facelet_t *facelet) {                                    \
+    return (facelet->NAME##_status);                                 \
+  }                                                                  \
+                                                                     \
+  void facelet_set_##NAME##_status(facelet_t *facelet,               \
+                                   facelet_attr_status_t status) {   \
+    facelet->NAME##_status = status;                                 \
+  }                                                                  \
+                                                                     \
+  int facelet_get_##NAME(const facelet_t *facelet, TYPE *NAME) {     \
+    assert(facelet);                                                 \
+    if (!facelet_has_##NAME(facelet)) return -1;                     \
+    *NAME = facelet->NAME;                                           \
+    return 0;                                                        \
+  }                                                                  \
+                                                                     \
+  int facelet_set_local_##NAME(facelet_t *facelet, TYPE NAME) {      \
+    assert(facelet);                                                 \
+    switch (facelet->NAME##_status) {                                \
+      case FACELET_ATTR_STATUS_UNSET:                                \
+      case FACELET_ATTR_STATUS_CLEAN:                                \
+      case FACELET_ATTR_STATUS_DIRTY:                                \
+      case FACELET_ATTR_STATUS_PENDING:                              \
+        facelet->NAME = NAME;                                        \
+        facelet->NAME##_status = FACELET_ATTR_STATUS_DIRTY;          \
+        if (facelet->status == FACELET_STATUS_CLEAN)                 \
+          facelet->status = FACELET_STATUS_UPDATE;                   \
+        break;                                                       \
+      case FACELET_ATTR_STATUS_CONFLICT:                             \
+        break;                                                       \
+      case FACELET_ATTR_STATUS_UNDEFINED:                            \
+      case FACELET_ATTR_STATUS_N:                                    \
+        ERROR("Unexpected attribute status value");                  \
+        return -1;                                                   \
+    }                                                                \
+    return 0;                                                        \
+  }                                                                  \
+                                                                     \
+  int facelet_set_remote_##NAME(facelet_t *facelet, TYPE NAME) {     \
+    assert(facelet);                                                 \
+    switch (facelet->NAME##_status) {                                \
+      case FACELET_ATTR_STATUS_UNSET:                                \
+        facelet->NAME = NAME;                                        \
+        facelet->NAME##_status = FACELET_ATTR_STATUS_CLEAN;          \
+        break;                                                       \
+      case FACELET_ATTR_STATUS_CLEAN:                                \
+        facelet->NAME = NAME;                                        \
+        break;                                                       \
+      case FACELET_ATTR_STATUS_DIRTY:                                \
+        ERROR("Discarded remote value for status reasons");          \
+        break;                                                       \
+      case FACELET_ATTR_STATUS_PENDING:                              \
+        ERROR("Received remote value on pending attribute");         \
+        facelet->NAME##_status = FACELET_ATTR_STATUS_CONFLICT;       \
+        /* We need to proceed to an update of the face */            \
+        if (facelet->status != FACELET_STATUS_UPDATE)                \
+          facelet->status = FACELET_STATUS_UPDATE;                   \
+        break;                                                       \
+      case FACELET_ATTR_STATUS_CONFLICT:                             \
+        return -1;                                                   \
+      case FACELET_ATTR_STATUS_UNDEFINED:                            \
+      case FACELET_ATTR_STATUS_N:                                    \
+        ERROR("Unexpected attribute status value");                  \
+        return -1;                                                   \
+    }                                                                \
+    return 0;                                                        \
+  }                                                                  \
+                                                                     \
+  int facelet_set_##NAME(facelet_t *facelet, TYPE NAME) {            \
+    return facelet_set_local_##NAME(facelet, NAME);                  \
+  }                                                                  \
+                                                                     \
+  int facelet_unset_##NAME(facelet_t *facelet) {                     \
+    return facelet->NAME##_status = FACELET_ATTR_STATUS_UNSET;       \
+  }
 
 #define _(TYPE, NAME) FACELET_ACCESSORS(TYPE, NAME)
 foreach_facelet_attr
@@ -681,773 +616,630 @@ foreach_facelet_attr
 
 // FIXME CLEAN for key fields, dirty for fields to update.
 
-#define MERGE_ATTRIBUTE(TYPE, NAME)                                                     \
-do {                                                                                    \
-    switch(facelet_to_merge->NAME ## _status) {                                         \
-        case FACELET_ATTR_STATUS_UNDEFINED:                                             \
-        case FACELET_ATTR_STATUS_N:                                                     \
-        case FACELET_ATTR_STATUS_PENDING:                                               \
-        case FACELET_ATTR_STATUS_CONFLICT:                                              \
-            ERROR("Unexpected facelet attribute status");                               \
-            return -1;                                                                  \
-        case FACELET_ATTR_STATUS_UNSET:                                                 \
-            break;                                                                      \
-        case FACELET_ATTR_STATUS_CLEAN:                                                 \
-        case FACELET_ATTR_STATUS_DIRTY:                                                 \
-            facelet_set_ ## NAME(facelet, facelet_to_merge-> NAME);                     \
-            break;                                                                      \
-    }                                                                                   \
-} while (0)
-
-int facelet_merge(facelet_t * facelet, facelet_t * facelet_to_merge)
-{
-    assert(facelet && facelet_to_merge);
+#define MERGE_ATTRIBUTE(TYPE, NAME)                          \
+  do {                                                       \
+    switch (facelet_to_merge->NAME##_status) {               \
+      case FACELET_ATTR_STATUS_UNDEFINED:                    \
+      case FACELET_ATTR_STATUS_N:                            \
+      case FACELET_ATTR_STATUS_PENDING:                      \
+      case FACELET_ATTR_STATUS_CONFLICT:                     \
+        ERROR("Unexpected facelet attribute status");        \
+        return -1;                                           \
+      case FACELET_ATTR_STATUS_UNSET:                        \
+        break;                                               \
+      case FACELET_ATTR_STATUS_CLEAN:                        \
+      case FACELET_ATTR_STATUS_DIRTY:                        \
+        facelet_set_##NAME(facelet, facelet_to_merge->NAME); \
+        break;                                               \
+    }                                                        \
+  } while (0)
+
+    int
+    facelet_merge(facelet_t *facelet, facelet_t *facelet_to_merge) {
+  assert(facelet && facelet_to_merge);
 
 #define _(TYPE, NAME) MERGE_ATTRIBUTE(TYPE, NAME);
-    foreach_facelet_attr
+  foreach_facelet_attr
 #undef _
-    facelet->event = facelet_to_merge->event;
-
-    /* Routes */
-    hicn_route_t ** route_array;
-    int n = route_set_get_array(facelet_to_merge->routes, &route_array);
-    if (n < 0) {
-        ERROR("[facelet_free] Error getting route set associated to facelet");
-    } else {
-        for (unsigned i = 0; i < n; i++) {
-            hicn_route_t * route = route_array[i];
-            hicn_route_t * route_found = NULL;
-            if (route_set_get(facelet->routes, route, &route_found) < 0) {
-                ERROR("Error searching for route");
-                continue;
-            }
-            if (route_found)
-                continue;
-            route_set_add(facelet->routes, hicn_route_dup(route));
-        }
+      facelet->event = facelet_to_merge->event;
+
+  /* Routes */
+  hicn_route_t **route_array;
+  int n = route_set_get_array(facelet_to_merge->routes, &route_array);
+  if (n < 0) {
+    ERROR("[facelet_free] Error getting route set associated to facelet");
+  } else {
+    for (unsigned i = 0; i < n; i++) {
+      hicn_route_t *route = route_array[i];
+      if (!route) continue; /* Should not occur */
+      hicn_route_t *route_found = NULL;
+      if (route_set_get(facelet->routes, route, &route_found) < 0) {
+        ERROR("Error searching for route");
+        continue;
+      }
+      if (route_found) continue;
+      route_set_add(facelet->routes, hicn_route_dup(route));
     }
-    free(route_array);
+  }
+  free(route_array);
 
-    return 0;
+  return 0;
 }
 
-#define MERGE_ATTRIBUTE_REMOTE(TYPE, NAME)                                              \
-do {                                                                                    \
-    switch(facelet_to_merge->NAME ## _status) {                                         \
-        case FACELET_ATTR_STATUS_UNDEFINED:                                             \
-        case FACELET_ATTR_STATUS_N:                                                     \
-        case FACELET_ATTR_STATUS_DIRTY:                                                 \
-        case FACELET_ATTR_STATUS_PENDING:                                               \
-        case FACELET_ATTR_STATUS_CONFLICT:                                              \
-            ERROR("Unexpected facelet attribute status");                               \
-            return -1;                                                                  \
-        case FACELET_ATTR_STATUS_UNSET:                                                 \
-            break;                                                                      \
-        case FACELET_ATTR_STATUS_CLEAN:                                                 \
-            facelet_set_ ## NAME(facelet, facelet_to_merge-> NAME);                     \
-            break;                                                                      \
-                                                                                        \
-    }                                                                                   \
-} while (0)
-
-int facelet_merge_remote(facelet_t * facelet, const facelet_t * facelet_to_merge)
-{
-    assert(facelet && facelet_to_merge);
+#define MERGE_ATTRIBUTE_REMOTE(TYPE, NAME)                   \
+  do {                                                       \
+    switch (facelet_to_merge->NAME##_status) {               \
+      case FACELET_ATTR_STATUS_UNDEFINED:                    \
+      case FACELET_ATTR_STATUS_N:                            \
+      case FACELET_ATTR_STATUS_DIRTY:                        \
+      case FACELET_ATTR_STATUS_PENDING:                      \
+      case FACELET_ATTR_STATUS_CONFLICT:                     \
+        ERROR("Unexpected facelet attribute status");        \
+        return -1;                                           \
+      case FACELET_ATTR_STATUS_UNSET:                        \
+        break;                                               \
+      case FACELET_ATTR_STATUS_CLEAN:                        \
+        facelet_set_##NAME(facelet, facelet_to_merge->NAME); \
+        break;                                               \
+    }                                                        \
+  } while (0)
+
+int facelet_merge_remote(facelet_t *facelet,
+                         const facelet_t *facelet_to_merge) {
+  assert(facelet && facelet_to_merge);
 #define _(TYPE, NAME) MERGE_ATTRIBUTE_REMOTE(TYPE, NAME);
-    foreach_facelet_attr
+  foreach_facelet_attr
 #undef _
-    facelet->event = facelet_to_merge->event;
-    return 0;
+      facelet->event = facelet_to_merge->event;
+  return 0;
 }
 
-int
-facelet_get_face(const facelet_t * facelet, face_t ** pface)
-{
-    assert(pface);
-
-    /* Facelet has all the required information to create a face */
-    if (facelet_validate_face(facelet) < 0) {
-        ERROR("[facelet_get_face] Face does not validate");
-        return 0;
-    }
+int facelet_get_face(const facelet_t *facelet, face_t **pface) {
+  assert(pface);
 
-    face_t * face = face_create();
-    if (!face)
-        goto ERR_CREATE;
-
-    assert(facelet_has_netdevice(facelet));
-    face->netdevice = facelet->netdevice;
-
-    /* Face type */
-    switch(facelet->face_type.layer) {
-        case FACE_TYPE_LAYER_4:
-            switch(facelet->face_type.encap) {
-                case FACE_TYPE_ENCAP_UDP:
-                    face->type = FACE_TYPE_UDP;
-                    break;
-                case FACE_TYPE_ENCAP_TCP:
-                    face->type = FACE_TYPE_TCP;
-                    break;
-                case FACE_TYPE_ENCAP_UNDEFINED:
-                case FACE_TYPE_ENCAP_N:
-                    ERROR("[facelet_get_face] Unsupported face encapsulation");
-                    goto ERR;
-            }
-
-            if (facelet_get_family(facelet, &face->family) < 0) {
-                ERROR("[facelet_get_face] Error retrieving face family");
-                goto ERR;
-            }
-            if (facelet_get_local_addr(facelet, &face->local_addr) < 0) {
-                ERROR("[facelet_get_face] Error retrieving face local address");
-                goto ERR;
-            }
-            if (facelet_get_local_port(facelet, &face->local_port) < 0) {
-                ERROR("[facelet_get_face] Error retrieving face local port");
-                goto ERR;
-            }
-            if (facelet_get_remote_addr(facelet, &face->remote_addr) < 0) {
-                ERROR("[facelet_get_face] Error retrieving face remote address");
-                goto ERR;
-            }
-            if (facelet_get_remote_port(facelet, &face->remote_port) < 0) {
-                ERROR("[facelet_get_face] Error retrieving face remote port");
-                goto ERR;
-            }
-            break;
-
-        case FACE_TYPE_LAYER_3:
-            ERROR("{facelet_get_face] hICN face not (yet) implemented");
-            goto ERR;
-
-        case FACE_TYPE_LAYER_UNDEFINED:
-        case FACE_TYPE_LAYER_N:
-            ERROR("[facelet_get_face] Unsupported face type");
-            goto ERR;
-    }
-
-    if (facelet_has_admin_state(facelet)) {
-        if (facelet_get_admin_state(facelet, &face->admin_state) < 0) {
-            ERROR("[facelet_get_face] Error getting face admin state");
-            goto ERR;
-        }
-    } else {
-        face->admin_state = FACE_STATE_UP;
+  /* Facelet has all the required information to create a face */
+  if (facelet_validate_face(facelet) < 0) {
+    ERROR("[facelet_get_face] Face does not validate");
+    return 0;
+  }
+
+  face_t *face = face_create();
+  if (!face) goto ERR_CREATE;
+
+  assert(facelet_has_netdevice(facelet));
+  face->netdevice = facelet->netdevice;
+
+  /* Face type */
+  switch (facelet->face_type.layer) {
+    case FACE_TYPE_LAYER_4:
+      switch (facelet->face_type.encap) {
+        case FACE_TYPE_ENCAP_UDP:
+          face->type = FACE_TYPE_UDP;
+          break;
+        case FACE_TYPE_ENCAP_TCP:
+          face->type = FACE_TYPE_TCP;
+          break;
+        case FACE_TYPE_ENCAP_UNDEFINED:
+        case FACE_TYPE_ENCAP_N:
+          ERROR("[facelet_get_face] Unsupported face encapsulation");
+          goto ERR;
+      }
+
+      if (facelet_get_family(facelet, &face->family) < 0) {
+        ERROR("[facelet_get_face] Error retrieving face family");
+        goto ERR;
+      }
+      if (facelet_get_local_addr(facelet, &face->local_addr) < 0) {
+        ERROR("[facelet_get_face] Error retrieving face local address");
+        goto ERR;
+      }
+      if (facelet_get_local_port(facelet, &face->local_port) < 0) {
+        ERROR("[facelet_get_face] Error retrieving face local port");
+        goto ERR;
+      }
+      if (facelet_get_remote_addr(facelet, &face->remote_addr) < 0) {
+        ERROR("[facelet_get_face] Error retrieving face remote address");
+        goto ERR;
+      }
+      if (facelet_get_remote_port(facelet, &face->remote_port) < 0) {
+        ERROR("[facelet_get_face] Error retrieving face remote port");
+        goto ERR;
+      }
+      break;
+
+    case FACE_TYPE_LAYER_3:
+      ERROR("{facelet_get_face] hICN face not (yet) implemented");
+      goto ERR;
+
+    case FACE_TYPE_LAYER_UNDEFINED:
+    case FACE_TYPE_LAYER_N:
+      ERROR("[facelet_get_face] Unsupported face type");
+      goto ERR;
+  }
+
+  if (facelet_has_admin_state(facelet)) {
+    if (facelet_get_admin_state(facelet, &face->admin_state) < 0) {
+      ERROR("[facelet_get_face] Error getting face admin state");
+      goto ERR;
     }
-
-    if (facelet_has_state(facelet)) {
-        if (facelet_get_state(facelet, &face->state) < 0) {
-            ERROR("[facelet_get_face] Error getting face state");
-            goto ERR;
-        }
-    } else {
-        face->state = FACE_STATE_UP;
+  } else {
+    face->admin_state = FACE_STATE_UP;
+  }
+
+  if (facelet_has_state(facelet)) {
+    if (facelet_get_state(facelet, &face->state) < 0) {
+      ERROR("[facelet_get_face] Error getting face state");
+      goto ERR;
     }
+  } else {
+    face->state = FACE_STATE_UP;
+  }
 
 #ifdef WITH_POLICY
-    /* Priority */
-    if (facelet_has_priority(facelet)) {
-        if (facelet_get_priority(facelet, &face->priority) < 0) {
-            ERROR("[facelet_get_face] Error getting face priority");
-            goto ERR;
-        }
-    } else {
-        face->priority = 0;
+  /* Priority */
+  if (facelet_has_priority(facelet)) {
+    if (facelet_get_priority(facelet, &face->priority) < 0) {
+      ERROR("[facelet_get_face] Error getting face priority");
+      goto ERR;
+    }
+  } else {
+    face->priority = 0;
+  }
+
+  /* Tags */
+
+  /* - based on netdevice type */
+  policy_tags_t tags = POLICY_TAGS_EMPTY;
+  if (facelet_has_netdevice_type(facelet)) {
+    netdevice_type_t netdevice_type;
+    if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) {
+      ERROR("error getting netdevice_type");
+      goto ERR;
     }
 
-    /* Tags */
-
-    /* - based on netdevice type */
-    policy_tags_t tags = POLICY_TAGS_EMPTY;
-    if (facelet_has_netdevice_type(facelet)) {
-        netdevice_type_t netdevice_type;
-        if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) {
-            ERROR("error getting netdevice_type");
-            goto ERR;
-        }
-
-
-        switch(netdevice_type) {
-            case NETDEVICE_TYPE_UNDEFINED:
-            case NETDEVICE_TYPE_LOOPBACK:
-                break;
-            case NETDEVICE_TYPE_WIRED:
-                policy_tags_add(&tags, POLICY_TAG_WIRED);
-                break;
-            case NETDEVICE_TYPE_WIFI:
-                policy_tags_add(&tags, POLICY_TAG_WIFI);
-                break;
-            case NETDEVICE_TYPE_CELLULAR:
-                policy_tags_add(&tags, POLICY_TAG_CELLULAR);
-                break;
-            default:
-                goto ERR;
-        }
+    switch (netdevice_type) {
+      case NETDEVICE_TYPE_UNDEFINED:
+      case NETDEVICE_TYPE_LOOPBACK:
+        break;
+      case NETDEVICE_TYPE_WIRED:
+        policy_tags_add(&tags, POLICY_TAG_WIRED);
+        break;
+      case NETDEVICE_TYPE_WIFI:
+        policy_tags_add(&tags, POLICY_TAG_WIFI);
+        break;
+      case NETDEVICE_TYPE_CELLULAR:
+        policy_tags_add(&tags, POLICY_TAG_CELLULAR);
+        break;
+      default:
+        goto ERR;
     }
-    face->tags = tags;
+  }
+  face->tags = tags;
 #endif /* WITH_POLICY */
 
-    *pface = face;
+  *pface = face;
 
-    return 0;
+  return 0;
 
 ERR:
-    free(face);
+  free(face);
 ERR_CREATE:
-    *pface = NULL;
-    return -1;
+  *pface = NULL;
+  return -1;
 }
 
-facelet_status_t
-facelet_get_status(const facelet_t * facelet)
-{
-    return facelet->status;
+facelet_status_t facelet_get_status(const facelet_t *facelet) {
+  return facelet->status;
 }
 
-void
-facelet_set_status(facelet_t * facelet, facelet_status_t status)
-{
-    facelet->status = status;
+void facelet_set_status(facelet_t *facelet, facelet_status_t status) {
+  facelet->status = status;
 }
 
-#define SET_ATTR_STATUS_CLEAN(TYPE, NAME)                       \
-do {                                                            \
-    if (facelet->NAME ## _status  == FACELET_ATTR_STATUS_DIRTY) \
-        facelet->NAME ## _status = FACELET_ATTR_STATUS_CLEAN;   \
-} while (0)
+#define SET_ATTR_STATUS_CLEAN(TYPE, NAME)                    \
+  do {                                                       \
+    if (facelet->NAME##_status == FACELET_ATTR_STATUS_DIRTY) \
+      facelet->NAME##_status = FACELET_ATTR_STATUS_CLEAN;    \
+  } while (0)
 
-void
-facelet_set_attr_clean(facelet_t * facelet)
-{
+void facelet_set_attr_clean(facelet_t *facelet) {
 #define _(TYPE, NAME) SET_ATTR_STATUS_CLEAN(TYPE, NAME);
-    foreach_facelet_attr
+  foreach_facelet_attr
 #undef _
 }
 
-void
-facelet_set_error(facelet_t * facelet, facelet_error_reason_t reason)
-{
-    facelet->error++;
-    switch(reason) {
-        case FACELET_ERROR_REASON_UNSPECIFIED_ERROR:
-        case FACELET_ERROR_REASON_INTERNAL_ERROR:
-        case FACELET_ERROR_REASON_PERMISSION_DENIED:
-            if (facelet->error >= FACELET_MAX_ERRORS)
-                facelet_set_status(facelet, FACELET_STATUS_IGNORED);
-            break;
-        case FACELET_ERROR_REASON_FORWARDER_OFFLINE:
-            break;
-        case FACELET_ERROR_REASON_UNDEFINED:
-        case FACELET_ERROR_REASON_N:
-            ERROR("facelet_set_error] Unexpected error reason");
-            break;
-    }
+void facelet_set_error(facelet_t *facelet, facelet_error_reason_t reason) {
+  facelet->error++;
+  switch (reason) {
+    case FACELET_ERROR_REASON_UNSPECIFIED_ERROR:
+    case FACELET_ERROR_REASON_INTERNAL_ERROR:
+    case FACELET_ERROR_REASON_PERMISSION_DENIED:
+      if (facelet->error >= FACELET_MAX_ERRORS)
+        facelet_set_status(facelet, FACELET_STATUS_IGNORED);
+      break;
+    case FACELET_ERROR_REASON_FORWARDER_OFFLINE:
+      break;
+    case FACELET_ERROR_REASON_UNDEFINED:
+    case FACELET_ERROR_REASON_N:
+      ERROR("facelet_set_error] Unexpected error reason");
+      break;
+  }
 }
 
-void
-facelet_unset_error(facelet_t * facelet)
-{
-    facelet->error = 0;
-}
+void facelet_unset_error(facelet_t *facelet) { facelet->error = 0; }
 
-bool
-facelet_get_error(const facelet_t * facelet)
-{
-    return facelet->error;
-}
+bool facelet_get_error(const facelet_t *facelet) { return facelet->error; }
 
-void
-facelet_set_bj_done(facelet_t * facelet)
-{
-    facelet->bj_done = true;
-}
-
-void
-facelet_unset_bj_done(facelet_t * facelet)
-{
-    facelet->bj_done = false;
-}
-
-bool
-facelet_is_bj_done(const facelet_t * facelet)
-{
-    return facelet->bj_done;
-}
+void facelet_set_bj_done(facelet_t *facelet) { facelet->bj_done = true; }
 
-void
-facelet_set_au_done(facelet_t * facelet)
-{
-    facelet->au_done = true;
-}
+void facelet_unset_bj_done(facelet_t *facelet) { facelet->bj_done = false; }
 
-bool
-facelet_is_au_done(const facelet_t * facelet)
-{
-    return facelet->au_done;
-}
+bool facelet_is_bj_done(const facelet_t *facelet) { return facelet->bj_done; }
 
-facelet_event_t
-facelet_get_event(const facelet_t * facelet)
-{
-    return facelet->event;
+facelet_event_t facelet_get_event(const facelet_t *facelet) {
+  return facelet->event;
 }
 
-void
-facelet_set_event(facelet_t * facelet, facelet_event_t event)
-{
-    facelet->event = event;
+void facelet_set_event(facelet_t *facelet, facelet_event_t event) {
+  facelet->event = event;
 }
 
-int
-facelet_add_route(facelet_t * facelet, hicn_route_t * route)
-{
-    return route_set_add(facelet->routes, route);
+int facelet_add_route(facelet_t *facelet, hicn_route_t *route) {
+  return route_set_add(facelet->routes, route);
 }
 
-int
-facelet_remove_route(facelet_t * facelet, hicn_route_t * route, hicn_route_t ** route_removed)
-{
-    return route_set_remove(facelet->routes, route, route_removed);
+int facelet_remove_route(facelet_t *facelet, hicn_route_t *route,
+                         hicn_route_t **route_removed) {
+  return route_set_remove(facelet->routes, route, route_removed);
 }
 
-int
-facelet_clear_routes(facelet_t * facelet)
-{
-    return route_set_clear(facelet->routes);
+int facelet_clear_routes(facelet_t *facelet) {
+  return route_set_clear(facelet->routes);
 }
 
-int
-facelet_get_route_array(const facelet_t * facelet, hicn_route_t *** route_array)
-{
-    return route_set_get_array(facelet->routes, route_array);
+int facelet_get_route_array(const facelet_t *facelet,
+                            hicn_route_t ***route_array) {
+  return route_set_get_array(facelet->routes, route_array);
 }
 
-int
-facelet_snprintf(char * s, size_t size, const facelet_t * facelet)
-{
-    char * cur = s;
-    int rc;
-
-    assert(facelet);
-
-    /* Header + key attributes (netdevice + family) */
-    rc = snprintf(cur, s + size - cur, "<Facelet [%d] %s %s (%s)",
-            facelet->id,
-            facelet_status_str[facelet->status],
-            facelet_get_error(facelet) ? "/!\\" : "",
-            (facelet->family == AF_INET) ? "AF_INET" :
-            (facelet->family == AF_INET6) ? "AF_INET6" :
-            (facelet->family == AF_UNSPEC) ? "AF_UNSPEC" :
-            "unknown");
-    if (rc < 0)
-        return rc;
+int facelet_snprintf(char *s, size_t size, const facelet_t *facelet) {
+  char *cur = s;
+  int rc;
+
+  assert(facelet);
+
+  /* Header + key attributes (netdevice + family) */
+  rc = snprintf(cur, s + size - cur, "<Facelet [%d] %s %s (%s)", facelet->id,
+                facelet_status_str[facelet->status],
+                facelet_get_error(facelet) ? "/!\\" : "",
+                (facelet->family == AF_INET)     ? "AF_INET"
+                : (facelet->family == AF_INET6)  ? "AF_INET6"
+                : (facelet->family == AF_UNSPEC) ? "AF_UNSPEC"
+                                                 : "unknown");
+  if (rc < 0) return rc;
+  cur += rc;
+  if (cur >= s + size) return (int)(cur - s);
+
+  /* Netdevice */
+  if (facelet_has_netdevice(facelet)) {
+    rc = snprintf(cur, s + size - cur, " netdevice=%s",
+                  facelet->netdevice.name[0] ? facelet->netdevice.name : "*");
+    if (rc < 0) return rc;
     cur += rc;
-    if (cur >= s + size)
-        return (int)(cur - s);
-
-    /* Netdevice */
-    if (facelet_has_netdevice(facelet)) {
-        rc = snprintf(cur, s + size - cur, " netdevice=%s",
-                facelet->netdevice.name[0] ? facelet->netdevice.name : "*");
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-
-        rc = snprintf(cur, s + size - cur, "/%d", facelet->netdevice.index);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
+    if (cur >= s + size) return (int)(cur - s);
 
-    } else {
-        rc = snprintf(cur, s + size - cur, " netdevice=*/*");
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+    rc = snprintf(cur, s + size - cur, "/%d", facelet->netdevice.index);
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
 
-    /* Netdevice type */
-    if (facelet_has_netdevice_type(facelet)) {
-        rc = snprintf(cur, s + size - cur, " type=%s",
-                netdevice_type_str[facelet->netdevice_type]);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+  } else {
+    rc = snprintf(cur, s + size - cur, " netdevice=*/*");
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
+
+  /* Netdevice type */
+  if (facelet_has_netdevice_type(facelet)) {
+    rc = snprintf(cur, s + size - cur, " type=%s",
+                  netdevice_type_str(facelet->netdevice_type));
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
 
-    /* Local ip address */
-    if (facelet_has_local_addr(facelet)) {
-        rc = snprintf(cur, s + size - cur, " local_addr=");
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-
-        rc = ip_address_snprintf(cur, s + size - cur, &facelet->local_addr,
-                facelet->family);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+  /* Local ip address */
+  if (facelet_has_local_addr(facelet)) {
+    rc = snprintf(cur, s + size - cur, " local_addr=");
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
 
-    /* Local port */
-    if (facelet_has_local_port(facelet)) {
-        rc = snprintf(cur, s + size - cur, " local_port=%d",
-                facelet->local_port);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+    rc = ip_address_snprintf(cur, s + size - cur, &facelet->local_addr,
+                             facelet->family);
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
 
-    /* Remote ip address */
-    if (facelet_has_remote_addr(facelet)) {
-        rc = snprintf(cur, s + size - cur, " remote_addr=");
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-
-        rc = ip_address_snprintf(cur, s + size - cur, &facelet->remote_addr,
-                facelet->family);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+  /* Local port */
+  if (facelet_has_local_port(facelet)) {
+    rc = snprintf(cur, s + size - cur, " local_port=%d", facelet->local_port);
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
 
-    /* Remote port */
-    if (facelet_has_remote_port(facelet)) {
-        rc = snprintf(cur, s + size - cur, " remote_port=%d",
-                facelet->remote_port);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+  /* Remote ip address */
+  if (facelet_has_remote_addr(facelet)) {
+    rc = snprintf(cur, s + size - cur, " remote_addr=");
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
 
-    /* Admin state */
-    if (facelet_has_admin_state(facelet)) {
-        rc = snprintf(cur, s + size - cur, " admin_state=%s",
-                face_state_str[facelet->admin_state]);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+    rc = ip_address_snprintf(cur, s + size - cur, &facelet->remote_addr,
+                             facelet->family);
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
 
-    /* State */
-    if (facelet_has_state(facelet)) {
-        rc = snprintf(cur, s + size - cur, " state=%s",
-                face_state_str[facelet->state]);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+  /* Remote port */
+  if (facelet_has_remote_port(facelet)) {
+    rc = snprintf(cur, s + size - cur, " remote_port=%d", facelet->remote_port);
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
+
+  /* Admin state */
+  if (facelet_has_admin_state(facelet)) {
+    rc = snprintf(cur, s + size - cur, " admin_state=%s",
+                  face_state_str(facelet->admin_state));
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
+
+  /* State */
+  if (facelet_has_state(facelet)) {
+    rc = snprintf(cur, s + size - cur, " state=%s",
+                  face_state_str(facelet->state));
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
 
 #ifdef WITH_POLICY
-    /* Priority */
-    if (facelet_has_priority(facelet)) {
-        rc = snprintf(cur, s + size - cur, " priority=%d", facelet->priority);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+  /* Priority */
+  if (facelet_has_priority(facelet)) {
+    rc = snprintf(cur, s + size - cur, " priority=%d", facelet->priority);
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
 #endif /* WITH_POLICY */
 
-    /* Face type */
-    if (facelet_has_face_type(facelet)) {
-        rc = snprintf(cur, s + size - cur, " face_type=LAYER%s/%s",
-            FACEMGR_FACE_TYPE_STR(facelet->face_type));
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
-
-    /* Routes */
-    rc = snprintf(cur, s + size - cur, " routes={ ");
-    if (rc < 0)
-        return rc;
+  /* Face type */
+  if (facelet_has_face_type(facelet)) {
+    rc = snprintf(cur, s + size - cur, " face_type=LAYER%s/%s",
+                  FACEMGR_FACE_TYPE_STR(facelet->face_type));
+    if (rc < 0) return rc;
     cur += rc;
-    if (cur >= s + size)
-        return (int)(cur - s);
-
-    hicn_route_t ** route_array;
-    int n = route_set_get_array(facelet->routes, &route_array);
-    if (n < 0) {
-        ERROR("[facelet_free] Error getting route set associated to facelet");
-    } else {
-        for (unsigned i = 0; i < n; i++) {
-            hicn_route_t * route = route_array[i];
-            rc = (int)hicn_route_snprintf(cur, s + size - cur, route);
-            if (rc < 0)
-                return rc;
-            cur += rc;
-            if (cur >= s + size)
-                return (int)(cur - s);
-
-            rc = snprintf(cur, s + size - cur, ", ");
-            if (rc < 0)
-                return rc;
-            cur += rc;
-            if (cur >= s + size)
-                return (int)(cur - s);
-        }
+    if (cur >= s + size) return (int)(cur - s);
+  }
+
+  /* Routes */
+  rc = snprintf(cur, s + size - cur, " routes={ ");
+  if (rc < 0) return rc;
+  cur += rc;
+  if (cur >= s + size) return (int)(cur - s);
+
+  hicn_route_t **route_array;
+  int n = route_set_get_array(facelet->routes, &route_array);
+  if (n < 0) {
+    ERROR("[facelet_free] Error getting route set associated to facelet");
+  } else {
+    for (unsigned i = 0; i < n; i++) {
+      hicn_route_t *route = route_array[i];
+      if (!route) continue; /* Should not occur */
+      rc = (int)hicn_route_snprintf(cur, s + size - cur, route);
+      if (rc < 0) return rc;
+      cur += rc;
+      if (cur >= s + size) return (int)(cur - s);
+
+      rc = snprintf(cur, s + size - cur, ", ");
+      if (rc < 0) return rc;
+      cur += rc;
+      if (cur >= s + size) return (int)(cur - s);
     }
-    free(route_array);
+  }
+  free(route_array);
 
-    rc = snprintf(cur, s + size - cur, "}>");
-    if (rc < 0)
-        return rc;
-    cur += rc;
-    if (cur >= s + size)
-        return (int)(cur - s);
+  rc = snprintf(cur, s + size - cur, "}>");
+  if (rc < 0) return rc;
+  cur += rc;
+  if (cur >= s + size) return (int)(cur - s);
 
-    return (int)(cur - s);
+  return (int)(cur - s);
 }
 
-int facelet_snprintf_json(char * s, size_t size, const facelet_t * facelet, int indent)
-{
-    char * cur = s;
-    int rc;
-
-    assert(facelet);
-
-    /* Header + key attributes (netdevice + family) */
-    rc = snprintf(cur, s + size - cur, "%*s%s", 4 * indent, "", "{\n");
-    if (rc < 0)
-        return rc;
+int facelet_snprintf_json(char *s, size_t size, const facelet_t *facelet,
+                          int indent) {
+  char *cur = s;
+  int rc;
+
+  assert(facelet);
+
+  /* Header + key attributes (netdevice + family) */
+  rc = snprintf(cur, s + size - cur, "%*s%s", 4 * indent, "", "{\n");
+  if (rc < 0) return rc;
+  cur += rc;
+  if (cur >= s + size) return (int)(cur - s);
+
+  /* id */
+  rc = snprintf(cur, s + size - cur, "%*s%s: %d,\n", 4 * (indent + 1), "",
+                "\"id\"", facelet->id);
+  if (rc < 0) return rc;
+  cur += rc;
+  if (cur >= s + size) return (int)(cur - s);
+
+  /* Status */
+  rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent + 1), "",
+                "\"status\"", facelet_status_str[facelet->status]);
+  if (rc < 0) return rc;
+  cur += rc;
+  if (cur >= s + size) return (int)(cur - s);
+
+  /* Family */
+  rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent + 1), "",
+                "\"family\"",
+                (facelet->family == AF_INET)     ? "AF_INET"
+                : (facelet->family == AF_INET6)  ? "AF_INET6"
+                : (facelet->family == AF_UNSPEC) ? "AF_UNSPEC"
+                                                 : "unknown");
+  if (rc < 0) return rc;
+  cur += rc;
+  if (cur >= s + size) return (int)(cur - s);
+
+  /* Netdevice */
+  if (facelet_has_netdevice(facelet)) {
+    rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent + 1), "",
+                  "\"netdevice\"",
+                  facelet->netdevice.name[0] ? facelet->netdevice.name : "*");
+    if (rc < 0) return rc;
     cur += rc;
-    if (cur >= s + size)
-        return (int)(cur - s);
-
-    /* id */
-    rc = snprintf(cur, s + size - cur, "%*s%s: %d,\n", 4 * (indent+1), "", "\"id\"",
-            facelet->id);
-    if (rc < 0)
-        return rc;
+    if (cur >= s + size) return (int)(cur - s);
+
+  } else {
+    rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent + 1), "",
+                  "\"netdevice\"", "*");
+    if (rc < 0) return rc;
     cur += rc;
-    if (cur >= s + size)
-        return (int)(cur - s);
-
-    /* Status */
-    rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent+1), "", "\"status\"",
-            facelet_status_str[facelet->status]);
-    if (rc < 0)
-        return rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
+
+  /* Netdevice type */
+  if (facelet_has_netdevice_type(facelet)) {
+    rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent + 1), "",
+                  "\"netdevice_type\"",
+                  netdevice_type_str(facelet->netdevice_type));
+    if (rc < 0) return rc;
     cur += rc;
-    if (cur >= s + size)
-        return (int)(cur - s);
-
-    /* Family */
-    rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent+1), "", "\"family\"",
-            (facelet->family == AF_INET) ? "AF_INET" :
-            (facelet->family == AF_INET6) ? "AF_INET6" :
-            (facelet->family == AF_UNSPEC) ? "AF_UNSPEC" :
-            "unknown");
-    if (rc < 0)
-        return rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
+
+  /* Local ip address */
+  if (facelet_has_local_addr(facelet)) {
+    rc = snprintf(cur, s + size - cur, "%*s%s: \"", 4 * (indent + 1), "",
+                  "\"local_addr\"");
+    if (rc < 0) return rc;
     cur += rc;
-    if (cur >= s + size)
-        return (int)(cur - s);
-
-    /* Netdevice */
-    if (facelet_has_netdevice(facelet)) {
-        rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent+1), "",
-                "\"netdevice\"",
-                facelet->netdevice.name[0] ? facelet->netdevice.name : "*");
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-
-    } else {
-        rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent+1), "",
-                "\"netdevice\"", "*");
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+    if (cur >= s + size) return (int)(cur - s);
 
-    /* Netdevice type */
-    if (facelet_has_netdevice_type(facelet)) {
-        rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent+1), "",
-                "\"netdevice_type\"",
-                netdevice_type_str[facelet->netdevice_type]);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
-
-    /* Local ip address */
-    if (facelet_has_local_addr(facelet)) {
-        rc = snprintf(cur, s + size - cur, "%*s%s: \"", 4 * (indent+1), "",
-                "\"local_addr\"");
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-
-        rc = ip_address_snprintf(cur, s + size - cur, &facelet->local_addr,
-                facelet->family);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-
-        rc = snprintf(cur, s + size - cur, "\",\n");
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
-
-    /* Local port */
-    if (facelet_has_local_port(facelet)) {
-        rc = snprintf(cur, s + size - cur, "%*s%s: %d,\n", 4 * (indent+1), "",
-                "\"local_port\"",
-                facelet->local_port);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
-
-    /* Remote ip address */
-    if (facelet_has_remote_addr(facelet)) {
-        rc = snprintf(cur, s + size - cur, "%*s%s: \"", 4 * (indent+1), "",
-                "\"remote_addr\"");
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-
-        rc = ip_address_snprintf(cur, s + size - cur, &facelet->remote_addr,
-                facelet->family);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-
-        rc = snprintf(cur, s + size - cur, "\",\n");
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+    rc = ip_address_snprintf(cur, s + size - cur, &facelet->local_addr,
+                             facelet->family);
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
 
-    /* Remote port */
-    if (facelet_has_remote_port(facelet)) {
-        rc = snprintf(cur, s + size - cur, "%*s%s: %d,\n", 4 * (indent+1), "",
-                "\"remote_port\"",
-                facelet->remote_port);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+    rc = snprintf(cur, s + size - cur, "\",\n");
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
+
+  /* Local port */
+  if (facelet_has_local_port(facelet)) {
+    rc = snprintf(cur, s + size - cur, "%*s%s: %d,\n", 4 * (indent + 1), "",
+                  "\"local_port\"", facelet->local_port);
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
+
+  /* Remote ip address */
+  if (facelet_has_remote_addr(facelet)) {
+    rc = snprintf(cur, s + size - cur, "%*s%s: \"", 4 * (indent + 1), "",
+                  "\"remote_addr\"");
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
 
-    /* Admin state */
-    if (facelet_has_admin_state(facelet)) {
-        rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent+1), "",
-                "\"admin_state\"",
-                face_state_str[facelet->admin_state]);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+    rc = ip_address_snprintf(cur, s + size - cur, &facelet->remote_addr,
+                             facelet->family);
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
 
-    /* State */
-    if (facelet_has_state(facelet)) {
-        rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent+1), "",
-                "\"state\"",
-                face_state_str[facelet->state]);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+    rc = snprintf(cur, s + size - cur, "\",\n");
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
+
+  /* Remote port */
+  if (facelet_has_remote_port(facelet)) {
+    rc = snprintf(cur, s + size - cur, "%*s%s: %d,\n", 4 * (indent + 1), "",
+                  "\"remote_port\"", facelet->remote_port);
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
+
+  /* Admin state */
+  if (facelet_has_admin_state(facelet)) {
+    rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent + 1), "",
+                  "\"admin_state\"", face_state_str(facelet->admin_state));
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
+
+  /* State */
+  if (facelet_has_state(facelet)) {
+    rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\",\n", 4 * (indent + 1), "",
+                  "\"state\"", face_state_str(facelet->state));
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
 
 #ifdef WITH_POLICY
-    /* Priority */
-    if (facelet_has_priority(facelet)) {
-        rc = snprintf(cur, s + size - cur, "%*s%s: %d,\n", 4 * (indent+1), "",
-                "\"priority\"", facelet->priority);
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
+  /* Priority */
+  if (facelet_has_priority(facelet)) {
+    rc = snprintf(cur, s + size - cur, "%*s%s: %d,\n", 4 * (indent + 1), "",
+                  "\"priority\"", facelet->priority);
+    if (rc < 0) return rc;
+    cur += rc;
+    if (cur >= s + size) return (int)(cur - s);
+  }
 #endif /* WITH_POLICY */
 
-    if (facelet_has_face_type(facelet)) {
-        rc = snprintf(cur, s + size - cur, "%*s%s: \"LAYER%s/%s\",\n", 4 * (indent+1), "",
-                "\"face_type\"",
-            FACEMGR_FACE_TYPE_STR(facelet->face_type));
-        if (rc < 0)
-            return rc;
-        cur += rc;
-        if (cur >= s + size)
-            return (int)(cur - s);
-    }
-
-    /* Status error */
-    rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\"\n", 4 * (indent+1), "",
-            "\"error\"",
-            facelet_get_error(facelet) ? "true" : "false");
-    if (rc < 0)
-        return rc;
+  if (facelet_has_face_type(facelet)) {
+    rc = snprintf(cur, s + size - cur, "%*s%s: \"LAYER%s/%s\",\n",
+                  4 * (indent + 1), "", "\"face_type\"",
+                  FACEMGR_FACE_TYPE_STR(facelet->face_type));
+    if (rc < 0) return rc;
     cur += rc;
-    if (cur >= s + size)
-        return (int)(cur - s);
+    if (cur >= s + size) return (int)(cur - s);
+  }
 
-    /* Routes */
-    // TODO
+  /* Status error */
+  rc = snprintf(cur, s + size - cur, "%*s%s: \"%s\"\n", 4 * (indent + 1), "",
+                "\"error\"", facelet_get_error(facelet) ? "true" : "false");
+  if (rc < 0) return rc;
+  cur += rc;
+  if (cur >= s + size) return (int)(cur - s);
 
-    rc = snprintf(cur, s + size - cur, "%*s%s", 4 * indent, "", "}");
-    if (rc < 0)
-        return rc;
-    cur += rc;
-    if (cur >= s + size)
-        return (int)(cur - s);
+  /* Routes */
+  // TODO
+
+  rc = snprintf(cur, s + size - cur, "%*s%s", 4 * indent, "", "}");
+  if (rc < 0) return rc;
+  cur += rc;
+  if (cur >= s + size) return (int)(cur - s);
 
-    return (int)(cur - s);
+  return (int)(cur - s);
 }
diff --git a/ctrl/facemgr/src/facelet_array.c b/ctrl/facemgr/src/facelet_array.c
index 3ee110b8e..d48625979 100644
--- a/ctrl/facemgr/src/facelet_array.c
+++ b/ctrl/facemgr/src/facelet_array.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -23,4 +23,3 @@
 #include "facelet_array.h"
 
 TYPEDEF_ARRAY(facelet_array, facelet_t *, facelet_equals, facelet_snprintf);
-
diff --git a/ctrl/facemgr/src/facelet_array.h b/ctrl/facemgr/src/facelet_array.h
index 099774691..b3b17e88b 100644
--- a/ctrl/facemgr/src/facelet_array.h
+++ b/ctrl/facemgr/src/facelet_array.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/ctrl/facemgr/src/interface.c b/ctrl/facemgr/src/interface.c
index 7f95be4ce..a9aeeaf33 100644
--- a/ctrl/facemgr/src/interface.c
+++ b/ctrl/facemgr/src/interface.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -29,170 +29,144 @@
 #include "interface.h"
 
 TYPEDEF_MAP_H(interface_ops_map, const char *, const interface_ops_t *);
-TYPEDEF_MAP(interface_ops_map, const char *, const interface_ops_t *, strcmp, string_snprintf, generic_snprintf);
-
-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 -1;
-    }
-    interface_ops_map_add(interface_ops_map, ops->type, ops);
-    return 0;
+TYPEDEF_MAP(interface_ops_map, const char *, const interface_ops_t *, strcmp,
+            string_snprintf, generic_snprintf);
+
+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 -1;
+  }
+  interface_ops_map_add(interface_ops_map, ops->type, ops);
+  return 0;
 }
 
-int
-interface_unregister_all()
-{
-    int ret = 0;
-    const char ** ops_name_array = NULL;
-    int n = interface_ops_map_get_key_array(interface_ops_map, &ops_name_array);
-    if (n < 0) {
-        ERROR("[interface_unregister_all] Could not get interface ops array");
-        return -1;
-    }
-
-    for (unsigned i = 0; i < n; i++) {
-        const char * ops_name = ops_name_array[i];
-        if (interface_ops_map_remove(interface_ops_map, ops_name, NULL) < 0) {
-            ERROR("[interface_unregister_all] Could not remove %s from interface ops map", ops_name);
-            ret = -1;
-        }
+int interface_unregister_all() {
+  int ret = 0;
+  const char **ops_name_array = NULL;
+  int n = interface_ops_map_get_key_array(interface_ops_map, &ops_name_array);
+  if (n < 0) {
+    ERROR("[interface_unregister_all] Could not get interface ops array");
+    return -1;
+  }
+
+  for (unsigned i = 0; i < n; i++) {
+    const char *ops_name = ops_name_array[i];
+    if (interface_ops_map_remove(interface_ops_map, ops_name, NULL) < 0) {
+      ERROR(
+          "[interface_unregister_all] Could not remove %s from interface ops "
+          "map",
+          ops_name);
+      ret = -1;
     }
-    free(ops_name_array);
+  }
+  free(ops_name_array);
 
-    interface_ops_map_free(interface_ops_map);
-    interface_ops_map = NULL;
+  interface_ops_map_free(interface_ops_map);
+  interface_ops_map = NULL;
 
-    return ret;
+  return ret;
 }
 
-interface_t *
-interface_create(const char * name, const char * type)
-{
-
-    const interface_ops_t * ops = NULL;
-    int rc = interface_ops_map_get(interface_ops_map, type, &ops);
-    if (rc < 0) {
-        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_owner = NULL;
-    interface->data = NULL;
-
-    return interface;
+interface_t *interface_create(const char *name, const char *type) {
+  const interface_ops_t *ops = NULL;
+  int rc = interface_ops_map_get(interface_ops_map, type, &ops);
+  if (rc < 0) {
+    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_owner = NULL;
+  interface->data = NULL;
+
+  return interface;
 }
 
-void
-interface_free(interface_t * interface)
-{
-    free(interface->name);
-    free(interface);
+void interface_free(interface_t *interface) {
+  free(interface->name);
+  free(interface);
 }
 
-void
-interface_set_callback(interface_t * interface, void * callback_owner,
-        interface_cb_t callback)
-{
-    interface->callback = callback;
-    interface->callback_owner = callback_owner;
+void interface_set_callback(interface_t *interface, void *callback_owner,
+                            interface_cb_t callback) {
+  interface->callback = callback;
+  interface->callback_owner = callback_owner;
 }
 
-int
-interface_initialize(interface_t * interface, void * cfg)
-{
-    if (!interface->ops->initialize)
-        return -1;
-    return interface->ops->initialize(interface, cfg);
+int interface_initialize(interface_t *interface, void *cfg) {
+  if (!interface->ops->initialize) return -1;
+  return interface->ops->initialize(interface, cfg);
 }
 
-int
-interface_finalize(interface_t * interface)
-{
-    if (!interface->ops->finalize)
-        return -1;
-    return interface->ops->finalize(interface);
+int interface_finalize(interface_t *interface) {
+  if (!interface->ops->finalize) return -1;
+  return interface->ops->finalize(interface);
 }
 
-int
-interface_on_event(interface_t * interface, facelet_t * facelet)
-{
-    if (!interface->ops->on_event)
-        return -1;
-    return interface->ops->on_event(interface, facelet);
+int interface_on_event(interface_t *interface, facelet_t *facelet) {
+  if (!interface->ops->on_event) return -1;
+  return interface->ops->on_event(interface, facelet);
 }
 
-int
-interface_raise_event(interface_t * interface, facelet_t * facelet)
-{
-    assert(interface->callback);
-    return interface->callback(interface->callback_owner,
-            INTERFACE_CB_TYPE_RAISE_EVENT, facelet);
+int interface_raise_event(interface_t *interface, facelet_t *facelet) {
+  assert(interface->callback);
+  return interface->callback(interface->callback_owner,
+                             INTERFACE_CB_TYPE_RAISE_EVENT, facelet);
 }
 
-int
-interface_register_fd(interface_t * interface, int fd, void * data)
-{
-    assert(interface->callback);
-    fd_callback_data_t fd_callback = {
-        .fd = fd,
-        .owner = interface,
-        .callback = (fd_callback_t)interface->ops->callback,
-        .data = data,
-    };
-    return interface->callback(interface->callback_owner,
-            INTERFACE_CB_TYPE_REGISTER_FD, &fd_callback);
+int interface_register_fd(interface_t *interface, int fd, void *data) {
+  assert(interface->callback);
+  fd_callback_data_t fd_callback = {
+      .fd = fd,
+      .owner = interface,
+      .callback = (fd_callback_t)interface->ops->callback,
+      .data = data,
+  };
+  return interface->callback(interface->callback_owner,
+                             INTERFACE_CB_TYPE_REGISTER_FD, &fd_callback);
 }
 
-int
-interface_unregister_fd(interface_t * interface, int fd)
-{
-    assert(interface->callback);
-    fd_callback_data_t fd_callback = {
-        .fd = fd,
-        .owner = interface,
-        .callback = NULL,
-        .data = NULL,
-    };
-    return interface->callback(interface->callback_owner,
-            INTERFACE_CB_TYPE_UNREGISTER_FD, &fd_callback);
+int interface_unregister_fd(interface_t *interface, int fd) {
+  assert(interface->callback);
+  fd_callback_data_t fd_callback = {
+      .fd = fd,
+      .owner = interface,
+      .callback = NULL,
+      .data = NULL,
+  };
+  return interface->callback(interface->callback_owner,
+                             INTERFACE_CB_TYPE_UNREGISTER_FD, &fd_callback);
 }
 
-typedef int (*interface_fd_callback_t)(interface_t * interface, int fd, void * unused);
-
-int
-interface_register_timer(interface_t * interface, unsigned delay_ms,
-        interface_fd_callback_t callback, void * data)
-{
-    assert(interface->callback);
-    timer_callback_data_t timer_callback = {
-        .delay_ms = delay_ms,
-        .owner = interface,
-        .callback = (fd_callback_t)callback,
-        .data = data,
-    };
-    int rc = interface->callback(interface->callback_owner,
-            INTERFACE_CB_TYPE_REGISTER_TIMER, &timer_callback);
-    return rc;
+typedef int (*interface_fd_callback_t)(interface_t *interface, int fd,
+                                       void *unused);
+
+int interface_register_timer(interface_t *interface, unsigned delay_ms,
+                             interface_fd_callback_t callback, void *data) {
+  assert(interface->callback);
+  timer_callback_data_t timer_callback = {
+      .delay_ms = delay_ms,
+      .owner = interface,
+      .callback = (fd_callback_t)callback,
+      .data = data,
+  };
+  int rc =
+      interface->callback(interface->callback_owner,
+                          INTERFACE_CB_TYPE_REGISTER_TIMER, &timer_callback);
+  return rc;
 }
 
-int
-interface_unregister_timer(interface_t * interface, int fd)
-{
-    assert(interface->callback);
-    return interface->callback(interface->callback_owner,
-            INTERFACE_CB_TYPE_UNREGISTER_TIMER, &fd);
+int interface_unregister_timer(interface_t *interface, int fd) {
+  assert(interface->callback);
+  return interface->callback(interface->callback_owner,
+                             INTERFACE_CB_TYPE_UNREGISTER_TIMER, &fd);
 }
diff --git a/ctrl/facemgr/src/interface.h b/ctrl/facemgr/src/interface.h
index a4fbda1fb..a999036d5 100644
--- a/ctrl/facemgr/src/interface.h
+++ b/ctrl/facemgr/src/interface.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -32,40 +32,41 @@
 #include <hicn/facemgr/loop.h>
 
 typedef enum {
-    INTERFACE_CB_TYPE_REGISTER_FD,
-    INTERFACE_CB_TYPE_UNREGISTER_FD,
-    INTERFACE_CB_TYPE_RAISE_EVENT,
-    INTERFACE_CB_TYPE_REGISTER_TIMER,
-    INTERFACE_CB_TYPE_UNREGISTER_TIMER,
+  INTERFACE_CB_TYPE_REGISTER_FD,
+  INTERFACE_CB_TYPE_UNREGISTER_FD,
+  INTERFACE_CB_TYPE_RAISE_EVENT,
+  INTERFACE_CB_TYPE_REGISTER_TIMER,
+  INTERFACE_CB_TYPE_UNREGISTER_TIMER,
 } interface_cb_type_t;
 
-typedef int (*interface_cb_t)(facemgr_t * facemgr, interface_cb_type_t type, void * data);
+typedef int (*interface_cb_t)(facemgr_t* facemgr, interface_cb_type_t type,
+                              void* data);
 
 /**
  * \brief Interface operations
  */
 struct interface_s;
 typedef struct {
-    /** The type given to the interfaces */
-    char * type;
-    /* Constructor */
-    int (*initialize)(struct interface_s * interface, void * cfg);
-    /* Destructor */
-    int (*finalize)(struct interface_s * interface);
-    /* Callback upon file descriptor event (iif previously registered) */
-    int (*callback)(struct interface_s * interface, int fd, void * data);
-    /* Callback upon face events coming from the face manager */
-    int (*on_event)(struct interface_s * interface, struct facelet_s * facelet);
+  /** The type given to the interfaces */
+  char* type;
+  /* Constructor */
+  int (*initialize)(struct interface_s* interface, void* cfg);
+  /* Destructor */
+  int (*finalize)(struct interface_s* interface);
+  /* Callback upon file descriptor event (iif previously registered) */
+  int (*callback)(struct interface_s* interface, int fd, void* data);
+  /* Callback upon face events coming from the face manager */
+  int (*on_event)(struct interface_s* interface, struct facelet_s* facelet);
 } interface_ops_t;
 
 typedef struct interface_s {
-    char * name;
-    const interface_ops_t * ops;
+  char* name;
+  const interface_ops_t* ops;
 
-    interface_cb_t callback;
-    void * callback_owner;
+  interface_cb_t callback;
+  void* callback_owner;
 
-    void * data;
+  void* data;
 } interface_t;
 
 /**
@@ -75,7 +76,7 @@ typedef struct interface_s {
  * \return Flag indicating the success (FACEMGR_SUCCESS=0), or failure (any
  *     other value) of the operation.
  */
-int interface_register(const interface_ops_t * ops);
+int interface_register(const interface_ops_t* ops);
 
 int interface_unregister_all();
 
@@ -91,22 +92,22 @@ int interface_unregister_all();
  * \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);
+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);
+void interface_free(interface_t* interface);
 
+void interface_set_callback(interface_t* interface, void* callback_owner,
+                            interface_cb_t callback);
 
-void interface_set_callback(interface_t * interface, void * callback_owner, interface_cb_t callback);
+int interface_initialize(interface_t* interface, void* cfg);
 
-int interface_initialize(interface_t * interface, void * cfg);
+int interface_finalize(interface_t* interface);
 
-int interface_finalize(interface_t * interface);
-
-int interface_on_event(interface_t * interface, struct facelet_s * facelet);
+int interface_on_event(interface_t* interface, struct facelet_s* facelet);
 
 /**
  * \brief Raises a facelet event to the face manager
@@ -115,15 +116,17 @@ int interface_on_event(interface_t * interface, struct facelet_s * facelet);
  * \param [in] facelet - Facelet to communicate with the event
  * \return Error code
  */
-int interface_callback(interface_t * interface, interface_cb_type_t type, void * data);
+int interface_callback(interface_t* interface, interface_cb_type_t type,
+                       void* data);
 
-int interface_raise_event(interface_t * interface, facelet_t * facelet);
+int interface_raise_event(interface_t* interface, facelet_t* facelet);
 
-int interface_register_fd(interface_t * interface, int fd, void * data);
+int interface_register_fd(interface_t* interface, int fd, void* data);
 
-int interface_unregister_fd(interface_t * interface, int fd);
+int interface_unregister_fd(interface_t* interface, int fd);
 
-typedef int (*interface_fd_callback_t)(interface_t * interface, int fd, void * unused);
+typedef int (*interface_fd_callback_t)(interface_t* interface, int fd,
+                                       void* unused);
 
 /**
  * \brief Registers a timer event
@@ -135,8 +138,8 @@ typedef int (*interface_fd_callback_t)(interface_t * interface, int fd, void * u
  * \return A positive value uniquely identifying the timer, or -1 in case of
  *      error
  */
-int interface_register_timer(interface_t * interface, unsigned delay_ms,
-        interface_fd_callback_t callback, void * data);
+int interface_register_timer(interface_t* interface, unsigned delay_ms,
+                             interface_fd_callback_t callback, void* data);
 
 /**
  * \brief Unregisters a timer event
@@ -144,6 +147,6 @@ int interface_register_timer(interface_t * interface, unsigned delay_ms,
  * \param [in] fd - Timer identifier
  * \return 0 in case of success, -1 otherwise
  */
-int interface_unregister_timer(interface_t * interface, int fd);
+int interface_unregister_timer(interface_t* interface, int fd);
 
 #endif /* FACEMGR_INTERFACE_H */
diff --git a/ctrl/facemgr/src/interfaces/CMakeLists.txt b/ctrl/facemgr/src/interfaces/CMakeLists.txt
index e4d4423e9..02fb0eb48 100644
--- a/ctrl/facemgr/src/interfaces/CMakeLists.txt
+++ b/ctrl/facemgr/src/interfaces/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -16,28 +16,33 @@ list(APPEND SOURCE_FILES)
 list(APPEND INCLUDE_DIRS)
 list(APPEND LIBRARIES)
 
+
+##############################################################
+# Add components
+##############################################################
 add_subdirectory(hicn_light)
 
 if(APPLE)
-add_subdirectory(network_framework)
+  add_subdirectory(network_framework)
 endif()
 
 if(LINUX)
-add_subdirectory(netlink)
-add_subdirectory(bonjour)
-endif()
-
-if(ANDROID)
-add_subdirectory(android_utility)
-add_subdirectory(priority_controller)
+  if(ANDROID)
+    add_subdirectory(android)
+    add_subdirectory(priority_controller)
+  else()
+    add_subdirectory(netlink)
+  endif()
+
+  add_subdirectory(bonjour)
 endif()
 
 if(WITH_EXAMPLE_DUMMY)
-add_subdirectory(dummy)
+  add_subdirectory(dummy)
 endif()
 
 if(WITH_EXAMPLE_UPDOWN)
-add_subdirectory(updown)
+  add_subdirectory(updown)
 endif()
 
 set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
diff --git a/ctrl/facemgr/src/interfaces/android_utility/CMakeLists.txt b/ctrl/facemgr/src/interfaces/android/CMakeLists.txt
index 0ebe87745..beabc1280 100644
--- a/ctrl/facemgr/src/interfaces/android_utility/CMakeLists.txt
+++ b/ctrl/facemgr/src/interfaces/android/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,16 +11,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-list(APPEND SOURCE_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/android_utility.c
+list(APPEND HEADER_FILES
 )
 
-list(APPEND INCLUDE_DIRS
+list(APPEND SOURCE_FILES
+    ${CMAKE_CURRENT_SOURCE_DIR}/android.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)
diff --git a/ctrl/facemgr/src/interfaces/android/android.c b/ctrl/facemgr/src/interfaces/android/android.c
new file mode 100644
index 000000000..4e084d76d
--- /dev/null
+++ b/ctrl/facemgr/src/interfaces/android/android.c
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file interfaces/android/android.c
+ * \brief Netlink interface
+ */
+
+#include <assert.h>
+#include <pthread.h>
+#include <sys/eventfd.h>
+#include <unistd.h>  // close
+
+#include <hicn/facemgr.h>
+#include <hicn/util/ip_address.h>
+#include <hicn/util/log.h>
+
+#include "../../common.h"
+#include "../../interface.h"
+#include "../../facelet_array.h"
+
+#include "android.h"
+
+/*
+ * aar_modules/FaceMgrLibrary/facemgrLibrary/src/main/java/com/cisco/hicn/facemgrlibrary/supportlibrary/FacemgrUtility.java
+ */
+#define FACEMGR_ANDROID_CLASS \
+  "com/cisco/hicn/facemgrlibrary/supportlibrary/FacemgrUtility"
+
+/* Internal data storage */
+typedef struct {
+  int fd;
+  android_cfg_t cfg;
+  JNIEnv *env;
+  jclass cls;
+  bool attached_to_vm;
+  facelet_array_t *facelets;
+  pthread_mutex_t mutex;
+} android_data_t;
+
+// might replace android utility
+
+jclass find_class_global(JNIEnv *env, const char *name) {
+  jclass c = (*env)->FindClass(env, name);
+  jclass c_global = 0;
+  if (c) {
+    c_global = (jclass)(*env)->NewGlobalRef(env, c);
+    (*env)->DeleteLocalRef(env, c);
+  }
+  return c_global;
+}
+
+int android_on_network_event(interface_t *interface, const char *interface_name,
+                             netdevice_type_t netdevice_type, bool up,
+                             int family, const char *ip_address) {
+  android_data_t *data = (android_data_t *)interface->data;
+
+  netdevice_t *netdevice = netdevice_create_from_name(interface_name);
+  if (!netdevice) {
+    ERROR("[android_on_network_event] error creating netdevice '%s'",
+          interface_name);
+    goto ERR_ND;
+  }
+
+  ip_address_t local_addr = IP_ADDRESS_EMPTY;
+  if (ip_address) {
+    if (ip_address_pton(ip_address, &local_addr) < 0) {
+      ERROR("[android_on_network_event] error processing IP address");
+      goto ERR_IP_ADDRESS;
+    }
+  }
+
+  facelet_t *facelet = facelet_create();
+  if (!facelet) {
+    ERROR("[android_on_network_event] error creating facelet");
+    goto ERR_FACELET;
+  }
+
+  if (facelet_set_netdevice(facelet, *netdevice) < 0) {
+    ERROR("[android_on_network_event] error setting netdevice");
+    goto ERR;
+  }
+
+  if (netdevice_type != NETDEVICE_TYPE_UNDEFINED) {
+    if (facelet_set_netdevice_type(facelet, netdevice_type) < 0) {
+      ERROR("[android_on_network_event] error setting netdevice type");
+      goto ERR;
+    }
+  }
+
+  if (facelet_set_family(facelet, family) < 0) {
+    ERROR("[android_on_network_event] error setting family");
+    goto ERR;
+  }
+
+  if (ip_address) {
+    if (facelet_set_local_addr(facelet, local_addr) < 0) {
+      ERROR("[android_on_network_event] error setting local address");
+      goto ERR;
+    }
+  }
+  netdevice_free(netdevice);
+
+  facelet_set_event(facelet, up ? FACELET_EVENT_CREATE : FACELET_EVENT_DELETE);
+  // FACELET_EVENT_UPDATE, FACELET_EVENT_SET_DOWN
+  facelet_set_attr_clean(facelet);
+
+  pthread_mutex_lock(&data->mutex);
+  if (facelet_array_add(data->facelets, facelet)) {
+    ERROR("[android_on_network_event] Could not add facelet to buffer");
+    goto ERR_ADD;
+  }
+
+  pthread_mutex_unlock(&data->mutex);
+
+  eventfd_write(data->fd, 1);
+  return 0;
+
+ERR_ADD:
+  pthread_mutex_unlock(&data->mutex);
+ERR:
+  facelet_free(facelet);
+ERR_FACELET:
+ERR_IP_ADDRESS:
+  netdevice_free(netdevice);
+ERR_ND:
+  return -1;
+}
+
+bool get_jni_env(JavaVM *jvm, JNIEnv **env) {
+  bool did_attach_thread = false;
+  INFO("initialize: get_jni_env");
+  *env = NULL;
+  // Check if the current thread is attached to the VM
+  int get_env_result = (*jvm)->GetEnv(jvm, (void **)env, JNI_VERSION_1_6);
+  if (get_env_result == JNI_EDETACHED) {
+    INFO("initialize: detached!");
+    if ((*jvm)->AttachCurrentThread(jvm, env, NULL) == JNI_OK) {
+      INFO("initialize: attached...");
+      did_attach_thread = true;
+    } else {
+      INFO("initialize: failed to attach");
+      // Failed to attach thread. Throw an exception if you want to.
+    }
+  } else if (get_env_result == JNI_EVERSION) {
+    // Unsupported JNI version. Throw an exception if you want to.
+    INFO("initialize: unsupported");
+  }
+  return did_attach_thread;
+}
+
+int android_initialize(interface_t *interface, void *cfg) {
+  android_data_t *data = malloc(sizeof(android_data_t));
+  if (!data) goto ERR_MALLOC;
+  interface->data = data;
+
+  if (!cfg) goto ERR_CFG;
+  data->cfg = *(android_cfg_t *)cfg;
+
+  JavaVM *jvm = data->cfg.jvm;
+  if (!jvm) goto ERR_JVM;
+
+  data->facelets = facelet_array_create();
+  if (!data->facelets) goto ERR_FACELETS;
+
+  if ((data->fd = eventfd(0, EFD_SEMAPHORE)) == -1) goto ERR_EVENTFD;
+
+  if (interface_register_fd(interface, data->fd, NULL) < 0) {
+    ERROR("[android_initialize] Error registering fd");
+    goto ERR_REGISTER_FD;
+  }
+
+  pthread_mutex_init(&data->mutex, NULL);
+
+  data->attached_to_vm = get_jni_env(jvm, &data->env);
+
+  if (!data->env) goto ERR_ENV;
+
+  data->cls = find_class_global(data->env, FACEMGR_ANDROID_CLASS);
+  if (data->cls == 0) goto ERR_CLS;
+
+  jmethodID mid_initialize =
+      (*data->env)
+          ->GetStaticMethodID(data->env, data->cls, "initialize", "()I");
+  if (!mid_initialize) goto ERR_MID;
+
+  (*data->env)
+      ->CallStaticIntMethod(data->env, data->cls, mid_initialize,
+                            &android_on_network_event, interface);
+
+  return 0;
+
+ERR_MID:
+  (*data->env)->DeleteGlobalRef(data->env, data->cls);
+ERR_CLS:
+  if (data->attached_to_vm) {
+    (*jvm)->DetachCurrentThread(jvm);
+    data->attached_to_vm = false;
+  }
+  data->env = NULL;
+ERR_ENV:
+  interface_unregister_fd(interface, data->fd);
+ERR_REGISTER_FD:
+  close(data->fd);
+ERR_EVENTFD:
+  facelet_array_free(data->facelets);
+ERR_FACELETS:
+ERR_JVM:
+ERR_CFG:
+  free(data);
+ERR_MALLOC:
+  return -1;
+}
+
+int android_finalize(interface_t *interface) {
+  android_data_t *data = (android_data_t *)interface->data;
+
+  jmethodID mid_terminate =
+      (*data->env)->GetStaticMethodID(data->env, data->cls, "terminate", "()I");
+  if (mid_terminate) {
+    (*data->env)
+        ->CallStaticIntMethod(data->env, data->cls, mid_terminate,
+                              &android_on_network_event, interface);
+  }
+
+  (*data->env)->DeleteGlobalRef(data->env, data->cls);
+
+  JavaVM *jvm = data->cfg.jvm;
+  if (data->attached_to_vm) {
+    (*jvm)->DetachCurrentThread(jvm);
+    data->attached_to_vm = false;
+  }
+  data->env = NULL;
+
+  pthread_mutex_destroy(&data->mutex);
+
+  // interface_unregister_fd(interface, data->fd); // XXX done in
+  // facemgr_delete_interface...
+  close(data->fd);
+  facelet_array_free(data->facelets);
+
+  free(data);
+
+  return 0;
+}
+
+int android_callback(interface_t *interface, int fd, void *unused) {
+  android_data_t *data = (android_data_t *)interface->data;
+
+  uint64_t ret;
+  if (read(data->fd, &ret, sizeof(ret)) < 0) return -1;
+  if (ret == 0)  // EOF
+    return 0;
+
+  pthread_mutex_lock(&data->mutex);
+  for (unsigned i = 0; i < facelet_array_len(data->facelets); i++) {
+    facelet_t *facelet;
+    if (facelet_array_get_index(data->facelets, i, &facelet) < 0) {
+      ERROR("[android_callback] Error getting facelet in array");
+      continue;
+    }
+
+    interface_raise_event(interface, facelet);
+  }
+
+  for (unsigned i = 0; i < facelet_array_len(data->facelets); i++) {
+    if (facelet_array_remove_index(data->facelets, i, NULL) < 0) {
+      ERROR("[android_callback] Could not purge facelet from array");
+    }
+  }
+  pthread_mutex_unlock(&data->mutex);
+
+  return 0;
+}
+
+const interface_ops_t android_ops = {
+    .type = "android",
+    .initialize = android_initialize,
+    .callback = android_callback,
+    .finalize = android_finalize,
+    .on_event = NULL,
+};
diff --git a/hicn-light/src/hicn/config/controlUpdateConnection.h b/ctrl/facemgr/src/interfaces/android/android.h
index eea303202..319bfe10a 100644
--- a/hicn-light/src/hicn/config/controlUpdateConnection.h
+++ b/ctrl/facemgr/src/interfaces/android/android.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,22 +14,26 @@
  */
 
 /**
- * @file control_UpdateConnection.h
- * @brief Update a connection to an interface
- *
- * <#Detailed Description#>
- *
+ * \file android/android.h
+ * \brief Android utility.
  */
 
-#ifndef Control_UpdateConnection_h
-#define Control_UpdateConnection_h
+#ifndef FACEMGR_INTERFACE_ANDROID_H
+#define FACEMGR_INTERFACE_ANDROID_H
+
+#ifdef __ANDROID__
+
+#include <jni.h>
+#include "../../interface.h"
 
-#ifdef WITH_POLICY
+typedef struct {
+  JavaVM *jvm;
+} android_cfg_t;
 
-#include <hicn/config/controlState.h>
-CommandOps *controlUpdateConnection_Create(ControlState *state);
-CommandOps *controlUpdateConnection_HelpCreate(ControlState *state);
+int android_on_network_event(interface_t *interface, const char *interface_name,
+                             netdevice_type_t netdevice_type, bool up,
+                             int family, const char *ip_address);
 
-#endif /* WITH_POLICY */
+#endif /* __ANDROID__ */
 
-#endif  // Control_UpdateConnection_h
+#endif /* FACEMGR_INTERFACE_ANDROID_H */
diff --git a/ctrl/facemgr/src/interfaces/android_utility/android_utility.c b/ctrl/facemgr/src/interfaces/android_utility/android_utility.c
deleted file mode 100644
index d8e20659a..000000000
--- a/ctrl/facemgr/src/interfaces/android_utility/android_utility.c
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * 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/android_utility/android_utility.c
- * \brief Implementation of Android utility.
- */
-
-#include <assert.h>
-
-#include <hicn/facemgr.h>
-#include <hicn/ctrl/face.h>
-#include <hicn/util/log.h>
-#include "../../common.h"
-#include "../../interface.h"
-
-#include "android_utility.h"
-
-#define FACEMGR_UTILITY_CLASS "com/cisco/hicn/facemgrlibrary/supportlibrary/FacemgrUtility"
-
-
-#define AU_INTERFACE_TYPE_UNDEFINED 0
-#define AU_INTERFACE_TYPE_WIRED     1
-#define AU_INTERFACE_TYPE_WIFI      2
-#define AU_INTERFACE_TYPE_CELLULAR  3
-#define AU_INTERFACE_TYPE_LOOPBACK  4
-#define AU_INTERFACE_TYPE_UNAVAILABLE 5
-
-#define ERR_STR_JAVA "Java VM parameters are required in the interface configuration."
-
-typedef struct {
-    android_utility_cfg_t cfg;
-} au_data_t;
-
-int au_initialize(interface_t * interface, void * cfg)
-{
-    au_data_t * data = malloc(sizeof(au_data_t));
-    if (!data)
-        return -1;
-    interface->data = data;
-
-    if (!cfg)
-        goto ERR_CFG;
-
-    data->cfg = * (android_utility_cfg_t *) cfg;
-
-    if (!data->cfg.jvm)
-        goto ERR_CFG;
-
-    return 0;
-
-ERR_CFG:
-        fprintf(stderr, ERR_STR_JAVA);
-        return -1;
-}
-
-int au_finalize(interface_t * interface)
-{
-    /* Nothing to do */
-    return 0;
-}
-
-int au_on_event(interface_t * interface, facelet_t * facelet)
-{
-    /*
-     * This function is responsible to annotate every face we receive with the
-     * correct interface type, based on the value returned by the Android
-     * utility shipped with the Android forwarder.
-     */
-    au_data_t * data = (au_data_t*)interface->data;
-
-    netdevice_t netdevice = NETDEVICE_EMPTY;
-    int rc = facelet_get_netdevice(facelet, &netdevice);
-    if (rc < 0)
-        return -1;
-
-    JNIEnv *env;
-    JavaVM *jvm = data->cfg.jvm;
-    (*jvm)->AttachCurrentThread(jvm, &env, NULL);
-    jclass cls = (*env)->FindClass(env, FACEMGR_UTILITY_CLASS);
-    jmethodID getNetworkType = (*env)->GetStaticMethodID(env, cls,
-            "getNetworkType", "(Ljava/lang/String;)I");
-    jint interface_type = (*env)->CallStaticIntMethod(env, cls, getNetworkType,
-            (*env)->NewStringUTF(env, netdevice.name));
-
-    netdevice_type_t netdevice_type = AU_INTERFACE_TYPE_UNDEFINED;
-    switch(interface_type) {
-        case AU_INTERFACE_TYPE_UNDEFINED:
-            break;
-        case AU_INTERFACE_TYPE_WIRED:
-            netdevice_type = NETDEVICE_TYPE_WIRED;
-            break;
-        case AU_INTERFACE_TYPE_WIFI:
-            netdevice_type = NETDEVICE_TYPE_WIFI;
-            break;
-        case AU_INTERFACE_TYPE_CELLULAR:
-            netdevice_type = NETDEVICE_TYPE_CELLULAR;
-            break;
-        case AU_INTERFACE_TYPE_LOOPBACK:
-            netdevice_type = NETDEVICE_TYPE_LOOPBACK;
-            break;
-        default:
-            DEBUG("AU RETURNED ERROR");
-            return -1;
-    }
-
-    DEBUG("AU RETURNED %s : %s", netdevice.name, netdevice_type_str[netdevice_type]);
-
-    facelet_t * facelet_new = facelet_create();
-    facelet_set_netdevice(facelet_new, netdevice);
-    facelet_set_attr_clean(facelet_new);
-    facelet_set_netdevice_type(facelet_new, netdevice_type);
-
-    facelet_set_event(facelet_new, FACELET_EVENT_UPDATE);
-    interface_raise_event(interface, facelet_new);
-
-    return 0;
-}
-
-const interface_ops_t android_utility_ops = {
-    .type = "android_utility",
-    .initialize = au_initialize,
-    .finalize = au_finalize,
-    .callback = NULL,
-    .on_event = au_on_event,
-};
diff --git a/ctrl/facemgr/src/interfaces/android_utility/android_utility.h b/ctrl/facemgr/src/interfaces/android_utility/android_utility.h
deleted file mode 100644
index 53adfedf6..000000000
--- a/ctrl/facemgr/src/interfaces/android_utility/android_utility.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * 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 android_utility/android_utility.h
- * \brief Android utility.
- *
- * This class relies on a small utility wrapper shipped with the Android
- * application to access to Java SDK APIs for information not available to
- * native code.
- *
- * For instance, we currently don't have on Linux any mean to get the type
- * associated to an interface, especially for cellular interfaces. WiFi and
- * Bluetooth information is for instance available through specific netlink
- * subsystems, or by means of a support library, but cellular detection mostly
- * relies on heuristics based on interface names (eg. in network manager).
- *
- * Android ship a Radio Interface Layer (RIL) daemon that exposes a control
- * socket to the Java API to control the radio layer, but there is no working
- * code exploiting it and no proper documentation.
- */
-
-#ifndef FACEMGR_INTERFACE_ANDROID_UTILITY_H
-#define FACEMGR_INTERFACE_ANDROID_UTILITY_H
-
-#ifdef __ANDROID__
-
-#include <jni.h>
-
-typedef struct {
-    JavaVM *jvm;
-} android_utility_cfg_t;
-
-#endif /* __ANDROID__ */
-
-#endif /* FACEMGR_INTERFACE_ANDROID_UTILITY_H */
diff --git a/ctrl/facemgr/src/interfaces/bonjour/CMakeLists.txt b/ctrl/facemgr/src/interfaces/bonjour/CMakeLists.txt
index 8a0ddc888..90ca0e47f 100644
--- a/ctrl/facemgr/src/interfaces/bonjour/CMakeLists.txt
+++ b/ctrl/facemgr/src/interfaces/bonjour/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/ctrl/facemgr/src/interfaces/bonjour/bonjour.c b/ctrl/facemgr/src/interfaces/bonjour/bonjour.c
index 40b7f5f90..90f18c299 100644
--- a/ctrl/facemgr/src/interfaces/bonjour/bonjour.c
+++ b/ctrl/facemgr/src/interfaces/bonjour/bonjour.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,6 +25,7 @@
 #include <hicn/facemgr.h>
 #include <hicn/util/log.h>
 #include <hicn/util/map.h>
+#include <hicn/util/sstrncpy.h>
 
 #include "../../common.h"
 #include "../../interface.h"
@@ -40,368 +41,357 @@
 #define DEFAULT_SERVICE_DOMAIN "local"
 
 typedef struct {
-    bonjour_cfg_t cfg;
-    int sock;
-    size_t buffer_size;
-    void* buffer;
+  bonjour_cfg_t cfg;
+  int sock;
+  size_t buffer_size;
+  void* buffer;
 
-    /* The face being resolved, non-NULL values indicate interface is busy... */
-    face_t * face;
+  /* The face being resolved, non-NULL values indicate interface is busy... */
+  face_t* face;
 } bj_data_t;
 
-int bj_initialize(interface_t * interface, void * cfg)
-{
-    bj_data_t * data = malloc(sizeof(bj_data_t));
-    if (!data)
-        goto ERR_MALLOC;
-    interface->data = data;
+int bj_initialize(interface_t* interface, void* cfg) {
+  bj_data_t* data = malloc(sizeof(bj_data_t));
+  if (!data) goto ERR_MALLOC;
+  interface->data = data;
 
-    if (cfg) {
+  if (cfg) {
 #ifndef __linux__
-        if (cfg->netdevice)
-            WARN("Binding to interface is (currently) only supported on Linux");
+    if (cfg->netdevice)
+      WARN("Binding to interface is (currently) only supported on Linux");
 #endif /* ! __linux__ */
-        data->cfg = * (bonjour_cfg_t *) cfg;
-    } else {
-        memset(&data->cfg, 0, sizeof(bonjour_cfg_t));
-    }
+    data->cfg = *(bonjour_cfg_t*)cfg;
+  } else {
+    memset(&data->cfg, 0, sizeof(bonjour_cfg_t));
+  }
 
-    if (!data->cfg.service_name)
-        data->cfg.service_name = DEFAULT_SERVICE_NAME;
+  if (!data->cfg.service_name) data->cfg.service_name = DEFAULT_SERVICE_NAME;
 
-    if (!data->cfg.service_protocol)
-        data->cfg.service_protocol = DEFAULT_SERVICE_PROTOCOL;
+  if (!data->cfg.service_protocol)
+    data->cfg.service_protocol = DEFAULT_SERVICE_PROTOCOL;
 
-    if (!data->cfg.service_domain)
-        data->cfg.service_domain = DEFAULT_SERVICE_DOMAIN;
+  if (!data->cfg.service_domain)
+    data->cfg.service_domain = DEFAULT_SERVICE_DOMAIN;
 
-    data->sock = mdns_socket_open_ipv4();
-    if (data->sock < 0) {
-        printf("Failed to open socket: %s\n", strerror(errno));
-        goto ERR_SOCK;
-    }
+  data->sock = mdns_socket_open_ipv4();
+  if (data->sock < 0) {
+    printf("Failed to open socket: %s\n", strerror(errno));
+    goto ERR_SOCK;
+  }
 
-    /* Netdevice configuration */
+  /* Netdevice configuration */
 #ifdef __linux__
 #ifndef __ANDROID__
-    if (IS_VALID_NETDEVICE(data->cfg.netdevice)) {
-        int rc = setsockopt(data->sock, SOL_SOCKET, SO_BINDTODEVICE,
-                &data->cfg.netdevice.name, strlen(data->cfg.netdevice.name) + 1);
-        if (rc == -1) {
-            ERROR("setsockopt");
-            goto ERR_SOCK_OPT;
-        }
+  if (IS_VALID_NETDEVICE(data->cfg.netdevice)) {
+    int rc = setsockopt(data->sock, SOL_SOCKET, SO_BINDTODEVICE,
+                        &data->cfg.netdevice.name,
+                        strnlen_s(data->cfg.netdevice.name, IFNAMSIZ));
+    if (rc == -1) {
+      ERROR("setsockopt");
+      goto ERR_SOCK_OPT;
     }
+  }
 #endif
 #endif /* __linux__ */
 
-    data->buffer_size = DEFAULT_BUFFER_SIZE;
-    data->buffer = malloc(data->buffer_size);
-    if (!data->buffer)
-        goto ERR_BUFFER;
+  data->buffer_size = DEFAULT_BUFFER_SIZE;
+  data->buffer = malloc(data->buffer_size);
+  if (!data->buffer) goto ERR_BUFFER;
 
 #ifdef _WIN32
-    WORD versionWanted = MAKEWORD(1, 1);
-    WSADATA wsaData;
-    WSAStartup(versionWanted, &wsaData);
+  WORD versionWanted = MAKEWORD(1, 1);
+  WSADATA wsaData;
+  WSAStartup(versionWanted, &wsaData);
 #endif
 
-    if (interface_register_fd(interface, data->sock, NULL) < 0) {
-        ERROR("[bj_initialize] Error registering fd");
-        goto ERR_FD;
-    }
+  if (interface_register_fd(interface, data->sock, NULL) < 0) {
+    ERROR("[bj_initialize] Error registering fd");
+    goto ERR_FD;
+  }
 
-    return 0;
+  return 0;
 
 ERR_FD:
-    free(data->buffer);
+  free(data->buffer);
 ERR_BUFFER:
 #ifndef __ANDROID__
 ERR_SOCK_OPT:
 #endif
-    mdns_socket_close(data->sock);
+  mdns_socket_close(data->sock);
 #ifdef _WIN32
-    WSACleanup();
+  WSACleanup();
 #endif
 ERR_SOCK:
-    free(data);
+  free(data);
 ERR_MALLOC:
-    return -1;
+  return -1;
 }
 
 /*
  * We reuse the callback to be triggered upon external events
  * TODO: move to a cleaner interface architecture later...
  */
-int bj_on_event(interface_t * interface, facelet_t * facelet)
-{
-    bj_data_t * data = (bj_data_t*)interface->data;
-
-    /*
-    printf("Sending DNS-SD discovery\n");
-    if (mdns_discovery_send(sock)) {
-            printf("Failed to send DNS-DS discovery: %s\n", strerror(errno));
-            goto quit;
-    }
-
-    printf("Reading DNS-SD replies\n");
-    for (int i = 0; i < 10; ++i) {
-            records = mdns_discovery_recv(sock, buffer, capacity, callback,
-                                          user_data);
-            sleep(1);
-    }
-    */
-
-    DEBUG("Sending mDNS query");
-    char service_string[SERVICE_STRING_SIZE];
-
-    int rc = snprintf(service_string, SERVICE_STRING_SIZE, "_%s._%s.%s.",
-            data->cfg.service_name, data->cfg.service_protocol,
-            data->cfg.service_domain);
-    if (rc < 0)
-        ; // error
-    else if (rc >= SERVICE_STRING_SIZE)
-        ; //truncated
-
-    if (mdns_query_send(data->sock, MDNS_RECORDTYPE_PTR,
-                        service_string,
-                        strlen(service_string),
-                        data->buffer, data->buffer_size)) {
-            printf("Failed to send mDNS query: %s\n", strerror(errno));
-            return -1;
-    }
-    return 0;
+int bj_on_event(interface_t* interface, facelet_t* facelet) {
+  bj_data_t* data = (bj_data_t*)interface->data;
+
+  /*
+  printf("Sending DNS-SD discovery\n");
+  if (mdns_discovery_send(sock)) {
+          printf("Failed to send DNS-DS discovery: %s\n", strerror(errno));
+          goto quit;
+  }
+
+  printf("Reading DNS-SD replies\n");
+  for (int i = 0; i < 10; ++i) {
+          records = mdns_discovery_recv(sock, buffer, capacity, callback,
+                                        user_data);
+          sleep(1);
+  }
+  */
+
+  DEBUG("Sending mDNS query");
+  char service_string[SERVICE_STRING_SIZE];
+
+  int rc = snprintf(service_string, SERVICE_STRING_SIZE, "_%s._%s.%s.",
+                    data->cfg.service_name, data->cfg.service_protocol,
+                    data->cfg.service_domain);
+  if (rc < 0)
+    ;  // error
+  else if (rc >= SERVICE_STRING_SIZE)
+    ;  // truncated
+
+  if (mdns_query_send(data->sock, MDNS_RECORDTYPE_PTR, service_string,
+                      strnlen_s(service_string, SERVICE_STRING_SIZE),
+                      data->buffer, data->buffer_size)) {
+    printf("Failed to send mDNS query: %s\n", strerror(errno));
+    return -1;
+  }
+  return 0;
 }
 
 static char addrbuffer[64];
 static char namebuffer[256];
 static mdns_record_txt_t txtbuffer[128];
 
-static mdns_string_t
-ipv4_address_to_string(char* buffer, size_t capacity, const struct sockaddr_in* addr) {
-	char host[NI_MAXHOST] = {0};
-	char service[NI_MAXSERV] = {0};
-	int ret = getnameinfo((const struct sockaddr*)addr, sizeof(struct sockaddr_in),
-	                      host, NI_MAXHOST, service, NI_MAXSERV,
-	                      NI_NUMERICSERV | NI_NUMERICHOST);
-	int len = 0;
-	if (ret == 0) {
-		if (addr->sin_port != 0)
-			len = snprintf(buffer, capacity, "%s:%s", host, service);
-		else
-			len = snprintf(buffer, capacity, "%s", host);
-	}
-	if (len >= (int)capacity)
-		len = (int)capacity - 1;
-	mdns_string_t str = {buffer, len};
-	return str;
+static mdns_string_t ipv4_address_to_string(char* buffer, size_t capacity,
+                                            const struct sockaddr_in* addr) {
+  char host[NI_MAXHOST] = {0};
+  char service[NI_MAXSERV] = {0};
+  int ret = getnameinfo((const struct sockaddr*)addr,
+                        sizeof(struct sockaddr_in), host, NI_MAXHOST, service,
+                        NI_MAXSERV, NI_NUMERICSERV | NI_NUMERICHOST);
+  int len = 0;
+  if (ret == 0) {
+    if (addr->sin_port != 0)
+      len = snprintf(buffer, capacity, "%s:%s", host, service);
+    else
+      len = snprintf(buffer, capacity, "%s", host);
+  }
+  if (len >= (int)capacity) len = (int)capacity - 1;
+  mdns_string_t str = {buffer, len};
+  return str;
 }
 
-static mdns_string_t
-ipv6_address_to_string(char* buffer, size_t capacity, const struct sockaddr_in6* addr) {
-	char host[NI_MAXHOST] = {0};
-	char service[NI_MAXSERV] = {0};
-	int ret = getnameinfo((const struct sockaddr*)addr, sizeof(struct sockaddr_in6),
-	                      host, NI_MAXHOST, service, NI_MAXSERV,
-	                      NI_NUMERICSERV | NI_NUMERICHOST);
-	int len = 0;
-	if (ret == 0) {
-		if (addr->sin6_port != 0)
-			len = snprintf(buffer, capacity, "[%s]:%s", host, service);
-		else
-			len = snprintf(buffer, capacity, "%s", host);
-	}
-	if (len >= (int)capacity)
-		len = (int)capacity - 1;
-	mdns_string_t str = {buffer, len};
-	return str;
+static mdns_string_t ipv6_address_to_string(char* buffer, size_t capacity,
+                                            const struct sockaddr_in6* addr) {
+  char host[NI_MAXHOST] = {0};
+  char service[NI_MAXSERV] = {0};
+  int ret = getnameinfo((const struct sockaddr*)addr,
+                        sizeof(struct sockaddr_in6), host, NI_MAXHOST, service,
+                        NI_MAXSERV, NI_NUMERICSERV | NI_NUMERICHOST);
+  int len = 0;
+  if (ret == 0) {
+    if (addr->sin6_port != 0)
+      len = snprintf(buffer, capacity, "[%s]:%s", host, service);
+    else
+      len = snprintf(buffer, capacity, "%s", host);
+  }
+  if (len >= (int)capacity) len = (int)capacity - 1;
+  mdns_string_t str = {buffer, len};
+  return str;
 }
 
-static mdns_string_t
-ip_address_to_string(char* buffer, size_t capacity, const struct sockaddr* addr) {
-	if (addr->sa_family == AF_INET6)
-		return ipv6_address_to_string(buffer, capacity, (const struct sockaddr_in6*)addr);
-	return ipv4_address_to_string(buffer, capacity, (const struct sockaddr_in*)addr);
+static mdns_string_t ip_address_to_string(char* buffer, size_t capacity,
+                                          const struct sockaddr* addr) {
+  if (addr->sa_family == AF_INET6)
+    return ipv6_address_to_string(buffer, capacity,
+                                  (const struct sockaddr_in6*)addr);
+  return ipv4_address_to_string(buffer, capacity,
+                                (const struct sockaddr_in*)addr);
 }
 
-int
-ip_address_set_sockaddr(ip_address_t * ip_address, struct sockaddr * sa)
-{
-    switch(sa->sa_family) {
-        case AF_INET:
-            ip_address->v4.as_inaddr = ((struct sockaddr_in *)sa)->sin_addr;
-            break;
-        case AF_INET6:
-            ip_address->v6.as_in6addr = ((struct sockaddr_in6 *)sa)->sin6_addr;
-            break;
-        default:
-            return -1;
-    }
-
-    return 0;
+int ip_address_set_sockaddr(ip_address_t* ip_address, struct sockaddr* sa) {
+  switch (sa->sa_family) {
+    case AF_INET:
+      ip_address->v4.as_inaddr = ((struct sockaddr_in*)sa)->sin_addr;
+      break;
+    case AF_INET6:
+      ip_address->v6.as_in6addr = ((struct sockaddr_in6*)sa)->sin6_addr;
+      break;
+    default:
+      return -1;
+  }
+
+  return 0;
 }
 
-static int
-callback(const struct sockaddr* from, mdns_entry_type_t entry, uint16_t type,
-        uint16_t rclass, uint32_t ttl, const void* data, size_t size, size_t
-        offset, size_t length, void* user_data)
-{
-    interface_t * interface = (interface_t*)user_data;
-    bj_data_t * bj_data = (bj_data_t *)interface->data;
-
-    struct sockaddr_storage addr;
-
-    mdns_string_t fromaddrstr = ip_address_to_string(addrbuffer, sizeof(addrbuffer), from);
-    const char* entrytype = (entry == MDNS_ENTRYTYPE_ANSWER) ? "answer" :
-        ((entry == MDNS_ENTRYTYPE_AUTHORITY) ? "authority" : "additional");
-
-    switch(type) {
-        case MDNS_RECORDTYPE_A:
-        {
-            ip_address_t ip_address;
-            mdns_record_parse_a(data, size, offset, length, (struct sockaddr_in*)&addr);
-            ip_address_set_sockaddr(&ip_address, (struct sockaddr *)&addr);
-
-            mdns_string_t addrstr = ipv4_address_to_string(namebuffer, sizeof(namebuffer), (struct sockaddr_in *)&addr);
-            DEBUG("%.*s : %s A %.*s",
-                    MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-                    MDNS_STRING_FORMAT(addrstr));
-
-            facelet_t * facelet = facelet_create();
-            facelet_set_netdevice(facelet, bj_data->cfg.netdevice);
-            facelet_set_family(facelet, AF_INET);
-            facelet_set_remote_addr(facelet, ip_address);
-            //facelet_set_remote_port(facelet, ((struct sockaddr_in*)&addr)->sin_port);
-
-            facelet_set_event(facelet, FACELET_EVENT_UPDATE);
-            interface_raise_event(interface, facelet);
-            break;
-        }
+static int callback(const struct sockaddr* from, mdns_entry_type_t entry,
+                    uint16_t type, uint16_t rclass, uint32_t ttl,
+                    const void* data, size_t size, size_t offset, size_t length,
+                    void* user_data) {
+  interface_t* interface = (interface_t*)user_data;
+  bj_data_t* bj_data = (bj_data_t*)interface->data;
+
+  struct sockaddr_storage addr;
+
+  mdns_string_t fromaddrstr =
+      ip_address_to_string(addrbuffer, sizeof(addrbuffer), from);
+  const char* entrytype =
+      (entry == MDNS_ENTRYTYPE_ANSWER)
+          ? "answer"
+          : ((entry == MDNS_ENTRYTYPE_AUTHORITY) ? "authority" : "additional");
+
+  switch (type) {
+    case MDNS_RECORDTYPE_A: {
+      ip_address_t ip_address;
+      mdns_record_parse_a(data, size, offset, length,
+                          (struct sockaddr_in*)&addr);
+      ip_address_set_sockaddr(&ip_address, (struct sockaddr*)&addr);
+
+      mdns_string_t addrstr = ipv4_address_to_string(
+          namebuffer, sizeof(namebuffer), (struct sockaddr_in*)&addr);
+      DEBUG("%.*s : %s A %.*s", MDNS_STRING_FORMAT(fromaddrstr), entrytype,
+            MDNS_STRING_FORMAT(addrstr));
+
+      facelet_t* facelet = facelet_create();
+      facelet_set_netdevice(facelet, bj_data->cfg.netdevice);
+      facelet_set_family(facelet, AF_INET);
+      facelet_set_remote_addr(facelet, ip_address);
+      // facelet_set_remote_port(facelet, ((struct
+      // sockaddr_in*)&addr)->sin_port);
+
+      facelet_set_event(facelet, FACELET_EVENT_UPDATE);
+      interface_raise_event(interface, facelet);
+      break;
+    }
 
-        case MDNS_RECORDTYPE_AAAA:
-        {
-            ip_address_t ip_address;
-            mdns_record_parse_aaaa(data, size, offset, length, (struct sockaddr_in6*)&addr);
-            ip_address_set_sockaddr(&ip_address, (struct sockaddr *)&addr);
-
-            mdns_string_t addrstr = ipv6_address_to_string(namebuffer,
-                    sizeof(namebuffer), (struct sockaddr_in6*)&addr);
-            DEBUG("%.*s : %s AAAA %.*s",
-                    MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-                    MDNS_STRING_FORMAT(addrstr));
-
-            facelet_t * facelet = facelet_create();
-            facelet_set_netdevice(facelet, bj_data->cfg.netdevice);
-            facelet_set_family(facelet, AF_INET6);
-            facelet_set_remote_addr(facelet, ip_address);
-            //facelet_set_remote_port(facelet, ((struct sockaddr_in6*)&addr)->sin6_port);
-
-            facelet_set_event(facelet, FACELET_EVENT_UPDATE);
-            interface_raise_event(interface, facelet);
-            break;
-        }
+    case MDNS_RECORDTYPE_AAAA: {
+      ip_address_t ip_address;
+      mdns_record_parse_aaaa(data, size, offset, length,
+                             (struct sockaddr_in6*)&addr);
+      ip_address_set_sockaddr(&ip_address, (struct sockaddr*)&addr);
+
+      mdns_string_t addrstr = ipv6_address_to_string(
+          namebuffer, sizeof(namebuffer), (struct sockaddr_in6*)&addr);
+      DEBUG("%.*s : %s AAAA %.*s", MDNS_STRING_FORMAT(fromaddrstr), entrytype,
+            MDNS_STRING_FORMAT(addrstr));
+
+      facelet_t* facelet = facelet_create();
+      facelet_set_netdevice(facelet, bj_data->cfg.netdevice);
+      facelet_set_family(facelet, AF_INET6);
+      facelet_set_remote_addr(facelet, ip_address);
+      // facelet_set_remote_port(facelet, ((struct
+      // sockaddr_in6*)&addr)->sin6_port);
+
+      facelet_set_event(facelet, FACELET_EVENT_UPDATE);
+      interface_raise_event(interface, facelet);
+      break;
+    }
 
-        case MDNS_RECORDTYPE_SRV: /* same port for both v4 and v6 */
-        {
-            mdns_record_srv_t srv = mdns_record_parse_srv(data, size, offset, length,
-                    namebuffer, sizeof(namebuffer));
-
-            DEBUG("%.*s : %s SRV %.*s priority %d weight %d port %d",
-                    MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-                    MDNS_STRING_FORMAT(srv.name), srv.priority, srv.weight, srv.port);
-
-            /* We raise both v4 and v6
-             *
-             * Unless we choose whether we query A and/or AAAA, this might leave
-             * us with an unused pending facelet, eg. we might not have an IPv6
-             * but we raise an IPv6 bonjour event...
-             */
-
-            facelet_t * facelet = facelet_create();
-            facelet_set_netdevice(facelet, bj_data->cfg.netdevice);
-            facelet_set_family(facelet, AF_INET);
-            facelet_set_remote_port(facelet, srv.port);
-
-            facelet_set_event(facelet, FACELET_EVENT_UPDATE);
-            interface_raise_event(interface, facelet);
-
-            facelet = facelet_create();
-            facelet_set_netdevice(facelet, bj_data->cfg.netdevice);
-            facelet_set_family(facelet, AF_INET6);
-            facelet_set_remote_port(facelet, srv.port);
-
-            facelet_set_event(facelet, FACELET_EVENT_UPDATE);
-            interface_raise_event(interface, facelet);
-            break;
-        }
+    case MDNS_RECORDTYPE_SRV: /* same port for both v4 and v6 */
+    {
+      mdns_record_srv_t srv = mdns_record_parse_srv(
+          data, size, offset, length, namebuffer, sizeof(namebuffer));
+
+      DEBUG("%.*s : %s SRV %.*s priority %d weight %d port %d",
+            MDNS_STRING_FORMAT(fromaddrstr), entrytype,
+            MDNS_STRING_FORMAT(srv.name), srv.priority, srv.weight, srv.port);
+
+      /* We raise both v4 and v6
+       *
+       * Unless we choose whether we query A and/or AAAA, this might leave
+       * us with an unused pending facelet, eg. we might not have an IPv6
+       * but we raise an IPv6 bonjour event...
+       */
+
+      facelet_t* facelet = facelet_create();
+      facelet_set_netdevice(facelet, bj_data->cfg.netdevice);
+      facelet_set_family(facelet, AF_INET);
+      facelet_set_remote_port(facelet, srv.port);
+
+      facelet_set_event(facelet, FACELET_EVENT_UPDATE);
+      interface_raise_event(interface, facelet);
+
+      facelet = facelet_create();
+      facelet_set_netdevice(facelet, bj_data->cfg.netdevice);
+      facelet_set_family(facelet, AF_INET6);
+      facelet_set_remote_port(facelet, srv.port);
+
+      facelet_set_event(facelet, FACELET_EVENT_UPDATE);
+      interface_raise_event(interface, facelet);
+      break;
+    }
 
-        case MDNS_RECORDTYPE_PTR:
-        {
-            mdns_string_t namestr = mdns_record_parse_ptr(data, size, offset, length,
-                    namebuffer, sizeof(namebuffer));
-            DEBUG("%.*s : %s PTR %.*s type %u rclass 0x%x ttl %u length %d",
-                    MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-                    MDNS_STRING_FORMAT(namestr), type, rclass, ttl, (int)length);
-            break;
-        }
+    case MDNS_RECORDTYPE_PTR: {
+      mdns_string_t namestr = mdns_record_parse_ptr(
+          data, size, offset, length, namebuffer, sizeof(namebuffer));
+      DEBUG("%.*s : %s PTR %.*s type %u rclass 0x%x ttl %u length %d",
+            MDNS_STRING_FORMAT(fromaddrstr), entrytype,
+            MDNS_STRING_FORMAT(namestr), type, rclass, ttl, (int)length);
+      break;
+    }
 
-        case MDNS_RECORDTYPE_TXT:
-        {
-            size_t parsed = mdns_record_parse_txt(data, size, offset, length,
-                    txtbuffer, sizeof(txtbuffer) / sizeof(mdns_record_txt_t));
-            for (size_t itxt = 0; itxt < parsed; ++itxt) {
-                if (txtbuffer[itxt].value.length) {
-                    DEBUG("%.*s : %s TXT %.*s = %.*s",
-                            MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-                            MDNS_STRING_FORMAT(txtbuffer[itxt].key),
-                            MDNS_STRING_FORMAT(txtbuffer[itxt].value));
-                }
-                else {
-                    DEBUG("%.*s : %s TXT %.*s",
-                            MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-                            MDNS_STRING_FORMAT(txtbuffer[itxt].key));
-                }
-            }
-            break;
+    case MDNS_RECORDTYPE_TXT: {
+      size_t parsed =
+          mdns_record_parse_txt(data, size, offset, length, txtbuffer,
+                                sizeof(txtbuffer) / sizeof(mdns_record_txt_t));
+      for (size_t itxt = 0; itxt < parsed; ++itxt) {
+        if (txtbuffer[itxt].value.length) {
+          DEBUG("%.*s : %s TXT %.*s = %.*s", MDNS_STRING_FORMAT(fromaddrstr),
+                entrytype, MDNS_STRING_FORMAT(txtbuffer[itxt].key),
+                MDNS_STRING_FORMAT(txtbuffer[itxt].value));
+        } else {
+          DEBUG("%.*s : %s TXT %.*s", MDNS_STRING_FORMAT(fromaddrstr),
+                entrytype, MDNS_STRING_FORMAT(txtbuffer[itxt].key));
         }
-
-        default:
-            /* Silently ignore the received record */
-            DEBUG("%.*s : %s type %u rclass 0x%x ttl %u length %d",
-                    MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-                    type, rclass, ttl, (int)length);
-            return 0;
+      }
+      break;
     }
-    return 0;
 
+    default:
+      /* Silently ignore the received record */
+      DEBUG("%.*s : %s type %u rclass 0x%x ttl %u length %d",
+            MDNS_STRING_FORMAT(fromaddrstr), entrytype, type, rclass, ttl,
+            (int)length);
+      return 0;
+  }
+  return 0;
 }
 
 /*
  * The fact we use a single fd does not allow us to get user_data associated to
  * the query.
  */
-int bj_callback(interface_t * interface, int fd, void * unused)
-{
-    bj_data_t * data = (bj_data_t*)interface->data;
-    DEBUG("Got an mDNS reply");
-    /* size_t records = */ mdns_query_recv(data->sock, data->buffer, data->buffer_size, callback, interface, 1);
+int bj_callback(interface_t* interface, int fd, void* unused) {
+  bj_data_t* data = (bj_data_t*)interface->data;
+  DEBUG("Got an mDNS reply");
+  /* size_t records = */ mdns_query_recv(
+      data->sock, data->buffer, data->buffer_size, callback, interface, 1);
 
-    return 0;
+  return 0;
 }
 
-int bj_finalize(interface_t * interface)
-{
-    bj_data_t * data = (bj_data_t*)interface->data;
+int bj_finalize(interface_t* interface) {
+  bj_data_t* data = (bj_data_t*)interface->data;
 
-    free(data->buffer);
-    mdns_socket_close(data->sock);
+  free(data->buffer);
+  mdns_socket_close(data->sock);
 
 #ifdef _WIN32
-    WSACleanup();
+  WSACleanup();
 #endif
 
-    return 0;
-
+  return 0;
 }
 
 const interface_ops_t bonjour_ops = {
@@ -410,5 +400,5 @@ const interface_ops_t bonjour_ops = {
     .on_event = bj_on_event,
     .callback = bj_callback,
     .finalize = bj_finalize,
-  //  .on_event = NULL,
+    //  .on_event = NULL,
 };
diff --git a/ctrl/facemgr/src/interfaces/bonjour/bonjour.h b/ctrl/facemgr/src/interfaces/bonjour/bonjour.h
index fe053079d..6458423ea 100644
--- a/ctrl/facemgr/src/interfaces/bonjour/bonjour.h
+++ b/ctrl/facemgr/src/interfaces/bonjour/bonjour.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,11 +25,11 @@
  *  queries...
  */
 
-#include <hicn/ctrl/face.h> /* netdevice_t */
+#include <hicn/face.h> /* netdevice_t */
 
 typedef struct {
-    netdevice_t netdevice;
-    char * service_name;
-    char * service_protocol;
-    char * service_domain;
+  netdevice_t netdevice;
+  char* service_name;
+  char* service_protocol;
+  char* service_domain;
 } bonjour_cfg_t;
diff --git a/ctrl/facemgr/src/interfaces/bonjour/mdns/mdns.c b/ctrl/facemgr/src/interfaces/bonjour/mdns/mdns.c
index a8e97e8e0..e2bb4f432 100644
--- a/ctrl/facemgr/src/interfaces/bonjour/mdns/mdns.c
+++ b/ctrl/facemgr/src/interfaces/bonjour/mdns/mdns.c
@@ -1,6 +1,6 @@
 
 #ifdef _WIN32
-#  define _CRT_SECURE_NO_WARNINGS 1
+#define _CRT_SECURE_NO_WARNINGS 1
 #endif
 
 #include "mdns.h"
@@ -9,184 +9,176 @@
 #include <errno.h>
 
 #ifdef _WIN32
-#  define sleep(x) Sleep(x * 1000)
+#define sleep(x) Sleep(x * 1000)
 #else
-#  include <netdb.h>
+#include <netdb.h>
 #endif
 
 static char addrbuffer[64];
 static char namebuffer[256];
 static mdns_record_txt_t txtbuffer[128];
 
-static mdns_string_t
-ipv4_address_to_string(char* buffer, size_t capacity, const struct sockaddr_in* addr) {
-	char host[NI_MAXHOST] = {0};
-	char service[NI_MAXSERV] = {0};
-	int ret = getnameinfo((const struct sockaddr*)addr, sizeof(struct sockaddr_in),
-	                      host, NI_MAXHOST, service, NI_MAXSERV,
-	                      NI_NUMERICSERV | NI_NUMERICHOST);
-	int len = 0;
-	if (ret == 0) {
-		if (addr->sin_port != 0)
-			len = snprintf(buffer, capacity, "%s:%s", host, service);
-		else
-			len = snprintf(buffer, capacity, "%s", host);
-	}
-	if (len >= (int)capacity)
-		len = (int)capacity - 1;
-	mdns_string_t str = {buffer, len};
-	return str;
+static mdns_string_t ipv4_address_to_string(char* buffer, size_t capacity,
+                                            const struct sockaddr_in* addr) {
+  char host[NI_MAXHOST] = {0};
+  char service[NI_MAXSERV] = {0};
+  int ret = getnameinfo((const struct sockaddr*)addr,
+                        sizeof(struct sockaddr_in), host, NI_MAXHOST, service,
+                        NI_MAXSERV, NI_NUMERICSERV | NI_NUMERICHOST);
+  int len = 0;
+  if (ret == 0) {
+    if (addr->sin_port != 0)
+      len = snprintf(buffer, capacity, "%s:%s", host, service);
+    else
+      len = snprintf(buffer, capacity, "%s", host);
+  }
+  if (len >= (int)capacity) len = (int)capacity - 1;
+  mdns_string_t str = {buffer, len};
+  return str;
 }
 
-static mdns_string_t
-ipv6_address_to_string(char* buffer, size_t capacity, const struct sockaddr_in6* addr) {
-	char host[NI_MAXHOST] = {0};
-	char service[NI_MAXSERV] = {0};
-	int ret = getnameinfo((const struct sockaddr*)addr, sizeof(struct sockaddr_in6),
-	                      host, NI_MAXHOST, service, NI_MAXSERV,
-	                      NI_NUMERICSERV | NI_NUMERICHOST);
-	int len = 0;
-	if (ret == 0) {
-		if (addr->sin6_port != 0)
-			len = snprintf(buffer, capacity, "[%s]:%s", host, service);
-		else
-			len = snprintf(buffer, capacity, "%s", host);
-	}
-	if (len >= (int)capacity)
-		len = (int)capacity - 1;
-	mdns_string_t str = {buffer, len};
-	return str;
+static mdns_string_t ipv6_address_to_string(char* buffer, size_t capacity,
+                                            const struct sockaddr_in6* addr) {
+  char host[NI_MAXHOST] = {0};
+  char service[NI_MAXSERV] = {0};
+  int ret = getnameinfo((const struct sockaddr*)addr,
+                        sizeof(struct sockaddr_in6), host, NI_MAXHOST, service,
+                        NI_MAXSERV, NI_NUMERICSERV | NI_NUMERICHOST);
+  int len = 0;
+  if (ret == 0) {
+    if (addr->sin6_port != 0)
+      len = snprintf(buffer, capacity, "[%s]:%s", host, service);
+    else
+      len = snprintf(buffer, capacity, "%s", host);
+  }
+  if (len >= (int)capacity) len = (int)capacity - 1;
+  mdns_string_t str = {buffer, len};
+  return str;
 }
 
-static mdns_string_t
-ip_address_to_string(char* buffer, size_t capacity, const struct sockaddr* addr) {
-	if (addr->sa_family == AF_INET6)
-		return ipv6_address_to_string(buffer, capacity, (const struct sockaddr_in6*)addr);
-	return ipv4_address_to_string(buffer, capacity, (const struct sockaddr_in*)addr);
+static mdns_string_t ip_address_to_string(char* buffer, size_t capacity,
+                                          const struct sockaddr* addr) {
+  if (addr->sa_family == AF_INET6)
+    return ipv6_address_to_string(buffer, capacity,
+                                  (const struct sockaddr_in6*)addr);
+  return ipv4_address_to_string(buffer, capacity,
+                                (const struct sockaddr_in*)addr);
 }
 
-static int
-callback(const struct sockaddr* from,
-         mdns_entry_type_t entry, uint16_t type,
-         uint16_t rclass, uint32_t ttl,
-         const void* data, size_t size, size_t offset, size_t length,
-         void* user_data) {
-	mdns_string_t fromaddrstr = ip_address_to_string(addrbuffer, sizeof(addrbuffer), from);
-	const char* entrytype = (entry == MDNS_ENTRYTYPE_ANSWER) ? "answer" :
-	                        ((entry == MDNS_ENTRYTYPE_AUTHORITY) ? "authority" : "additional");
-	if (type == MDNS_RECORDTYPE_PTR) {
-		mdns_string_t namestr = mdns_record_parse_ptr(data, size, offset, length,
-		                                              namebuffer, sizeof(namebuffer));
-		INFO("%.*s : %s PTR %.*s type %u rclass 0x%x ttl %u length %d\n",
-		       MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-		       MDNS_STRING_FORMAT(namestr), type, rclass, ttl, (int)length);
-	}
-	else if (type == MDNS_RECORDTYPE_SRV) {
-		mdns_record_srv_t srv = mdns_record_parse_srv(data, size, offset, length,
-		                                              namebuffer, sizeof(namebuffer));
-		INFO("%.*s : %s SRV %.*s priority %d weight %d port %d\n",
-		       MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-		       MDNS_STRING_FORMAT(srv.name), srv.priority, srv.weight, srv.port);
-	}
-	else if (type == MDNS_RECORDTYPE_A) {
-		struct sockaddr_in addr;
-		mdns_record_parse_a(data, size, offset, length, &addr);
-		mdns_string_t addrstr = ipv4_address_to_string(namebuffer, sizeof(namebuffer), &addr);
-		INFO("%.*s : %s A %.*s\n",
-		       MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-		       MDNS_STRING_FORMAT(addrstr));
-	}
-	else if (type == MDNS_RECORDTYPE_AAAA) {
-		struct sockaddr_in6 addr;
-		mdns_record_parse_aaaa(data, size, offset, length, &addr);
-		mdns_string_t addrstr = ipv6_address_to_string(namebuffer, sizeof(namebuffer), &addr);
-		INFO("%.*s : %s AAAA %.*s\n",
-		       MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-		       MDNS_STRING_FORMAT(addrstr));
-	}
-	else if (type == MDNS_RECORDTYPE_TXT) {
-		size_t parsed = mdns_record_parse_txt(data, size, offset, length,
-		                                      txtbuffer, sizeof(txtbuffer) / sizeof(mdns_record_txt_t));
-		for (size_t itxt = 0; itxt < parsed; ++itxt) {
-			if (txtbuffer[itxt].value.length) {
-				INFO("%.*s : %s TXT %.*s = %.*s\n",
-				       MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-				       MDNS_STRING_FORMAT(txtbuffer[itxt].key),
-				       MDNS_STRING_FORMAT(txtbuffer[itxt].value));
-			}
-			else {
-				INFO("%.*s : %s TXT %.*s\n",
-				       MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-				       MDNS_STRING_FORMAT(txtbuffer[itxt].key));
-			}
-		}
-	}
-	else {
-		INFO("%.*s : %s type %u rclass 0x%x ttl %u length %d\n",
-		       MDNS_STRING_FORMAT(fromaddrstr), entrytype,
-		       type, rclass, ttl, (int)length);
-	}
-	return 0;
+static int callback(const struct sockaddr* from, mdns_entry_type_t entry,
+                    uint16_t type, uint16_t rclass, uint32_t ttl,
+                    const void* data, size_t size, size_t offset, size_t length,
+                    void* user_data) {
+  mdns_string_t fromaddrstr =
+      ip_address_to_string(addrbuffer, sizeof(addrbuffer), from);
+  const char* entrytype =
+      (entry == MDNS_ENTRYTYPE_ANSWER)
+          ? "answer"
+          : ((entry == MDNS_ENTRYTYPE_AUTHORITY) ? "authority" : "additional");
+  if (type == MDNS_RECORDTYPE_PTR) {
+    mdns_string_t namestr = mdns_record_parse_ptr(
+        data, size, offset, length, namebuffer, sizeof(namebuffer));
+    INFO("%.*s : %s PTR %.*s type %u rclass 0x%x ttl %u length %d\n",
+         MDNS_STRING_FORMAT(fromaddrstr), entrytype,
+         MDNS_STRING_FORMAT(namestr), type, rclass, ttl, (int)length);
+  } else if (type == MDNS_RECORDTYPE_SRV) {
+    mdns_record_srv_t srv = mdns_record_parse_srv(
+        data, size, offset, length, namebuffer, sizeof(namebuffer));
+    INFO("%.*s : %s SRV %.*s priority %d weight %d port %d\n",
+         MDNS_STRING_FORMAT(fromaddrstr), entrytype,
+         MDNS_STRING_FORMAT(srv.name), srv.priority, srv.weight, srv.port);
+  } else if (type == MDNS_RECORDTYPE_A) {
+    struct sockaddr_in addr;
+    mdns_record_parse_a(data, size, offset, length, &addr);
+    mdns_string_t addrstr =
+        ipv4_address_to_string(namebuffer, sizeof(namebuffer), &addr);
+    INFO("%.*s : %s A %.*s\n", MDNS_STRING_FORMAT(fromaddrstr), entrytype,
+         MDNS_STRING_FORMAT(addrstr));
+  } else if (type == MDNS_RECORDTYPE_AAAA) {
+    struct sockaddr_in6 addr;
+    mdns_record_parse_aaaa(data, size, offset, length, &addr);
+    mdns_string_t addrstr =
+        ipv6_address_to_string(namebuffer, sizeof(namebuffer), &addr);
+    INFO("%.*s : %s AAAA %.*s\n", MDNS_STRING_FORMAT(fromaddrstr), entrytype,
+         MDNS_STRING_FORMAT(addrstr));
+  } else if (type == MDNS_RECORDTYPE_TXT) {
+    size_t parsed =
+        mdns_record_parse_txt(data, size, offset, length, txtbuffer,
+                              sizeof(txtbuffer) / sizeof(mdns_record_txt_t));
+    for (size_t itxt = 0; itxt < parsed; ++itxt) {
+      if (txtbuffer[itxt].value.length) {
+        INFO("%.*s : %s TXT %.*s = %.*s\n", MDNS_STRING_FORMAT(fromaddrstr),
+             entrytype, MDNS_STRING_FORMAT(txtbuffer[itxt].key),
+             MDNS_STRING_FORMAT(txtbuffer[itxt].value));
+      } else {
+        INFO("%.*s : %s TXT %.*s\n", MDNS_STRING_FORMAT(fromaddrstr), entrytype,
+             MDNS_STRING_FORMAT(txtbuffer[itxt].key));
+      }
+    }
+  } else {
+    INFO("%.*s : %s type %u rclass 0x%x ttl %u length %d\n",
+         MDNS_STRING_FORMAT(fromaddrstr), entrytype, type, rclass, ttl,
+         (int)length);
+  }
+  return 0;
 }
 
-int
-main() {
-	size_t capacity = 2048;
-	void* buffer = 0;
-	void* user_data = 0;
-	size_t records;
+int main() {
+  size_t capacity = 2048;
+  void* buffer = 0;
+  void* user_data = 0;
+  size_t records;
 
 #ifdef _WIN32
-	WORD versionWanted = MAKEWORD(1, 1);
-	WSADATA wsaData;
-	WSAStartup(versionWanted, &wsaData);
+  WORD versionWanted = MAKEWORD(1, 1);
+  WSADATA wsaData;
+  WSAStartup(versionWanted, &wsaData);
 #endif
 
-	int sock = mdns_socket_open_ipv4();
-	if (sock < 0) {
-		INFO("Failed to open socket: %s\n", strerror(errno));
-		return -1;
-	}
-	INFO("Opened IPv4 socket for mDNS/DNS-SD\n");
-	buffer = malloc(capacity);
-/*
-	INFO("Sending DNS-SD discovery\n");
-	if (mdns_discovery_send(sock)) {
-		INFO("Failed to send DNS-DS discovery: %s\n", strerror(errno));
-		goto quit;
-	}
-
-	INFO("Reading DNS-SD replies\n");
-	for (int i = 0; i < 10; ++i) {
-		records = mdns_discovery_recv(sock, buffer, capacity, callback,
-		                              user_data);
-		sleep(1);
-	}
-        */
-
-	INFO("Sending mDNS query\n");
-	if (mdns_query_send(sock, MDNS_RECORDTYPE_PTR,
-	                    MDNS_STRING_CONST("_hicn._udp.local."),
-	                    buffer, capacity)) {
-		INFO("Failed to send mDNS query: %s\n", strerror(errno));
-		goto quit;
-	}
-
-	INFO("Reading mDNS replies\n");
-	for (int i = 0; i < 10; ++i) {
-		records = mdns_query_recv(sock, buffer, capacity, callback, user_data, 1);
-		sleep(1);
-	}
+  int sock = mdns_socket_open_ipv4();
+  if (sock < 0) {
+    INFO("Failed to open socket: %s\n", strerror(errno));
+    return -1;
+  }
+  INFO("Opened IPv4 socket for mDNS/DNS-SD\n");
+  buffer = malloc(capacity);
+  /*
+          INFO("Sending DNS-SD discovery\n");
+          if (mdns_discovery_send(sock)) {
+                  INFO("Failed to send DNS-DS discovery: %s\n",
+     strerror(errno)); goto quit;
+          }
+
+          INFO("Reading DNS-SD replies\n");
+          for (int i = 0; i < 10; ++i) {
+                  records = mdns_discovery_recv(sock, buffer, capacity,
+     callback, user_data); sleep(1);
+          }
+          */
+
+  INFO("Sending mDNS query\n");
+  if (mdns_query_send(sock, MDNS_RECORDTYPE_PTR,
+                      MDNS_STRING_CONST("_hicn._udp.local."), buffer,
+                      capacity)) {
+    INFO("Failed to send mDNS query: %s\n", strerror(errno));
+    goto quit;
+  }
+
+  INFO("Reading mDNS replies\n");
+  for (int i = 0; i < 10; ++i) {
+    records = mdns_query_recv(sock, buffer, capacity, callback, user_data, 1);
+    sleep(1);
+  }
 
 quit:
-	free(buffer);
+  free(buffer);
 
-	mdns_socket_close(sock);
-	INFO("Closed socket\n");
+  mdns_socket_close(sock);
+  INFO("Closed socket\n");
 
 #ifdef _WIN32
-	WSACleanup();
+  WSACleanup();
 #endif
 
-	return 0;
+  return 0;
 }
diff --git a/ctrl/facemgr/src/interfaces/bonjour/mdns/mdns.h b/ctrl/facemgr/src/interfaces/bonjour/mdns/mdns.h
index ff04b5d72..4b8e7a7f4 100644
--- a/ctrl/facemgr/src/interfaces/bonjour/mdns/mdns.h
+++ b/ctrl/facemgr/src/interfaces/bonjour/mdns/mdns.h
@@ -7,7 +7,8 @@
  *
  * https://github.com/mjansson/mdns
  *
- * This library is put in the public domain; you can redistribute it and/or modify it without any restrictions.
+ * This library is put in the public domain; you can redistribute it and/or
+ * modify it without any restrictions.
  *
  */
 
@@ -31,76 +32,73 @@
 
 #define MDNS_INVALID_POS ((size_t)-1)
 
-#define MDNS_STRING_CONST(s) (s), (sizeof((s))-1)
+#define MDNS_STRING_CONST(s) (s), (sizeof((s)) - 1)
 #define MDNS_STRING_FORMAT(s) (int)((s).length), s.str
 
 enum mdns_record_type {
-	MDNS_RECORDTYPE_IGNORE = 0,
-	//Address
-	MDNS_RECORDTYPE_A = 1,
-	//Domain Name pointer
-	MDNS_RECORDTYPE_PTR = 12,
-	//Arbitrary text string
-	MDNS_RECORDTYPE_TXT = 16,
-	//IP6 Address [Thomson]
-	MDNS_RECORDTYPE_AAAA = 28,
-	//Server Selection [RFC2782]
-	MDNS_RECORDTYPE_SRV = 33
+  MDNS_RECORDTYPE_IGNORE = 0,
+  // Address
+  MDNS_RECORDTYPE_A = 1,
+  // Domain Name pointer
+  MDNS_RECORDTYPE_PTR = 12,
+  // Arbitrary text string
+  MDNS_RECORDTYPE_TXT = 16,
+  // IP6 Address [Thomson]
+  MDNS_RECORDTYPE_AAAA = 28,
+  // Server Selection [RFC2782]
+  MDNS_RECORDTYPE_SRV = 33
 };
 
 enum mdns_entry_type {
-	MDNS_ENTRYTYPE_ANSWER = 1,
-	MDNS_ENTRYTYPE_AUTHORITY = 2,
-	MDNS_ENTRYTYPE_ADDITIONAL = 3
+  MDNS_ENTRYTYPE_ANSWER = 1,
+  MDNS_ENTRYTYPE_AUTHORITY = 2,
+  MDNS_ENTRYTYPE_ADDITIONAL = 3
 };
 
-enum mdns_class {
-	MDNS_CLASS_IN = 1
-};
+enum mdns_class { MDNS_CLASS_IN = 1 };
 
-typedef enum mdns_record_type  mdns_record_type_t;
-typedef enum mdns_entry_type   mdns_entry_type_t;
-typedef enum mdns_class        mdns_class_t;
+typedef enum mdns_record_type mdns_record_type_t;
+typedef enum mdns_entry_type mdns_entry_type_t;
+typedef enum mdns_class mdns_class_t;
 
-typedef int (* mdns_record_callback_fn)(const struct sockaddr* from,
-                                        mdns_entry_type_t entry, uint16_t type,
-                                        uint16_t rclass, uint32_t ttl,
-                                        const void* data, size_t size, size_t offset, size_t length,
-                                        void* user_data);
+typedef int (*mdns_record_callback_fn)(const struct sockaddr* from,
+                                       mdns_entry_type_t entry, uint16_t type,
+                                       uint16_t rclass, uint32_t ttl,
+                                       const void* data, size_t size,
+                                       size_t offset, size_t length,
+                                       void* user_data);
 
-typedef struct mdns_string_t       mdns_string_t;
-typedef struct mdns_string_pair_t  mdns_string_pair_t;
-typedef struct mdns_record_srv_t   mdns_record_srv_t;
-typedef struct mdns_record_txt_t   mdns_record_txt_t;
+typedef struct mdns_string_t mdns_string_t;
+typedef struct mdns_string_pair_t mdns_string_pair_t;
+typedef struct mdns_record_srv_t mdns_record_srv_t;
+typedef struct mdns_record_txt_t mdns_record_txt_t;
 
 struct mdns_string_t {
-	const char* str;
-	size_t length;
+  const char* str;
+  size_t length;
 };
 
 struct mdns_string_pair_t {
-	size_t  offset;
-	size_t  length;
-	int     ref;
+  size_t offset;
+  size_t length;
+  int ref;
 };
 
 struct mdns_record_srv_t {
-	uint16_t priority;
-	uint16_t weight;
-	uint16_t port;
-	mdns_string_t name;
+  uint16_t priority;
+  uint16_t weight;
+  uint16_t port;
+  mdns_string_t name;
 };
 
 struct mdns_record_txt_t {
-	mdns_string_t key;
-	mdns_string_t value;
+  mdns_string_t key;
+  mdns_string_t value;
 };
 
-static int
-mdns_socket_open_ipv4(void);
+static int mdns_socket_open_ipv4(void);
 
-static int
-mdns_socket_setup_ipv4(int sock);
+static int mdns_socket_setup_ipv4(int sock);
 
 #if 0
 static int
@@ -112,8 +110,7 @@ static int
 mdns_socket_setup_ipv6(int sock);
 #endif
 
-static void
-mdns_socket_close(int sock);
+static void mdns_socket_close(int sock);
 
 #if 0
 static int
@@ -125,21 +122,18 @@ mdns_discovery_recv(int sock, void* buffer, size_t capacity,
                     mdns_record_callback_fn callback, void* user_data);
 #endif
 
-static int
-mdns_query_send(int sock, mdns_record_type_t type, const char* name, size_t length,
-                void* buffer, size_t capacity);
+static int mdns_query_send(int sock, mdns_record_type_t type, const char* name,
+                           size_t length, void* buffer, size_t capacity);
 
-static size_t
-mdns_query_recv(int sock, void* buffer, size_t capacity,
-                mdns_record_callback_fn callback, void* user_data,
-                uint8_t one_shot);
+static size_t mdns_query_recv(int sock, void* buffer, size_t capacity,
+                              mdns_record_callback_fn callback, void* user_data,
+                              uint8_t one_shot);
 
-static mdns_string_t
-mdns_string_extract(const void* buffer, size_t size, size_t* offset,
-                    char* str, size_t capacity);
+static mdns_string_t mdns_string_extract(const void* buffer, size_t size,
+                                         size_t* offset, char* str,
+                                         size_t capacity);
 
-static int
-mdns_string_skip(const void* buffer, size_t size, size_t* offset);
+static int mdns_string_skip(const void* buffer, size_t size, size_t* offset);
 
 #if 0
 static int
@@ -147,78 +141,80 @@ mdns_string_equal(const void* buffer_lhs, size_t size_lhs, size_t* ofs_lhs,
                   const void* buffer_rhs, size_t size_rhs, size_t* ofs_rhs);
 #endif
 
-static void*
-mdns_string_make(void* data, size_t capacity, const char* name, size_t length);
+static void* mdns_string_make(void* data, size_t capacity, const char* name,
+                              size_t length);
 
-static mdns_string_t
-mdns_record_parse_ptr(const void* buffer, size_t size, size_t offset, size_t length,
-                      char* strbuffer, size_t capacity);
+static mdns_string_t mdns_record_parse_ptr(const void* buffer, size_t size,
+                                           size_t offset, size_t length,
+                                           char* strbuffer, size_t capacity);
 
-static mdns_record_srv_t
-mdns_record_parse_srv(const void* buffer, size_t size, size_t offset, size_t length,
-                      char* strbuffer, size_t capacity);
+static mdns_record_srv_t mdns_record_parse_srv(const void* buffer, size_t size,
+                                               size_t offset, size_t length,
+                                               char* strbuffer,
+                                               size_t capacity);
 
-static struct sockaddr_in*
-mdns_record_parse_a(const void* buffer, size_t size, size_t offset, size_t length,
-                    struct sockaddr_in* addr);
+static struct sockaddr_in* mdns_record_parse_a(const void* buffer, size_t size,
+                                               size_t offset, size_t length,
+                                               struct sockaddr_in* addr);
 
-static struct sockaddr_in6*
-mdns_record_parse_aaaa(const void* buffer, size_t size, size_t offset, size_t length,
-                       struct sockaddr_in6* addr);
+static struct sockaddr_in6* mdns_record_parse_aaaa(const void* buffer,
+                                                   size_t size, size_t offset,
+                                                   size_t length,
+                                                   struct sockaddr_in6* addr);
 
-static size_t
-mdns_record_parse_txt(const void* buffer, size_t size, size_t offset, size_t length,
-                      mdns_record_txt_t* records, size_t capacity);
+static size_t mdns_record_parse_txt(const void* buffer, size_t size,
+                                    size_t offset, size_t length,
+                                    mdns_record_txt_t* records,
+                                    size_t capacity);
 
 // Implementations
 
-static int
-mdns_socket_open_ipv4(void) {
-	int sock = (int)socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-	if (sock < 0)
-		return -1;
-	if (mdns_socket_setup_ipv4(sock)) {
-		mdns_socket_close(sock);
-		return -1;
-	}
-	return sock;
+static int mdns_socket_open_ipv4(void) {
+  int sock = (int)socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+  if (sock < 0) return -1;
+  if (mdns_socket_setup_ipv4(sock)) {
+    mdns_socket_close(sock);
+    return -1;
+  }
+  return sock;
 }
 
-static int
-mdns_socket_setup_ipv4(int sock) {
-	struct sockaddr_in saddr;
-	memset(&saddr, 0, sizeof(saddr));
-	saddr.sin_family = AF_INET;
-	saddr.sin_addr.s_addr = INADDR_ANY;
+static int mdns_socket_setup_ipv4(int sock) {
+  struct sockaddr_in saddr;
+  memset(&saddr, 0, sizeof(saddr));
+  saddr.sin_family = AF_INET;
+  saddr.sin_addr.s_addr = INADDR_ANY;
 #ifdef __APPLE__
-	saddr.sin_len = sizeof(saddr);
+  saddr.sin_len = sizeof(saddr);
 #endif
 
-	if (bind(sock, (struct sockaddr*)&saddr, sizeof(saddr)))
-		return -1;
+  if (bind(sock, (struct sockaddr*)&saddr, sizeof(saddr))) return -1;
 
 #ifdef _WIN32
-	unsigned long param = 1;
-	ioctlsocket(sock, FIONBIO, &param);
+  unsigned long param = 1;
+  ioctlsocket(sock, FIONBIO, &param);
 #else
-	const int flags = fcntl(sock, F_GETFL, 0);
-	fcntl(sock, F_SETFL, flags | O_NONBLOCK);
+  const int flags = fcntl(sock, F_GETFL, 0);
+  fcntl(sock, F_SETFL, flags | O_NONBLOCK);
 #endif
 
-	unsigned char ttl = 1;
-	unsigned char loopback = 1;
-	struct ip_mreq req;
+  unsigned char ttl = 1;
+  unsigned char loopback = 1;
+  struct ip_mreq req;
 
-	setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL, (const char*)&ttl, sizeof(ttl));
-	setsockopt(sock, IPPROTO_IP, IP_MULTICAST_LOOP, (const char*)&loopback, sizeof(loopback));
+  setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL, (const char*)&ttl,
+             sizeof(ttl));
+  setsockopt(sock, IPPROTO_IP, IP_MULTICAST_LOOP, (const char*)&loopback,
+             sizeof(loopback));
 
-	memset(&req, 0, sizeof(req));
-	req.imr_multiaddr.s_addr = htonl((((uint32_t)224U) << 24U) | ((uint32_t)251U));
-	req.imr_interface.s_addr = INADDR_ANY;
-	if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&req, sizeof(req)))
-		return -1;
+  memset(&req, 0, sizeof(req));
+  req.imr_multiaddr.s_addr =
+      htonl((((uint32_t)224U) << 24U) | ((uint32_t)251U));
+  req.imr_interface.s_addr = INADDR_ANY;
+  if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&req, sizeof(req)))
+    return -1;
 
-	return 0;
+  return 0;
 }
 
 #if 0
@@ -274,67 +270,58 @@ mdns_socket_setup_ipv6(int sock) {
 }
 #endif
 
-static void
-mdns_socket_close(int sock) {
+static void mdns_socket_close(int sock) {
 #ifdef _WIN32
-	closesocket(sock);
+  closesocket(sock);
 #else
-	close(sock);
+  close(sock);
 #endif
 }
 
-static int
-mdns_is_string_ref(uint8_t val) {
-	return (0xC0 == (val & 0xC0));
-}
+static int mdns_is_string_ref(uint8_t val) { return (0xC0 == (val & 0xC0)); }
 
-static mdns_string_pair_t
-mdns_get_next_substring(const void* rawdata, size_t size, size_t offset) {
-	const uint8_t* buffer = rawdata;
-	mdns_string_pair_t pair = {MDNS_INVALID_POS, 0, 0};
-	if (!buffer[offset]) {
-		pair.offset = offset;
-		return pair;
-	}
-	if (mdns_is_string_ref(buffer[offset])) {
-		if (size < offset + 2)
-			return pair;
+static mdns_string_pair_t mdns_get_next_substring(const void* rawdata,
+                                                  size_t size, size_t offset) {
+  const uint8_t* buffer = rawdata;
+  mdns_string_pair_t pair = {MDNS_INVALID_POS, 0, 0};
+  if (!buffer[offset]) {
+    pair.offset = offset;
+    return pair;
+  }
+  if (mdns_is_string_ref(buffer[offset])) {
+    if (size < offset + 2) return pair;
 
-		offset = (((size_t)(0x3f & buffer[offset]) << 8) | (size_t)buffer[offset + 1]);
-		if (offset >= size)
-			return pair;
+    offset =
+        (((size_t)(0x3f & buffer[offset]) << 8) | (size_t)buffer[offset + 1]);
+    if (offset >= size) return pair;
 
-		pair.ref = 1;
-	}
+    pair.ref = 1;
+  }
 
-	size_t length = (size_t)buffer[offset++];
-	if (size < offset + length)
-		return pair;
+  size_t length = (size_t)buffer[offset++];
+  if (size < offset + length) return pair;
 
-	pair.offset = offset;
-	pair.length = length;
+  pair.offset = offset;
+  pair.length = length;
 
-	return pair;
+  return pair;
 }
 
-static int
-mdns_string_skip(const void* buffer, size_t size, size_t* offset) {
-	size_t cur = *offset;
-	mdns_string_pair_t substr;
-	do {
-		substr = mdns_get_next_substring(buffer, size, cur);
-		if (substr.offset == MDNS_INVALID_POS)
-			return 0;
-		if (substr.ref) {
-			*offset = cur + 2;
-			return 1;
-		}
-		cur = substr.offset + substr.length;
-	}
-	while (substr.length);
-
-	*offset = cur + 1;
-	return 1;
+static int mdns_string_skip(const void* buffer, size_t size, size_t* offset) {
+  size_t cur = *offset;
+  mdns_string_pair_t substr;
+  do {
+    substr = mdns_get_next_substring(buffer, size, cur);
+    if (substr.offset == MDNS_INVALID_POS) return 0;
+    if (substr.ref) {
+      *offset = cur + 2;
+      return 1;
+    }
+    cur = substr.offset + substr.length;
+  } while (substr.length);
+
+  *offset = cur + 1;
+  return 1;
 }
 
 #if 0
@@ -378,142 +365,133 @@ mdns_string_equal(const void* buffer_lhs, size_t size_lhs, size_t* ofs_lhs,
 }
 #endif
 
-static mdns_string_t
-mdns_string_extract(const void* buffer, size_t size, size_t* offset,
-                    char* str, size_t capacity) {
-	size_t cur = *offset;
-	size_t end = MDNS_INVALID_POS;
-	mdns_string_pair_t substr;
-	mdns_string_t result = {str, 0};
-	char* dst = str;
-	size_t remain = capacity;
-	do {
-		substr = mdns_get_next_substring(buffer, size, cur);
-		if (substr.offset == MDNS_INVALID_POS)
-			return result;
-		if (substr.ref && (end == MDNS_INVALID_POS))
-			end = cur + 2;
-		if (substr.length) {
-			size_t to_copy = (substr.length < remain) ? substr.length : remain;
-			memcpy(dst, (const char*)buffer + substr.offset, to_copy);
-			dst += to_copy;
-			remain -= to_copy;
-			if (remain) {
-				*dst++ = '.';
-				--remain;
-			}
-		}
-		cur = substr.offset + substr.length;
-	}
-	while (substr.length);
-
-	if (end == MDNS_INVALID_POS)
-		end = cur + 1;
-	*offset = end;
-
-	result.length = capacity - remain;
-	return result;
+static mdns_string_t mdns_string_extract(const void* buffer, size_t size,
+                                         size_t* offset, char* str,
+                                         size_t capacity) {
+  size_t cur = *offset;
+  size_t end = MDNS_INVALID_POS;
+  mdns_string_pair_t substr;
+  mdns_string_t result = {str, 0};
+  char* dst = str;
+  size_t remain = capacity;
+  do {
+    substr = mdns_get_next_substring(buffer, size, cur);
+    if (substr.offset == MDNS_INVALID_POS) return result;
+    if (substr.ref && (end == MDNS_INVALID_POS)) end = cur + 2;
+    if (substr.length) {
+      size_t to_copy = (substr.length < remain) ? substr.length : remain;
+      memcpy(dst, (const char*)buffer + substr.offset, to_copy);
+      dst += to_copy;
+      remain -= to_copy;
+      if (remain) {
+        *dst++ = '.';
+        --remain;
+      }
+    }
+    cur = substr.offset + substr.length;
+  } while (substr.length);
+
+  if (end == MDNS_INVALID_POS) end = cur + 1;
+  *offset = end;
+
+  result.length = capacity - remain;
+  return result;
 }
 
-static size_t
-mdns_string_find(const char* str, size_t length, char c, size_t offset) {
-	const void* found;
-	if (offset >= length)
-		return MDNS_INVALID_POS;
-	found = memchr(str + offset, c, length - offset);
-	if (found)
-		return (size_t)((const char*)found - str);
-	return MDNS_INVALID_POS;
+static size_t mdns_string_find(const char* str, size_t length, char c,
+                               size_t offset) {
+  const void* found;
+  if (offset >= length) return MDNS_INVALID_POS;
+  found = memchr(str + offset, c, length - offset);
+  if (found) return (size_t)((const char*)found - str);
+  return MDNS_INVALID_POS;
 }
 
-static void*
-mdns_string_make(void* data, size_t capacity, const char* name, size_t length) {
-	size_t pos = 0;
-	size_t last_pos = 0;
-	size_t remain = capacity;
-	unsigned char* dest = data;	
-	while ((last_pos < length) && ((pos = mdns_string_find(name, length, '.', last_pos)) != MDNS_INVALID_POS)) {
-		size_t sublength = pos - last_pos;
-		if (sublength < remain) {
-			*dest = (unsigned char)sublength;
-			memcpy(dest + 1, name + last_pos, sublength);
-			dest += sublength + 1;
-			remain -= sublength + 1;
-		}
-		else {
-			return 0;
-		}
-		last_pos = pos + 1;
-	}
-	if (last_pos < length) {
-		size_t sublength = length - last_pos;
-		if (sublength < capacity) {
-			*dest = (unsigned char)sublength;
-			memcpy(dest + 1, name + last_pos, sublength);
-			dest += sublength + 1;
-			remain -= sublength + 1;
-		}
-		else {
-			return 0;
-		}
-	}
-	if (!remain)
-		return 0;
-	*dest++ = 0;
-	return dest;
+static void* mdns_string_make(void* data, size_t capacity, const char* name,
+                              size_t length) {
+  size_t pos = 0;
+  size_t last_pos = 0;
+  size_t remain = capacity;
+  unsigned char* dest = data;
+  while ((last_pos < length) &&
+         ((pos = mdns_string_find(name, length, '.', last_pos)) !=
+          MDNS_INVALID_POS)) {
+    size_t sublength = pos - last_pos;
+    if (sublength < remain) {
+      *dest = (unsigned char)sublength;
+      memcpy(dest + 1, name + last_pos, sublength);
+      dest += sublength + 1;
+      remain -= sublength + 1;
+    } else {
+      return 0;
+    }
+    last_pos = pos + 1;
+  }
+  if (last_pos < length) {
+    size_t sublength = length - last_pos;
+    if (sublength < capacity) {
+      *dest = (unsigned char)sublength;
+      memcpy(dest + 1, name + last_pos, sublength);
+      dest += sublength + 1;
+      remain -= sublength + 1;
+    } else {
+      return 0;
+    }
+  }
+  if (!remain) return 0;
+  *dest++ = 0;
+  return dest;
 }
 
-static size_t
-mdns_records_parse(const struct sockaddr* from, const void* buffer, size_t size, size_t* offset,
-                   mdns_entry_type_t type, size_t records, mdns_record_callback_fn callback,
-                   void* user_data) {
-	size_t parsed = 0;
-	int do_callback = 1;
-	for (size_t i = 0; i < records; ++i) {
-		mdns_string_skip(buffer, size, offset);
-		const uint16_t* data = (const uint16_t*)((const char*)buffer + (*offset));
-
-		uint16_t rtype = ntohs(*data++);
-		uint16_t rclass = ntohs(*data++);
-		uint32_t ttl = ntohs(*(const uint32_t*)(const void*)data); data += 2;
-		uint16_t length = ntohs(*data++);
-
-		*offset += 10;
-
-		if (do_callback) {
-			++parsed;
-			if (callback(from, type, rtype, rclass, ttl, buffer, size, *offset, length,
-			             user_data))
-				do_callback = 0;
-		}
-
-		*offset += length;
-	}
-	return parsed;
+static size_t mdns_records_parse(const struct sockaddr* from,
+                                 const void* buffer, size_t size,
+                                 size_t* offset, mdns_entry_type_t type,
+                                 size_t records,
+                                 mdns_record_callback_fn callback,
+                                 void* user_data) {
+  size_t parsed = 0;
+  int do_callback = 1;
+  for (size_t i = 0; i < records; ++i) {
+    mdns_string_skip(buffer, size, offset);
+    const uint16_t* data = (const uint16_t*)((const char*)buffer + (*offset));
+
+    uint16_t rtype = ntohs(*data++);
+    uint16_t rclass = ntohs(*data++);
+    uint32_t ttl = ntohs(*(const uint32_t*)(const void*)data);
+    data += 2;
+    uint16_t length = ntohs(*data++);
+
+    *offset += 10;
+
+    if (do_callback) {
+      ++parsed;
+      if (callback(from, type, rtype, rclass, ttl, buffer, size, *offset,
+                   length, user_data))
+        do_callback = 0;
+    }
+
+    *offset += length;
+  }
+  return parsed;
 }
 
 static const uint8_t mdns_services_query[] = {
-	// Transaction ID
-	0x00, 0x00,
-	// Flags
-	0x00, 0x00,
-	// 1 question
-	0x00, 0x01,
-	// No answer, authority or additional RRs
-	0x00, 0x00,
-	0x00, 0x00,
-	0x00, 0x00,
-	// _services._dns-sd._udp.local.
-	0x09, '_', 's', 'e', 'r', 'v', 'i', 'c', 'e', 's',
-	0x07, '_', 'd', 'n', 's', '-', 's', 'd',
-	0x04, '_', 'u', 'd', 'p',
-	0x05, 'l', 'o', 'c', 'a', 'l',
-	0x00,
-	// PTR record
-	0x00, MDNS_RECORDTYPE_PTR,
-	// QU (unicast response) and class IN
-	0x80, MDNS_CLASS_IN
-};
+    // Transaction ID
+    0x00, 0x00,
+    // Flags
+    0x00, 0x00,
+    // 1 question
+    0x00, 0x01,
+    // No answer, authority or additional RRs
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    // _services._dns-sd._udp.local.
+    0x09, '_', 's', 'e', 'r', 'v', 'i', 'c', 'e', 's', 0x07, '_', 'd', 'n', 's',
+    '-', 's', 'd', 0x04, '_', 'u', 'd', 'p', 0x05, 'l', 'o', 'c', 'a', 'l',
+    0x00,
+    // PTR record
+    0x00, MDNS_RECORDTYPE_PTR,
+    // QU (unicast response) and class IN
+    0x80, MDNS_CLASS_IN};
 
 #if 0
 static int
@@ -645,233 +623,223 @@ mdns_discovery_recv(int sock, void* buffer, size_t capacity,
 
 static uint16_t mdns_transaction_id = 0;
 
-static int
-mdns_query_send(int sock, mdns_record_type_t type, const char* name, size_t length,
-                void* buffer, size_t capacity) {
-	if (capacity < (17 + length))
-		return -1;
-
-	uint16_t* data = buffer;
-	//Transaction ID
-	*data++ = htons(++mdns_transaction_id);
-	//Flags
-	*data++ = 0;
-	//Questions
-	*data++ = htons(1);
-	//No answer, authority or additional RRs
-	*data++ = 0;
-	*data++ = 0;
-	*data++ = 0;
-	//Name string
-	data = mdns_string_make(data, capacity - 17, name, length);
-	if (!data)
-		return -1;
-	//Record type
-	*data++ = htons(type);
-	//! Unicast response, class IN
-	*data++ = htons(0x8000U | MDNS_CLASS_IN);
-
-	struct sockaddr_storage addr_storage;
-	struct sockaddr_in addr;
-	struct sockaddr_in6 addr6;
-	struct sockaddr* saddr = (struct sockaddr*)&addr_storage;
-	socklen_t saddrlen = sizeof(struct sockaddr_storage);
-	if (getsockname(sock, saddr, &saddrlen))
-		return -1;
-	if (saddr->sa_family == AF_INET6) {
-		memset(&addr6, 0, sizeof(struct sockaddr_in6));
-		addr6.sin6_family = AF_INET6;
+static int mdns_query_send(int sock, mdns_record_type_t type, const char* name,
+                           size_t length, void* buffer, size_t capacity) {
+  if (capacity < (17 + length)) return -1;
+
+  uint16_t* data = buffer;
+  // Transaction ID
+  *data++ = htons(++mdns_transaction_id);
+  // Flags
+  *data++ = 0;
+  // Questions
+  *data++ = htons(1);
+  // No answer, authority or additional RRs
+  *data++ = 0;
+  *data++ = 0;
+  *data++ = 0;
+  // Name string
+  data = mdns_string_make(data, capacity - 17, name, length);
+  if (!data) return -1;
+  // Record type
+  *data++ = htons(type);
+  //! Unicast response, class IN
+  *data++ = htons(0x8000U | MDNS_CLASS_IN);
+
+  struct sockaddr_storage addr_storage;
+  struct sockaddr_in addr;
+  struct sockaddr_in6 addr6;
+  struct sockaddr* saddr = (struct sockaddr*)&addr_storage;
+  socklen_t saddrlen = sizeof(struct sockaddr_storage);
+  if (getsockname(sock, saddr, &saddrlen)) return -1;
+  if (saddr->sa_family == AF_INET6) {
+    memset(&addr6, 0, sizeof(struct sockaddr_in6));
+    addr6.sin6_family = AF_INET6;
 #ifdef __APPLE__
-		addr6.sin6_len = sizeof(struct sockaddr_in6);
+    addr6.sin6_len = sizeof(struct sockaddr_in6);
 #endif
-		addr6.sin6_addr.s6_addr[0] = 0xFF;
-		addr6.sin6_addr.s6_addr[1] = 0x02;
-		addr6.sin6_addr.s6_addr[15] = 0xFB;
-		addr6.sin6_port = htons((unsigned short)5353);
-		saddr = (struct sockaddr*)&addr6;
-		saddrlen = sizeof(struct sockaddr_in6);
-	}
-	else {
-		memset(&addr, 0, sizeof(struct sockaddr_in));
-		addr.sin_family = AF_INET;
+    addr6.sin6_addr.s6_addr[0] = 0xFF;
+    addr6.sin6_addr.s6_addr[1] = 0x02;
+    addr6.sin6_addr.s6_addr[15] = 0xFB;
+    addr6.sin6_port = htons((unsigned short)5353);
+    saddr = (struct sockaddr*)&addr6;
+    saddrlen = sizeof(struct sockaddr_in6);
+  } else {
+    memset(&addr, 0, sizeof(struct sockaddr_in));
+    addr.sin_family = AF_INET;
 #ifdef __APPLE__
-		addr.sin_len = sizeof(struct sockaddr_in);
+    addr.sin_len = sizeof(struct sockaddr_in);
 #endif
-		addr.sin_addr.s_addr = htonl((((uint32_t)224U) << 24U) | ((uint32_t)251U));
-		addr.sin_port = htons((unsigned short)5353);
-		saddr = (struct sockaddr*)&addr;
-		saddrlen = sizeof(struct sockaddr_in);
-	}
-
-	if (sendto(sock, buffer, (char*)data - (char*)buffer, 0,
-	           saddr, saddrlen) < 0)
-		return -1;
-	return 0;
+    addr.sin_addr.s_addr = htonl((((uint32_t)224U) << 24U) | ((uint32_t)251U));
+    addr.sin_port = htons((unsigned short)5353);
+    saddr = (struct sockaddr*)&addr;
+    saddrlen = sizeof(struct sockaddr_in);
+  }
+
+  if (sendto(sock, buffer, (char*)data - (char*)buffer, 0, saddr, saddrlen) < 0)
+    return -1;
+  return 0;
 }
 
-static size_t
-mdns_query_recv(int sock, void* buffer, size_t capacity,
-                mdns_record_callback_fn callback, void* user_data,
-                uint8_t one_shot) {
-	struct sockaddr_in6 addr;
-	struct sockaddr* saddr = (struct sockaddr*)&addr;
-	memset(&addr, 0, sizeof(addr));
-	saddr->sa_family = AF_INET;
+static size_t mdns_query_recv(int sock, void* buffer, size_t capacity,
+                              mdns_record_callback_fn callback, void* user_data,
+                              uint8_t one_shot) {
+  struct sockaddr_in6 addr;
+  struct sockaddr* saddr = (struct sockaddr*)&addr;
+  memset(&addr, 0, sizeof(addr));
+  saddr->sa_family = AF_INET;
 #ifdef __APPLE__
-	saddr->sa_len = sizeof(addr);
+  saddr->sa_len = sizeof(addr);
 #endif
-	socklen_t addrlen = sizeof(addr);
-	int ret = recvfrom(sock, buffer, capacity, 0,
-	                   saddr, &addrlen);
-	if (ret <= 0)
-		return 0;
-
-	size_t data_size = (size_t)ret;
-	uint16_t* data = (uint16_t*)buffer;
-
-	uint16_t transaction_id = ntohs(*data++);
-	++data;// uint16_t flags = ntohs(*data++);
-	uint16_t questions      = ntohs(*data++);
-	uint16_t answer_rrs     = ntohs(*data++);
-	uint16_t authority_rrs  = ntohs(*data++);
-	uint16_t additional_rrs = ntohs(*data++);
-
-	if (one_shot && transaction_id != mdns_transaction_id)// || (flags != 0x8400))
-		return 0; //Not a reply to our last question
-
-	if (questions > 1)
-		return 0;
-
-	//Skip questions part
-	int i;
-	for (i = 0; i < questions; ++i) {
-		size_t ofs = (size_t)((char*)data - (char*)buffer);
-		if (!mdns_string_skip(buffer, data_size, &ofs))
-			return 0;
-		data = (void*)((char*)buffer + ofs);
-		++data;
-		++data;
-	}
-
-	size_t records = 0;
-	size_t offset = (size_t)((char*)data - (char*)buffer);
-	records += mdns_records_parse(saddr, buffer, data_size, &offset,
-	                              MDNS_ENTRYTYPE_ANSWER, answer_rrs, 
-	                              callback, user_data);
-	records += mdns_records_parse(saddr, buffer, data_size, &offset,
-	                              MDNS_ENTRYTYPE_AUTHORITY, authority_rrs, 
-	                              callback, user_data);
-	records += mdns_records_parse(saddr, buffer, data_size, &offset,
-	                              MDNS_ENTRYTYPE_ADDITIONAL, additional_rrs, 
-	                              callback, user_data);
-	return records;
+  socklen_t addrlen = sizeof(addr);
+  int ret = recvfrom(sock, buffer, capacity, 0, saddr, &addrlen);
+  if (ret <= 0) return 0;
+
+  size_t data_size = (size_t)ret;
+  uint16_t* data = (uint16_t*)buffer;
+
+  uint16_t transaction_id = ntohs(*data++);
+  ++data;  // uint16_t flags = ntohs(*data++);
+  uint16_t questions = ntohs(*data++);
+  uint16_t answer_rrs = ntohs(*data++);
+  uint16_t authority_rrs = ntohs(*data++);
+  uint16_t additional_rrs = ntohs(*data++);
+
+  if (one_shot &&
+      transaction_id != mdns_transaction_id)  // || (flags != 0x8400))
+    return 0;  // Not a reply to our last question
+
+  if (questions > 1) return 0;
+
+  // Skip questions part
+  int i;
+  for (i = 0; i < questions; ++i) {
+    size_t ofs = (size_t)((char*)data - (char*)buffer);
+    if (!mdns_string_skip(buffer, data_size, &ofs)) return 0;
+    data = (void*)((char*)buffer + ofs);
+    ++data;
+    ++data;
+  }
+
+  size_t records = 0;
+  size_t offset = (size_t)((char*)data - (char*)buffer);
+  records += mdns_records_parse(saddr, buffer, data_size, &offset,
+                                MDNS_ENTRYTYPE_ANSWER, answer_rrs, callback,
+                                user_data);
+  records += mdns_records_parse(saddr, buffer, data_size, &offset,
+                                MDNS_ENTRYTYPE_AUTHORITY, authority_rrs,
+                                callback, user_data);
+  records += mdns_records_parse(saddr, buffer, data_size, &offset,
+                                MDNS_ENTRYTYPE_ADDITIONAL, additional_rrs,
+                                callback, user_data);
+  return records;
 }
 
-static mdns_string_t
-mdns_record_parse_ptr(const void* buffer, size_t size, size_t offset, size_t length,
-                      char* strbuffer, size_t capacity) {
-	//PTR record is just a string
-	if ((size >= offset + length) && (length >= 2))
-		return mdns_string_extract(buffer, size, &offset, strbuffer, capacity);
-	mdns_string_t empty = {0, 0};
-	return empty;
+static mdns_string_t mdns_record_parse_ptr(const void* buffer, size_t size,
+                                           size_t offset, size_t length,
+                                           char* strbuffer, size_t capacity) {
+  // PTR record is just a string
+  if ((size >= offset + length) && (length >= 2))
+    return mdns_string_extract(buffer, size, &offset, strbuffer, capacity);
+  mdns_string_t empty = {0, 0};
+  return empty;
 }
 
-static mdns_record_srv_t
-mdns_record_parse_srv(const void* buffer, size_t size, size_t offset, size_t length,
-                      char* strbuffer, size_t capacity) {
-	mdns_record_srv_t srv;
-	memset(&srv, 0, sizeof(mdns_record_srv_t));
-	// Read the priority, weight, port number and the discovery name
-	// SRV record format (http://www.ietf.org/rfc/rfc2782.txt):
-	// 2 bytes network-order unsigned priority
-	// 2 bytes network-order unsigned weight
-	// 2 bytes network-order unsigned port
-	// string: discovery (domain) name, minimum 2 bytes when compressed
-	if ((size >= offset + length) && (length >= 8)) {
-		const uint16_t* recorddata = (const uint16_t*)((const char*)buffer + offset);
-		srv.priority = ntohs(*recorddata++);
-		srv.weight = ntohs(*recorddata++);
-		srv.port = ntohs(*recorddata++);
-		offset += 6;
-		srv.name = mdns_string_extract(buffer, size, &offset, strbuffer, capacity);
-	}
-	return srv;
+static mdns_record_srv_t mdns_record_parse_srv(const void* buffer, size_t size,
+                                               size_t offset, size_t length,
+                                               char* strbuffer,
+                                               size_t capacity) {
+  mdns_record_srv_t srv;
+  memset(&srv, 0, sizeof(mdns_record_srv_t));
+  // Read the priority, weight, port number and the discovery name
+  // SRV record format (http://www.ietf.org/rfc/rfc2782.txt):
+  // 2 bytes network-order unsigned priority
+  // 2 bytes network-order unsigned weight
+  // 2 bytes network-order unsigned port
+  // string: discovery (domain) name, minimum 2 bytes when compressed
+  if ((size >= offset + length) && (length >= 8)) {
+    const uint16_t* recorddata =
+        (const uint16_t*)((const char*)buffer + offset);
+    srv.priority = ntohs(*recorddata++);
+    srv.weight = ntohs(*recorddata++);
+    srv.port = ntohs(*recorddata++);
+    offset += 6;
+    srv.name = mdns_string_extract(buffer, size, &offset, strbuffer, capacity);
+  }
+  return srv;
 }
 
-static struct sockaddr_in*
-mdns_record_parse_a(const void* buffer, size_t size, size_t offset, size_t length,
-                    struct sockaddr_in* addr) {
-	memset(addr, 0, sizeof(struct sockaddr_in));
-	addr->sin_family = AF_INET;
+static struct sockaddr_in* mdns_record_parse_a(const void* buffer, size_t size,
+                                               size_t offset, size_t length,
+                                               struct sockaddr_in* addr) {
+  memset(addr, 0, sizeof(struct sockaddr_in));
+  addr->sin_family = AF_INET;
 #ifdef __APPLE__
-	addr->sin_len = sizeof(struct sockaddr_in);
+  addr->sin_len = sizeof(struct sockaddr_in);
 #endif
-	if ((size >= offset + length) && (length == 4))
-		addr->sin_addr.s_addr = *(const uint32_t*)((const char*)buffer + offset);
-	return addr;
+  if ((size >= offset + length) && (length == 4))
+    addr->sin_addr.s_addr = *(const uint32_t*)((const char*)buffer + offset);
+  return addr;
 }
 
-static struct sockaddr_in6*
-mdns_record_parse_aaaa(const void* buffer, size_t size, size_t offset, size_t length,
-                       struct sockaddr_in6* addr) {
-	memset(addr, 0, sizeof(struct sockaddr_in6));
-	addr->sin6_family = AF_INET6;
+static struct sockaddr_in6* mdns_record_parse_aaaa(const void* buffer,
+                                                   size_t size, size_t offset,
+                                                   size_t length,
+                                                   struct sockaddr_in6* addr) {
+  memset(addr, 0, sizeof(struct sockaddr_in6));
+  addr->sin6_family = AF_INET6;
 #ifdef __APPLE__
-	addr->sin6_len = sizeof(struct sockaddr_in6);
+  addr->sin6_len = sizeof(struct sockaddr_in6);
 #endif
-	if ((size >= offset + length) && (length == 16))
-		addr->sin6_addr = *(const struct in6_addr*)((const char*)buffer + offset);
-	return addr;
+  if ((size >= offset + length) && (length == 16))
+    addr->sin6_addr = *(const struct in6_addr*)((const char*)buffer + offset);
+  return addr;
 }
 
-static size_t
-mdns_record_parse_txt(const void* buffer, size_t size, size_t offset, size_t length,
-                      mdns_record_txt_t* records, size_t capacity) {
-	size_t parsed = 0;
-	const char* strdata;
-	size_t separator, sublength;
-	size_t end = offset + length;
-
-	if (size < end)
-		end = size;
-
-	while ((offset < end) && (parsed < capacity)) {
-		strdata = (const char*)buffer + offset;
-		sublength = *(const unsigned char*)strdata;
-
-		++strdata;
-		offset += sublength + 1;
-
-		separator = 0;
-		for (size_t c = 0; c < sublength; ++c) {
-			//DNS-SD TXT record keys MUST be printable US-ASCII, [0x20, 0x7E]
-			if ((strdata[c] < 0x20) || (strdata[c] > 0x7E))
-				break;
-			if (strdata[c] == '=') {
-				separator = c;
-				break;
-			}
-		}
-
-		if (!separator)
-			continue;
-
-		if (separator < sublength) {
-			records[parsed].key.str = strdata;
-			records[parsed].key.length = separator;
-			records[parsed].value.str = strdata + separator + 1;
-			records[parsed].value.length = sublength - (separator + 1);
-		}
-		else {
-			records[parsed].key.str = strdata;
-			records[parsed].key.length = sublength;
-		}
-
-		++parsed;
-	}
-
-	return parsed;	
+static size_t mdns_record_parse_txt(const void* buffer, size_t size,
+                                    size_t offset, size_t length,
+                                    mdns_record_txt_t* records,
+                                    size_t capacity) {
+  size_t parsed = 0;
+  const char* strdata;
+  size_t separator, sublength;
+  size_t end = offset + length;
+
+  if (size < end) end = size;
+
+  while ((offset < end) && (parsed < capacity)) {
+    strdata = (const char*)buffer + offset;
+    sublength = *(const unsigned char*)strdata;
+
+    ++strdata;
+    offset += sublength + 1;
+
+    separator = 0;
+    for (size_t c = 0; c < sublength; ++c) {
+      // DNS-SD TXT record keys MUST be printable US-ASCII, [0x20, 0x7E]
+      if ((strdata[c] < 0x20) || (strdata[c] > 0x7E)) break;
+      if (strdata[c] == '=') {
+        separator = c;
+        break;
+      }
+    }
+
+    if (!separator) continue;
+
+    if (separator < sublength) {
+      records[parsed].key.str = strdata;
+      records[parsed].key.length = separator;
+      records[parsed].value.str = strdata + separator + 1;
+      records[parsed].value.length = sublength - (separator + 1);
+    } else {
+      records[parsed].key.str = strdata;
+      records[parsed].key.length = sublength;
+    }
+
+    ++parsed;
+  }
+
+  return parsed;
 }
 
 #ifdef _WIN32
diff --git a/ctrl/facemgr/src/interfaces/dummy/CMakeLists.txt b/ctrl/facemgr/src/interfaces/dummy/CMakeLists.txt
index 05276bc5a..c68c39273 100644
--- a/ctrl/facemgr/src/interfaces/dummy/CMakeLists.txt
+++ b/ctrl/facemgr/src/interfaces/dummy/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/ctrl/facemgr/src/interfaces/dummy/dummy.c b/ctrl/facemgr/src/interfaces/dummy/dummy.c
index 69c336e57..df63eef17 100644
--- a/ctrl/facemgr/src/interfaces/dummy/dummy.c
+++ b/ctrl/facemgr/src/interfaces/dummy/dummy.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -19,7 +19,7 @@
  */
 
 #include <stdlib.h>
-#include <unistd.h> // close
+#include <unistd.h>  // close
 
 #include <hicn/facemgr.h>
 
@@ -36,34 +36,32 @@
  * Internal data
  */
 typedef struct {
-    /* The configuration data will likely be allocated on the stack (or should
-     * be freed) by the caller, we recommend to make a copy of this data.
-     * This copy can further be altered with default values.
-     */
-    dummy_cfg_t cfg;
+  /* The configuration data will likely be allocated on the stack (or should
+   * be freed) by the caller, we recommend to make a copy of this data.
+   * This copy can further be altered with default values.
+   */
+  dummy_cfg_t cfg;
 
-    /* ... */
+  /* ... */
 
-    int fd; /* Sample internal data: file descriptor */
+  int fd; /* Sample internal data: file descriptor */
 } dummy_data_t;
 
-int dummy_initialize(interface_t * interface, void * cfg)
-{
-    dummy_data_t * data = malloc(sizeof(dummy_data_t));
-    if (!data)
-        goto ERR_MALLOC;
-    interface->data = data;
-
-    /* Use default values for unspecified configuration parameters */
-    if (cfg) {
-        data->cfg = *(dummy_cfg_t *)cfg;
-    } else {
-        memset(&data->cfg, 0, sizeof(data->cfg));
-    }
+int dummy_initialize(interface_t *interface, void *cfg) {
+  dummy_data_t *data = malloc(sizeof(dummy_data_t));
+  if (!data) goto ERR_MALLOC;
+  interface->data = data;
+
+  /* Use default values for unspecified configuration parameters */
+  if (cfg) {
+    data->cfg = *(dummy_cfg_t *)cfg;
+  } else {
+    memset(&data->cfg, 0, sizeof(data->cfg));
+  }
 
-    /* ... */
+  /* ... */
 
-    data->fd = 0;
+  data->fd = 0;
 #if 0
     if (interface_register_fd(interface, data->fd, NULL) < 0) {
         ERROR("[dummy_initialize] Error registering fd");
@@ -71,49 +69,45 @@ int dummy_initialize(interface_t * interface, void * cfg)
     }
 #endif
 
-    /* ... */
+  /* ... */
 
-    /*
-     * We should return a negative value in case of error, and a positive value
-     * otherwise:
-     *  - a file descriptor (>0) will be added to the event loop; or
-     *  - 0 if we don't use any file descriptor
-     */
-    return 0;
+  /*
+   * We should return a negative value in case of error, and a positive value
+   * otherwise:
+   *  - a file descriptor (>0) will be added to the event loop; or
+   *  - 0 if we don't use any file descriptor
+   */
+  return 0;
 
 ERR_FD:
 ERR_MALLOC:
-    return -1;
+  return -1;
 }
 
-int dummy_finalize(interface_t * interface)
-{
-    dummy_data_t * data = (dummy_data_t*)interface->data;
+int dummy_finalize(interface_t *interface) {
+  dummy_data_t *data = (dummy_data_t *)interface->data;
 
-    if (data->fd > 0)
-        close(data->fd);
+  if (data->fd > 0) close(data->fd);
 
-    return 0;
+  return 0;
 }
 
-int dummy_callback(interface_t * interface)
-{
-    dummy_data_t * data = (dummy_data_t*)interface->data;
-    UNUSED(data);
+int dummy_callback(interface_t *interface) {
+  dummy_data_t *data = (dummy_data_t *)interface->data;
+  UNUSED(data);
 
-    /* ... */
+  /* ... */
 
-    return 0;
+  return 0;
 }
 
-int dummy_on_event(interface_t * interface, facelet_t * facelet)
-{
-    dummy_data_t * data = (dummy_data_t*)interface->data;
-    UNUSED(data);
+int dummy_on_event(interface_t *interface, facelet_t *facelet) {
+  dummy_data_t *data = (dummy_data_t *)interface->data;
+  UNUSED(data);
 
-    /* ... */
+  /* ... */
 
-    return 0;
+  return 0;
 }
 
 interface_ops_t dummy_ops = {
diff --git a/ctrl/facemgr/src/interfaces/dummy/dummy.h b/ctrl/facemgr/src/interfaces/dummy/dummy.h
index 22fe5d1a6..f930ead58 100644
--- a/ctrl/facemgr/src/interfaces/dummy/dummy.h
+++ b/ctrl/facemgr/src/interfaces/dummy/dummy.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -28,7 +28,7 @@
  * Configuration data
  */
 typedef struct {
-    /* ... */
+  /* ... */
 } dummy_cfg_t;
 
 #endif /* FACEMGR_INTERFACE_DUMMY_H */
diff --git a/ctrl/facemgr/src/interfaces/hicn_light/CMakeLists.txt b/ctrl/facemgr/src/interfaces/hicn_light/CMakeLists.txt
index ef839a69c..a0fb3e351 100644
--- a/ctrl/facemgr/src/interfaces/hicn_light/CMakeLists.txt
+++ b/ctrl/facemgr/src/interfaces/hicn_light/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,20 +11,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
+##############################################################
+# Sources
+##############################################################
 list(APPEND HEADER_FILES
 )
 
 list(APPEND SOURCE_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_light.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_light.c
 )
 
 list(APPEND LIBRARIES
-    ${HICNCTRL_LIBRARIES}
+  ${LIBHICNCTRL_LIBRARIES}
 )
 
-
 list(APPEND INCLUDE_DIRS
-    ${HICNCTRL_INCLUDE_DIR}
+  ${LIBHICNCTRL_INCLUDE_DIR}
 )
 
 set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
diff --git a/ctrl/facemgr/src/interfaces/hicn_light/hicn_light.c b/ctrl/facemgr/src/interfaces/hicn_light/hicn_light.c
index b6e0e605a..b396782f5 100644
--- a/ctrl/facemgr/src/interfaces/hicn_light/hicn_light.c
+++ b/ctrl/facemgr/src/interfaces/hicn_light/hicn_light.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -19,8 +19,8 @@
  */
 #include <assert.h>
 #include <stdbool.h>
-#include <stdio.h> // snprintf
-#include <time.h> // time
+#include <stdio.h>  // snprintf
+#include <time.h>   // time
 
 #include <hicn/ctrl.h>
 #include <hicn/facemgr.h>
@@ -38,578 +38,636 @@
 #define WITH_POLL
 
 typedef enum {
-    HL_STATE_UNDEFINED,
-    HL_STATE_IDLE,
-    HL_STATE_ROUTES_SENT,
-    HL_STATE_ROUTES_RECEIVED,
-    HL_STATE_FACES_SENT,
-    HL_STATE_FACES_RECEIVED,
-    HL_STATE_N
+  HL_STATE_UNDEFINED,
+  HL_STATE_IDLE,
+  HL_STATE_ROUTES_SENT,
+  HL_STATE_ROUTES_RECEIVED,
+  HL_STATE_FACES_SENT,
+  HL_STATE_FACES_RECEIVED,
+  HL_STATE_N
 } hl_state_t;
 
 typedef struct {
-    hc_sock_t * s; /* NULL means no active socket */
-    hl_state_t state;
+  hc_sock_t *s; /* NULL means no active socket */
 
-    /* Timer used for forwarder reconnection */
-    int reconnect_timer_fd; /* 0 means no active timer */
+  /* Socket for polling, dependent on s */
+  hc_sock_t *sp; /* NULL means no active socket */
 
-    /* Timer used to periodically poll the forwarder face and routing tables */
-    int poll_timer_fd;
-    hc_data_t * polled_routes;
-} hl_data_t;
+  hl_state_t state;
+
+  /* Timer used for forwarder reconnection */
+  int reconnect_timer_fd; /* 0 means no active timer */
 
-/* Forward declarations */
-int hl_timeout(interface_t * interface, int fd, void * unused);
+  /* Timer used to periodically poll the forwarder face and routing tables */
+  int poll_timer_fd;
+  hc_data_t *polled_routes;
+} hl_data_t;
 
 #ifdef WITH_POLL
-int hl_process_state(interface_t * interface, int fd, void * unused)
+int hl_process_state(interface_t *interface, int fd, void *unused);
 #else
-int hl_process_state(interface_t * interface)
+int hl_process_state(interface_t *interface);
 #endif
-{
-    hl_data_t * data = (hl_data_t *)interface->data;
-
-    /*
-     * Every tick we need to probe the forwarder for the list of faces and
-     * associated routes.
-     *
-     * This is used to guess manually added faces and routes
-     *
-     * TODO ensure we are idle at tick time
-     */
-
-    switch(data->state)
-    {
-        case HL_STATE_IDLE:
-            assert(!data->polled_routes);
-
-            //DEBUG("[hl_process_state] Querying route list");
-            if (hc_route_list_async(data->s) < 0) {
-                DEBUG("[hl_process_state] Error querying route list");
-                return -1;
-            }
-            data->state = HL_STATE_ROUTES_SENT;
-            break;
 
+void start_poll_timer(interface_t *interface) {
+  hl_data_t *data = (hl_data_t *)interface->data;
 
-        case HL_STATE_ROUTES_RECEIVED:
-            //DEBUG("[hl_process_state] Querying face list");
-            if (hc_face_list_async(data->s) < 0) {
-                DEBUG("[hl_process_state] Error querying face list");
-                return -1;
-            }
-            data->state = HL_STATE_FACES_SENT;
-            break;
-
-        case HL_STATE_FACES_RECEIVED:
-            data->state = HL_STATE_IDLE;
-            break;
-
-        case HL_STATE_ROUTES_SENT:
-        case HL_STATE_FACES_SENT:
-            INFO("[hl_process_state] Out of sync... resetting state");
-            if (data->polled_routes) {
-                hc_data_free(data->polled_routes);
-                data->polled_routes = NULL;
-            }
-            data->state = HL_STATE_IDLE;
-            break;
+  data->poll_timer_fd = interface_register_timer(interface, INTERVAL_MS,
+                                                 hl_process_state, interface);
+  if (data->poll_timer_fd < 0) {
+    ERROR("[start_poll_timer) Could not start polling timer");
+  }
+}
 
-        case HL_STATE_UNDEFINED:
-        case HL_STATE_N:
-            ERROR("[hl_process_state] Unexpected state");
-            return -1;
-    }
+void stop_poll_timer(interface_t *interface) {
+  hl_data_t *data = (hl_data_t *)interface->data;
 
-    return 0;
+  if (data->poll_timer_fd > 0)
+    if (interface_unregister_timer(interface, data->poll_timer_fd) < 0) {
+      ERROR("[stop_poll_timer] Could not stop polling timer");
+    }
 }
 
-
-int
-hl_after_connect(interface_t * interface)
+#ifdef WITH_POLL
+int hl_process_state(interface_t *interface, int fd, void *unused)
+#else
+int hl_process_state(interface_t *interface)
+#endif
 {
-    hl_data_t * data = interface->data;
+  hl_data_t *data = (hl_data_t *)interface->data;
+
+  /*
+   * Every tick we need to probe the forwarder for the list of faces and
+   * associated routes.
+   *
+   * This is used to guess manually added faces and routes
+   *
+   * TODO ensure we are idle at tick time
+   */
+
+  switch (data->state) {
+    case HL_STATE_IDLE:
+      assert(!data->polled_routes);
+      stop_poll_timer(interface);
+
+      // DEBUG("[hl_process_state] Querying route list");
+      if (hc_route_list_async(data->sp) < 0) {
+        DEBUG("[hl_process_state] Error querying route list");
+        return -1;
+      }
+      data->state = HL_STATE_ROUTES_SENT;
+      break;
+
+    case HL_STATE_ROUTES_RECEIVED:
+      // DEBUG("[hl_process_state] Querying face list");
+      if (hc_face_list_async(data->sp) < 0) {
+        DEBUG("[hl_process_state] Error querying face list");
+        return -1;
+      }
+      data->state = HL_STATE_FACES_SENT;
+      break;
+
+    case HL_STATE_FACES_RECEIVED:
+      data->state = HL_STATE_IDLE;
+      start_poll_timer(interface);
+      break;
+
+    case HL_STATE_ROUTES_SENT:
+    case HL_STATE_FACES_SENT:
+      WARN("[hl_process_state] Out of sync... resetting state");
+      if (data->polled_routes) {
+        hc_data_free(data->polled_routes);
+        data->polled_routes = NULL;
+      }
+      data->state = HL_STATE_IDLE;
+      start_poll_timer(interface);
+      break;
+
+    case HL_STATE_UNDEFINED:
+    case HL_STATE_N:
+      ERROR("[hl_process_state] Unexpected state");
+      return -1;
+  }
+
+  return 0;
+}
 
-    /* File descriptor for control socket operations */
-    if (interface_register_fd(interface, hc_sock_get_fd(data->s), NULL) < 0) {
-        ERROR("[hc_connect] Error registering fd");
-        goto ERR_FD;
-    }
+/*
+ * Called whenever a connection to both sockets succeeds.
+ * Polling will be useful to detect when connection to the forwarder is lost,
+ * and will allow to try reconnect both sockets (the control socket being UDP /
+ * in blocking mode will not detect such loss of connection). Operations on the
+ * control socket that will fail will be reattempted by higher layers.
+ */
+int hl_after_connect(interface_t *interface) {
+  hl_data_t *data = interface->data;
 
-    /* We always restart from the idle phase */
-    data->state = HL_STATE_IDLE;
+  /* File descriptor for polling socket operations */
+  if (interface_register_fd(interface, hc_sock_get_fd(data->sp), NULL) < 0) {
+    ERROR("[hc_connect] Error registering fd");
+    goto ERR_FD;
+  }
 
+  /* We always restart from the idle phase */
+  data->state = HL_STATE_IDLE;
 
 /* poll will replace the original get, ideally we would get notifications */
 #ifdef WITH_POLL
-    data->poll_timer_fd = interface_register_timer(interface, INTERVAL_MS,
-            hl_process_state, interface);
-    if (data->poll_timer_fd < 0) {
-        ERROR("[hc_connect] Could not initialize polling timer");
-        return -1;
-    }
+  start_poll_timer(interface);
 #else
-    hl_process_state(interface);
+  hl_process_state(interface);
 #endif
 
-    return 0;
+  return 0;
 
-    //interface_unregister_fd(interface, hc_sock_get_fd(data->s));
+  // interface_unregister_fd(interface, hc_sock_get_fd(data->sp));
 ERR_FD:
-    return -1;
+  return -1;
 }
 
-int _hl_connect(interface_t * interface);
+int _hl_connect(interface_t *interface);
 
-int
-hl_connect_timeout(interface_t * interface, int fd, void * unused)
-{
-    hl_data_t * data = interface->data;
-    assert(fd == data->reconnect_timer_fd);
-    _unused(data);
+int hl_connect_timeout(interface_t *interface, int fd, void *unused) {
+  hl_data_t *data = interface->data;
+  assert(fd == data->reconnect_timer_fd);
+  _unused(data);
 
-    int rc = _hl_connect(interface);
-    if (rc < 0) {
-        DEBUG("[hl_initialize] Error during connection reattempt; next attempt in %ds", INTERVAL_MS / 1000);
-        return -1;
-    }
+  int rc = _hl_connect(interface);
+  if (rc < 0) {
+    DEBUG(
+        "[hl_initialize] Error during connection reattempt; next attempt in "
+        "%ds",
+        INTERVAL_MS / 1000);
+    return -1;
+  }
 
-    if (interface_unregister_timer(interface, fd) < 0) {
-        ERROR("[hl_connect_timeout] Could not cancel timer after successful connect");
-    }
+  if (interface_unregister_timer(interface, fd) < 0) {
+    ERROR(
+        "[hl_connect_timeout] Could not cancel timer after successful connect");
+  }
 
-    /* Connect success */
-    return hl_after_connect(interface);
+  /* Connect success */
+  return hl_after_connect(interface);
 }
 
-
-int
-_hl_connect(interface_t * interface)
-{
-    hl_data_t * data = interface->data;
-    assert(!data->s);
-
-    data->s = hc_sock_create();
-    if (data->s <= 0) {
-        ERROR("[hc_connect] Could not create control socket");
-        goto ERR_SOCK;
-    }
-
-    if (hc_sock_connect(data->s) < 0) {
-        DEBUG("[hc_connect] Could not connect control socket");
-        goto ERR_CONNECT;
-    }
-
-    return 0;
-
+/*
+ * Connection without reattempt. Both control and polling sockets should be
+ * connected to succeed.
+ */
+int _hl_connect(interface_t *interface) {
+  hl_data_t *data = interface->data;
+  assert(!data->s);
+  assert(!data->sp);
+
+  data->s = hc_sock_create();
+  if (data->s <= 0) {
+    ERROR("[hc_connect] Could not create control socket");
+    goto ERR_SOCK;
+  }
+
+  if (hc_sock_connect(data->s) < 0) {
+    DEBUG("[hc_connect] Could not connect control socket");
+    goto ERR_CONNECT;
+  }
+
+  data->sp = hc_sock_create();
+  if (data->sp <= 0) {
+    ERROR("[hc_connect] Could not create polling socket");
+    goto ERR_SOCK_POLL;
+  }
+
+  if (hc_sock_connect(data->sp) < 0) {
+    DEBUG("[hc_connect] Could not connect polling socket");
+    goto ERR_CONNECT_POLL;
+  }
+
+  return 0;
+
+ERR_CONNECT_POLL:
+  hc_sock_free(data->sp);
+  data->sp = NULL;
+ERR_SOCK_POLL:
 ERR_CONNECT:
-    hc_sock_free(data->s);
-    data->s = NULL;
+  hc_sock_free(data->s);
+  data->s = NULL;
 ERR_SOCK:
-    return -1;
-
+  return -1;
 }
 
-int hl_disconnect(interface_t * interface)
-{
-    hl_data_t * data = (hl_data_t *) interface->data;
-    if (data->reconnect_timer_fd > 0)
-        interface_unregister_timer(interface, data->reconnect_timer_fd);
+int hl_disconnect(interface_t *interface) {
+  hl_data_t *data = (hl_data_t *)interface->data;
+  if (data->reconnect_timer_fd > 0)
+    interface_unregister_timer(interface, data->reconnect_timer_fd);
 
-    if (data->poll_timer_fd > 0)
-        interface_unregister_timer(interface, data->poll_timer_fd);
+  stop_poll_timer(interface);
 
-    if (data->polled_routes)
-        hc_data_free(data->polled_routes);
+  if (data->polled_routes) hc_data_free(data->polled_routes);
 
-    if (data->s) {
-        interface_unregister_fd(interface, hc_sock_get_fd(data->s));
-        hc_sock_free(data->s);
-    }
+  if (data->s) {
+    hc_sock_free(data->s);
+    data->s = NULL;
+  }
 
-    return 0;
+  if (data->sp) {
+    interface_unregister_fd(interface, hc_sock_get_fd(data->sp));
+    hc_sock_free(data->sp);
+    data->sp = NULL;
+  }
+
+  return 0;
 }
 
-int
-hl_connect(interface_t * interface)
-{
-    hl_data_t * data = interface->data;
+/* Connection with reattempts */
+int hl_connect(interface_t *interface) {
+  hl_data_t *data = interface->data;
 
-    if (_hl_connect(interface) >= 0)
-        return hl_after_connect(interface);
+  if (_hl_connect(interface) >= 0) return hl_after_connect(interface);
 
-    /* Timer for managing the connection to the forwarder */
-    DEBUG("Connection to forwarder failed... next retry in %ds", INTERVAL_MS / 1000);
-    data->reconnect_timer_fd = interface_register_timer(interface, INTERVAL_MS, hl_connect_timeout, NULL);
-    if (data->reconnect_timer_fd < 0) {
-        ERROR("[hc_connect] Could not initialize reattempt timer");
-        return -1;
-    }
+  /* Timer for managing the connection to the forwarder */
+  DEBUG("Connection to forwarder failed... next retry in %ds",
+        INTERVAL_MS / 1000);
+  data->reconnect_timer_fd = interface_register_timer(interface, INTERVAL_MS,
+                                                      hl_connect_timeout, NULL);
+  if (data->reconnect_timer_fd < 0) {
+    ERROR("[hc_connect] Could not initialize reattempt timer");
+    return -1;
+  }
 
-    return 0;
+  return 0;
 }
 
-int
-hl_initialize(interface_t * interface, void * cfg)
-{
-    hl_data_t * data = malloc(sizeof(hl_data_t));
-    if (!data) {
-        ERROR("[hicn_light] Out of memory!");
-        goto ERR_MALLOC;
-    }
-
-    data->s = NULL;
-    data->reconnect_timer_fd = 0;
-    data->poll_timer_fd = 0;
+int hl_initialize(interface_t *interface, void *cfg) {
+  hl_data_t *data = malloc(sizeof(hl_data_t));
+  if (!data) {
+    ERROR("[hicn_light] Out of memory!");
+    goto ERR_MALLOC;
+  }
 
-    interface->data = data;
+  data->s = NULL;
+  data->sp = NULL;
+  data->reconnect_timer_fd = 0;
+  data->poll_timer_fd = 0;
+  data->polled_routes = NULL;
+  data->state = HL_STATE_UNDEFINED;
 
-    if (hl_connect(interface) < 0) {
-        ERROR("[hl_initialize] Error during connection to forwarder");
-        goto ERR_CONNECT;
-    }
+  interface->data = data;
 
-    data->polled_routes = NULL;
+  /* Connect both control and polling sockets */
+  if (hl_connect(interface) < 0) {
+    ERROR("[hl_initialize] Error during connection to forwarder");
+    goto ERR_CONNECT;
+  }
 
-    return 0;
+  return 0;
 
 ERR_CONNECT:
-    free(data);
+  free(data);
 ERR_MALLOC:
-    return -1;
+  return -1;
 }
 
-int hl_finalize(interface_t * interface)
-{
-    hl_data_t * data = (hl_data_t *) interface->data;
+int hl_finalize(interface_t *interface) {
+  hl_data_t *data = (hl_data_t *)interface->data;
 
-    hl_disconnect(interface);
+  hl_disconnect(interface);
 
-    if (data->polled_routes)
-        hc_data_free(data->polled_routes);
+  if (data->polled_routes) hc_data_free(data->polled_routes);
 
-    free(data);
+  free(data);
 
-    return 0;
+  return 0;
 }
 
-int hl_on_event(interface_t * interface, facelet_t * facelet)
-{
-    hc_face_t hc_face;
-    hc_route_t route;
-    int rc;
-    int ret = 0;
-    hl_data_t * data = (hl_data_t *)interface->data;
-    face_t * face = NULL;
-
-    hc_face.id = 0;
-    memset(hc_face.name, 0, sizeof(hc_face.name));
-
-
-    /* NOTE
-     *  - One example where this fails (and it is normal) is when we delete a
-     *  face that was not completely created, because for instance bonjour did
-     *  not give any data
-     */
-    if (facelet_get_face(facelet, &face) < 0) {
-        ERROR("Could not retrieve face from facelet");
-        ret = -FACELET_ERROR_REASON_INTERNAL_ERROR;
-        goto ERR_FACE;
+int hl_on_event(interface_t *interface, facelet_t *facelet) {
+  hc_face_t hc_face;
+  hc_route_t route;
+  int rc;
+  int ret = 0;
+  hl_data_t *data = (hl_data_t *)interface->data;
+  face_t *face = NULL;
+
+  hc_face.id = 0;
+  memset(hc_face.name, 0, sizeof(hc_face.name));
+
+  /* NOTE
+   *  - One example where this fails (and it is normal) is when we delete a
+   *  face that was not completely created, because for instance bonjour did
+   *  not give any data
+   */
+  if (facelet_get_face(facelet, &face) < 0) {
+    ERROR("Could not retrieve face from facelet");
+    ret = -FACELET_ERROR_REASON_INTERNAL_ERROR;
+    goto ERR_FACE;
+  }
+
+  if (!data->s) {
+    /* We are not connected to the forwarder */
+    ret = -FACELET_ERROR_REASON_FORWARDER_OFFLINE;
+    goto ERR;
+  }
+
+  switch (facelet_get_event(facelet)) {
+    case FACELET_EVENT_CREATE: {
+      /* Create face */
+      char buf[MAXSZ_FACELET];
+      facelet_snprintf(buf, MAXSZ_FACELET, facelet);
+      DEBUG("Create facelet %s", buf);
+
+      hc_face.face = *face;
+      rc = hc_face_create(data->s, &hc_face);
+      if (rc < 0) {
+        ERROR("Failed to create face\n");
+        ret = -FACELET_ERROR_REASON_UNSPECIFIED_ERROR;
+        goto ERR;
+      }
+      INFO("Created face id=%d - %s", hc_face.id, buf);
     }
 
-    if (!data->s) {
-        /* We are not connected to the forwarder */
-        ret = -FACELET_ERROR_REASON_FORWARDER_OFFLINE;
+      hicn_route_t **route_array;
+      int n = facelet_get_route_array(facelet, &route_array);
+      if (n < 0) {
+        ERROR("Failed to create default hICN/IPv4 route");
+        ret = -FACELET_ERROR_REASON_UNSPECIFIED_ERROR;
         goto ERR;
-    }
+      }
+      if (n == 0) {
+        /* Adding default routes */
+        route = (hc_route_t){
+            .face_id = hc_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");
+          ret = -1;
+        }
 
-    switch(facelet_get_event(facelet)) {
-
-        case FACELET_EVENT_CREATE:
-            {
-            /* Create face */
-            char buf[MAXSZ_FACELET];
-            facelet_snprintf(buf, MAXSZ_FACELET, facelet);
-            DEBUG("Create facelet %s", buf);
-
-            hc_face.face = *face;
-            rc = hc_face_create(data->s, &hc_face);
-            if (rc < 0) {
-                ERROR("Failed to create face\n");
-                ret = -FACELET_ERROR_REASON_UNSPECIFIED_ERROR;
-                goto ERR;
-            }
-            INFO("Created face id=%d - %s", hc_face.id, buf);
-            }
+        route = (hc_route_t){
+            .face_id = hc_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");
+          ret = -1;
+        }
 
-            hicn_route_t ** route_array;
-            int n = facelet_get_route_array(facelet, &route_array);
-            if (n < 0) {
-                ERROR("Failed to create default hICN/IPv4 route");
-                ret = -FACELET_ERROR_REASON_UNSPECIFIED_ERROR;
-                goto ERR;
-            }
-            if (n == 0) {
-                /* Adding default routes */
-                route = (hc_route_t) {
-                    .face_id = hc_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");
-                    ret = -1;
-                }
-
-                route = (hc_route_t) {
-                    .face_id = hc_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");
-                    ret = -1;
-                }
-
-                INFO("Successfully created default route(s).");
-            } else {
-                for (unsigned i = 0; i < n; i++) {
-                    hicn_route_t * hicn_route = route_array[i];
-                    ip_prefix_t prefix;
-                    int cost;
-                    if (hicn_route_get_prefix(hicn_route, &prefix) < 0) {
-                        ERROR("Failed to get route prefix");
-                        ret = -1;
-                        continue;
-                    }
-                    if (hicn_route_get_cost(hicn_route, &cost) < 0) {
-                        ERROR("Failed to get route cost");
-                        ret = -1;
-                        continue;
-                    }
-                    route = (hc_route_t) {
-                        .face_id = hc_face.id,
-                        .family = prefix.family,
-                        .remote_addr = prefix.address,
-                        .len = prefix.len,
-                        .cost = cost,
-                    };
-                    if (hc_route_create(data->s, &route) < 0) {
-                        ERROR("Failed to create static route route");
-                        ret = -1;
-                        continue;
-                    }
-                }
-            }
-            free(route_array);
-
-            break;
-
-        case FACELET_EVENT_DELETE:
-            /* Removing a face should also remove associated routes */
-            hc_face.face = *face;
-            rc = hc_face_delete(data->s, &hc_face);
-            if (rc < 0) {
-                ERROR("Failed to delete face\n");
-                ret = -FACELET_ERROR_REASON_UNSPECIFIED_ERROR;
-                goto ERR;
-            }
+        INFO("Successfully created default route(s).");
+      } else {
+        for (unsigned i = 0; i < n; i++) {
+          hicn_route_t *hicn_route = route_array[i];
+          ip_prefix_t prefix;
+          int cost;
+          if (hicn_route_get_prefix(hicn_route, &prefix) < 0) {
+            ERROR("Failed to get route prefix");
+            ret = -1;
+            continue;
+          }
+          if (hicn_route_get_cost(hicn_route, &cost) < 0) {
+            ERROR("Failed to get route cost");
+            ret = -1;
+            continue;
+          }
+          route = (hc_route_t){
+              .face_id = hc_face.id,
+              .name = "", /* take face_id into account */
+              .family = prefix.family,
+              .remote_addr = prefix.address,
+              .len = prefix.len,
+              .cost = cost,
+          };
+          if (hc_route_create(data->s, &route) < 0) {
+            ERROR("Failed to create static route route");
+            ret = -1;
+            continue;
+          }
+        }
+      }
+      free(route_array);
+
+      break;
+
+    case FACELET_EVENT_DELETE:
+      /* Removing a face should also remove associated routes */
+      hc_face.face = *face;
+      rc = hc_face_delete(data->s, &hc_face, 1);
+      if (rc < 0) {
+        ERROR("Failed to delete face\n");
+        ret = -FACELET_ERROR_REASON_UNSPECIFIED_ERROR;
+        goto ERR;
+      }
+
+      char buf[MAXSZ_FACELET];
+      facelet_snprintf(buf, MAXSZ_FACELET, facelet);
+      INFO("Deleted face id=%d", hc_face.id);
+
+      break;
+
+    case FACELET_EVENT_UPDATE:
+      /* Currently, only admin_state & priority are supported */
+      if (facelet_get_admin_state_status(facelet) ==
+          FACELET_ATTR_STATUS_DIRTY) {
+        hc_face.face = *face;
+        hc_face_t *face_found;
+
+        rc = hc_face_get(data->s, &hc_face, &face_found);
+        if (rc < 0) {
+          ERROR("Failed to find face\n");
+          ret = -FACELET_ERROR_REASON_INTERNAL_ERROR;
+          goto ERR;
+        }
+        if (!face_found) {
+          ERROR("Face to update has not been found");
+          ret = -FACELET_ERROR_REASON_UNSPECIFIED_ERROR;
+          goto ERR;
+        }
+        char conn_id_or_name[SYMBOLIC_NAME_LEN];
+        snprintf(conn_id_or_name, SYMBOLIC_NAME_LEN, "%d", face_found->id);
+        free(face_found);
+
+        face_state_t admin_state;
+        if (facelet_get_admin_state(facelet, &admin_state) < 0) {
+          ERROR("Failed to retrieve facelet admin state");
+          ret = -FACELET_ERROR_REASON_INTERNAL_ERROR;
+          goto ERR;
+        }
 
-            char buf[MAXSZ_FACELET];
-            facelet_snprintf(buf, MAXSZ_FACELET, facelet);
-            INFO("Deleted face id=%d", hc_face.id);
-
-            break;
-
-        case FACELET_EVENT_UPDATE:
-            /* Currently, only admin_state & priority are supported */
-            if (facelet_get_admin_state_status(facelet) == FACELET_ATTR_STATUS_DIRTY) {
-                hc_face.face = *face;
-                hc_face_t * face_found;
-
-                rc = hc_face_get(data->s, &hc_face, &face_found);
-                if (rc < 0) {
-                    ERROR("Failed to find face\n");
-                    ret = -FACELET_ERROR_REASON_INTERNAL_ERROR;
-                    goto ERR;
-                }
-                if (!face_found) {
-                    ERROR("Face to update has not been found");
-                    ret = -FACELET_ERROR_REASON_UNSPECIFIED_ERROR;
-                    goto ERR;
-                }
-                char conn_id_or_name[SYMBOLIC_NAME_LEN];
-                snprintf(conn_id_or_name, SYMBOLIC_NAME_LEN, "%d", face_found->id);
-                free(face_found);
-
-                face_state_t admin_state;
-                if (facelet_get_admin_state(facelet, &admin_state) < 0) {
-                    ERROR("Failed to retrieve facelet admin state");
-                    ret = -FACELET_ERROR_REASON_INTERNAL_ERROR;
-                    goto ERR;
-                }
-
-                if (hc_connection_set_admin_state(data->s, conn_id_or_name, admin_state) < 0) {
-                    ERROR("Failed to update admin state");
-                    ret = -FACELET_ERROR_REASON_UNSPECIFIED_ERROR;
-                    goto ERR;
-                }
-                facelet_set_admin_state_status(facelet, FACELET_ATTR_STATUS_CLEAN);
-                INFO("Updated face id=%d - admin_state=%s", hc_face.id,
-                        face_state_str[admin_state]);
-            }
+        if (hc_connection_set_admin_state(data->s, conn_id_or_name,
+                                          admin_state) < 0) {
+          ERROR("Failed to update admin state");
+          ret = -FACELET_ERROR_REASON_UNSPECIFIED_ERROR;
+          goto ERR;
+        }
+        facelet_set_admin_state_status(facelet, FACELET_ATTR_STATUS_CLEAN);
+        INFO("Updated face id=%d - admin_state=%s", hc_face.id,
+             face_state_str(admin_state));
+      }
 #ifdef WITH_POLICY
-            if (facelet_get_netdevice_type_status(facelet) == FACELET_ATTR_STATUS_DIRTY) {
-                hc_face.face = *face;
-                hc_face_t * face_found;
-
-                rc = hc_face_get(data->s, &hc_face, &face_found);
-                if (rc < 0) {
-                    ERROR("Failed to find face\n");
-                    goto ERR;
-                }
-                if (!face_found) {
-                    ERROR("Face to update has not been found");
-                    goto ERR;
-                }
-                char conn_id_or_name[SYMBOLIC_NAME_LEN];
-                snprintf(conn_id_or_name, SYMBOLIC_NAME_LEN, "%d", face_found->id);
-                free(face_found);
-
-                netdevice_type_t netdevice_type;
-                if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) {
-                    ERROR("Failed to retrieve facelet netdevice_type");
-                    goto ERR;
-                }
-
-                /* Encode netdevice type into tags */ 
-                policy_tags_t tags = POLICY_TAGS_EMPTY;
-                if (facelet_has_netdevice_type(facelet)) {
-                    netdevice_type_t netdevice_type;
-                    if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) {
-                        ERROR("error getting netdevice_type");
-                        goto ERR;
-                    }
-
-
-                    switch(netdevice_type) {
-                        case NETDEVICE_TYPE_UNDEFINED:
-                        case NETDEVICE_TYPE_LOOPBACK:
-                            break;
-                        case NETDEVICE_TYPE_WIRED:
-                            policy_tags_add(&tags, POLICY_TAG_WIRED);
-                            break;
-                        case NETDEVICE_TYPE_WIFI:
-                            policy_tags_add(&tags, POLICY_TAG_WIFI);
-                            break;
-                        case NETDEVICE_TYPE_CELLULAR:
-                            policy_tags_add(&tags, POLICY_TAG_CELLULAR);
-                            break;
-                        default:
-                            goto ERR;
-                    }
-                }
-                //face->tags = tags;
-
-                if (hc_connection_set_tags(data->s, conn_id_or_name, tags) < 0) {
-                    ERROR("Failed to update tags");
-                    goto ERR;
-                }
-                facelet_set_netdevice_type_status(facelet, FACELET_ATTR_STATUS_CLEAN);
-                INFO("Updated face id=%d - netdevice_type=%s", hc_face.id,
-                        netdevice_type_str[netdevice_type]);
-            }
-            if (facelet_get_priority_status(facelet) == FACELET_ATTR_STATUS_DIRTY) {
-                INFO("Updating priority...");
-                hc_face.face = *face;
-                hc_face_t * face_found;
-
-                rc = hc_face_get(data->s, &hc_face, &face_found);
-                if (rc < 0) {
-                    ERROR("Failed to find face\n");
-                    goto ERR;
-                }
-                if (!face_found) {
-                    ERROR("Face to update has not been found");
-                    goto ERR;
-                }
-                char conn_id_or_name[SYMBOLIC_NAME_LEN];
-                snprintf(conn_id_or_name, SYMBOLIC_NAME_LEN, "%d", face_found->id);
-                free(face_found);
-
-                uint32_t priority;
-                if (facelet_get_priority(facelet, &priority) < 0) {
-                    ERROR("Failed to retrieve facelet priority");
-                    goto ERR;
-                }
-
-                INFO("Changing connection %s priority to %d", conn_id_or_name, priority);
-                if (hc_connection_set_priority(data->s, conn_id_or_name, priority) < 0) {
-                    ERROR("Failed to update priority");
-                    goto ERR;
-                }
-                facelet_set_priority_status(facelet, FACELET_ATTR_STATUS_CLEAN);
-
-                INFO("Updated face id=%d - priority=%d", hc_face.id, priority);
-            }
-#endif /* WITH_POLICY */
-            break;
+      if (facelet_get_netdevice_type_status(facelet) ==
+          FACELET_ATTR_STATUS_DIRTY) {
+        hc_face.face = *face;
+        hc_face_t *face_found;
+
+        rc = hc_face_get(data->s, &hc_face, &face_found);
+        if (rc < 0) {
+          ERROR("Failed to find face\n");
+          goto ERR;
+        }
+        if (!face_found) {
+          ERROR("Face to update has not been found");
+          goto ERR;
+        }
+        char conn_id_or_name[SYMBOLIC_NAME_LEN];
+        snprintf(conn_id_or_name, SYMBOLIC_NAME_LEN, "%d", face_found->id);
+        free(face_found);
+
+        netdevice_type_t netdevice_type;
+        if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) {
+          ERROR("Failed to retrieve facelet netdevice_type");
+          goto ERR;
+        }
 
-        default:
-            ERROR("Unknown event %s\n", facelet_event_str[facelet_get_event(facelet)]);
-            /* Unsupported events */
-            ret = -FACELET_ERROR_REASON_INTERNAL_ERROR;
+        /* Encode netdevice type into tags */
+        policy_tags_t tags = POLICY_TAGS_EMPTY;
+        if (facelet_has_netdevice_type(facelet)) {
+          netdevice_type_t netdevice_type;
+          if (facelet_get_netdevice_type(facelet, &netdevice_type) < 0) {
+            ERROR("error getting netdevice_type");
             goto ERR;
-    }
+          }
+
+          switch (netdevice_type) {
+            case NETDEVICE_TYPE_UNDEFINED:
+            case NETDEVICE_TYPE_LOOPBACK:
+              break;
+            case NETDEVICE_TYPE_WIRED:
+              policy_tags_add(&tags, POLICY_TAG_WIRED);
+              break;
+            case NETDEVICE_TYPE_WIFI:
+              policy_tags_add(&tags, POLICY_TAG_WIFI);
+              break;
+            case NETDEVICE_TYPE_CELLULAR:
+              policy_tags_add(&tags, POLICY_TAG_CELLULAR);
+              break;
+            default:
+              goto ERR;
+          }
+        }
+        // face->tags = tags;
+
+        if (hc_connection_set_tags(data->s, conn_id_or_name, tags) < 0) {
+          ERROR("Failed to update tags");
+          goto ERR;
+        }
+        facelet_set_netdevice_type_status(facelet, FACELET_ATTR_STATUS_CLEAN);
+        INFO("Updated face id=%d - netdevice_type=%s", hc_face.id,
+             netdevice_type_str(netdevice_type));
+      }
+      if (facelet_get_priority_status(facelet) == FACELET_ATTR_STATUS_DIRTY) {
+        INFO("Updating priority...");
+        hc_face.face = *face;
+        hc_face_t *face_found;
+
+        rc = hc_face_get(data->s, &hc_face, &face_found);
+        if (rc < 0) {
+          ERROR("Failed to find face\n");
+          goto ERR;
+        }
+        if (!face_found) {
+          ERROR("Face to update has not been found");
+          goto ERR;
+        }
+        char conn_id_or_name[SYMBOLIC_NAME_LEN];
+        snprintf(conn_id_or_name, SYMBOLIC_NAME_LEN, "%d", face_found->id);
+        free(face_found);
+
+        uint32_t priority;
+        if (facelet_get_priority(facelet, &priority) < 0) {
+          ERROR("Failed to retrieve facelet priority");
+          goto ERR;
+        }
+
+        INFO("Changing connection %s priority to %d", conn_id_or_name,
+             priority);
+        if (hc_connection_set_priority(data->s, conn_id_or_name, priority) <
+            0) {
+          ERROR("Failed to update priority");
+          goto ERR;
+        }
+        facelet_set_priority_status(facelet, FACELET_ATTR_STATUS_CLEAN);
+
+        INFO("Updated face id=%d - priority=%d", hc_face.id, priority);
+      }
+#endif /* WITH_POLICY */
+      break;
+
+    default:
+      ERROR("Unknown event %s\n",
+            facelet_event_str[facelet_get_event(facelet)]);
+      /* Unsupported events */
+      ret = -FACELET_ERROR_REASON_INTERNAL_ERROR;
+      goto ERR;
+  }
 
 ERR:
-    face_free(face);
+  face_free(face);
 ERR_FACE:
-    return ret;
+  return ret;
 }
 
-int hl_callback(interface_t * interface, int fd, void * unused)
-{
-    hl_data_t * data = (hl_data_t*)interface->data;
-    hc_data_t * results;
-    int ret = 0;
-
-    /* In case of error, reconnect to forwarder */
-    if (hc_sock_callback(data->s, &results) < 0) {
-        DEBUG("Closing socket... reconnecting...");
-        if (interface_unregister_fd(interface, hc_sock_get_fd(data->s)) < 0) {
-            ERROR("[hl_callback] Error unregistering fd");
-        }
-
-        /* Stopping poll timer */
-        if (interface_unregister_timer(interface, data->poll_timer_fd) < 0) {
-            ERROR("[hl_callback] Could not cancel polling timer after forwarder disconnect");
-        }
-        if (data->polled_routes)
-            hc_data_free(data->polled_routes);
+/*
+ * This should only receive data from the polling socket which is asynchronous,
+ * while all face creation, etc. operations are done synchronously in this
+ * version.
+ */
+int hl_callback(interface_t *interface, int fd, void *unused) {
+  hl_data_t *data = (hl_data_t *)interface->data;
+  hc_data_t *results;
+  int ret = 0;
+
+  /* Workaround: sometimes this is called with data = NULL */
+  if (!data) {
+    INFO("[hl_callback] no data");
+    return 0;
+  }
 
-        hc_sock_free(data->s);
-        data->s = NULL;
-        hl_connect(interface);
-        return ret;
+  /* In case of error, reconnect to forwarder */
+  if (hc_sock_callback(data->sp, &results) < 0) {
+    INFO("Closing socket... reconnecting...");
+    if (interface_unregister_fd(interface, hc_sock_get_fd(data->sp)) < 0) {
+      ERROR("[hl_callback] Error unregistering fd");
     }
 
-    /* Shall we wait for more data ? */
-    if (!results->complete)
-        return ret;
+    /* Stopping poll timer */
+    stop_poll_timer(interface);
+    if (data->polled_routes) hc_data_free(data->polled_routes);
 
-    /* Process returned data */
-    switch(data->state) {
+    hc_sock_free(data->s);
+    data->s = NULL;
+    hc_sock_free(data->sp);
+    data->sp = NULL;
 
-        case HL_STATE_ROUTES_SENT:
-            //DEBUG("[hl_callback] Processing routes");
-            data->polled_routes = results;
+    hl_connect(interface);
+    return ret;
+  }
+
+  /* Shall we wait for more data ? */
+  if (!results->complete) {
+    INFO("[hl_callback] results incomplete");
+    return ret;
+  }
+
+  /* Process returned data */
+  // DEBUG("Processing data");
+  switch (data->state) {
+    case HL_STATE_ROUTES_SENT:
+      // DEBUG("[hl_callback] Processing routes");
+      data->polled_routes = results;
 
 #if 0
             foreach_route(r, results) {
@@ -622,19 +680,17 @@ int hl_callback(interface_t * interface, int fd, void * unused)
                 DEBUG("Route: %s", buf);
             }
 #endif
-            data->state = HL_STATE_ROUTES_RECEIVED;
-            if (hl_process_state(interface, fd, unused) < 0) {
-                ERROR("[hl_callback] Error processing state after routes received");
-                ret = -1;
-            }
-            break;
-
-
-        case HL_STATE_FACES_SENT:
-            //DEBUG("[hl_callback] Processing faces");
-            assert(data->polled_routes);
-            foreach_face(f, results) {
-
+      data->state = HL_STATE_ROUTES_RECEIVED;
+      if (hl_process_state(interface, fd, unused) < 0) {
+        ERROR("[hl_callback] Error processing state after routes received");
+        ret = -1;
+      }
+      break;
+
+    case HL_STATE_FACES_SENT:
+      // DEBUG("[hl_callback] Processing faces");
+      assert(data->polled_routes);
+      foreach_face(f, results) {
 #if 0
                 char buf[MAXSZ_FACE];
                 int rc = hc_face_snprintf(buf, MAXSZ_FACE, f);
@@ -646,17 +702,16 @@ int hl_callback(interface_t * interface, int fd, void * unused)
                 DEBUG("Face: %s", buf);
 #endif
 
-                /* We can ignore faces on localhost */
+        /* We can ignore faces on localhost */
 
-                facelet_t * facelet = facelet_create_from_face(&f->face);
-                if (!facelet) {
-                    ERROR("[hl_callback] Could not create facelet... skipping");
-                    continue;
-                }
+        facelet_t *facelet = facelet_create_from_face(&f->face);
+        if (!facelet) {
+          ERROR("[hl_callback] Could not create facelet... skipping");
+          continue;
+        }
 
-                foreach_route(r, data->polled_routes) {
-                    if (r->face_id != f->id)
-                        continue;
+        foreach_route(r, data->polled_routes) {
+          if (r->face_id != f->id) continue;
 
 #if 0
                     char route_s[MAXSZ_HC_ROUTE];
@@ -668,41 +723,40 @@ int hl_callback(interface_t * interface, int fd, void * unused)
                     DEBUG("Associated route: %s", route_s);
 #endif
 
-                    if (r->len == 0)
-                        continue;
-
-                    ip_prefix_t prefix = {
-                        .family = r->family,
-                        .address = r->remote_addr,
-                        .len = r->len,
-                    };
-                    hicn_route_t * route = hicn_route_create(&prefix, r->face_id, r->cost);
-                    facelet_add_route(facelet, route);
-                }
+          if (r->len == 0) continue;
 
-                facelet_set_event(facelet, FACELET_EVENT_GET);
-                interface_raise_event(interface, facelet);
-            }
-            hc_data_free(results);
-            hc_data_free(data->polled_routes);
-            data->polled_routes = NULL;
-            data->state = HL_STATE_FACES_RECEIVED;
-            if (hl_process_state(interface, fd, unused) < 0) {
-                ERROR("[hl_callback] Error processing state after faces received");
-                ret = -1;
-            }
-            break;
-
-        case HL_STATE_IDLE:
-        case HL_STATE_FACES_RECEIVED:
-        case HL_STATE_ROUTES_RECEIVED:
-        case HL_STATE_UNDEFINED:
-        case HL_STATE_N:
-            ERROR("[hl_callback] Unexpected state");
-            ret = -1;
-    }
+          ip_prefix_t prefix = {
+              .family = r->family,
+              .address = r->remote_addr,
+              .len = r->len,
+          };
+          hicn_route_t *route = hicn_route_create(&prefix, r->face_id, r->cost);
+          facelet_add_route(facelet, route);
+        }
 
-    return ret;
+        facelet_set_event(facelet, FACELET_EVENT_GET);
+        interface_raise_event(interface, facelet);
+      }
+      hc_data_free(results);
+      hc_data_free(data->polled_routes);
+      data->polled_routes = NULL;
+      data->state = HL_STATE_FACES_RECEIVED;
+      if (hl_process_state(interface, fd, unused) < 0) {
+        ERROR("[hl_callback] Error processing state after faces received");
+        ret = -1;
+      }
+      break;
+
+    case HL_STATE_IDLE:
+    case HL_STATE_FACES_RECEIVED:
+    case HL_STATE_ROUTES_RECEIVED:
+    case HL_STATE_UNDEFINED:
+    case HL_STATE_N:
+      ERROR("[hl_callback] Unexpected state");
+      ret = -1;
+  }
+
+  return ret;
 }
 
 const interface_ops_t hicn_light_ops = {
diff --git a/ctrl/facemgr/src/interfaces/netlink/CMakeLists.txt b/ctrl/facemgr/src/interfaces/netlink/CMakeLists.txt
index 7f44d87fe..5d46cb8b6 100644
--- a/ctrl/facemgr/src/interfaces/netlink/CMakeLists.txt
+++ b/ctrl/facemgr/src/interfaces/netlink/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/ctrl/facemgr/src/interfaces/netlink/netlink.c b/ctrl/facemgr/src/interfaces/netlink/netlink.c
index a1affd719..11738d7ac 100644
--- a/ctrl/facemgr/src/interfaces/netlink/netlink.c
+++ b/ctrl/facemgr/src/interfaces/netlink/netlink.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -20,9 +20,9 @@
 
 #include <assert.h>
 #include <linux/rtnetlink.h>
-#include <net/if_arp.h> // ARPHRD_LOOPBACK
-#include <sys/types.h> // getpid
-#include <unistd.h> // getpid
+#include <net/if_arp.h>  // ARPHRD_LOOPBACK
+#include <sys/types.h>   // getpid
+#include <unistd.h>      // getpid
 
 #include <hicn/facemgr.h>
 #include <hicn/util/ip_address.h>
@@ -32,202 +32,188 @@
 #include "../../interface.h"
 
 typedef enum {
-    NL_STATE_UNDEFINED,
-    NL_STATE_LINK_SENT,
-    NL_STATE_ADDR_SENT,
-    NL_STATE_DONE,
+  NL_STATE_UNDEFINED,
+  NL_STATE_LINK_SENT,
+  NL_STATE_ADDR_SENT,
+  NL_STATE_DONE,
 } nl_state_t;
 
 /* Internal data storage */
 typedef struct {
-    int fd;
-    nl_state_t state;
+  int fd;
+  nl_state_t state;
 } nl_data_t;
 
-static inline void parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len,
-	unsigned short flags)
-{
-    unsigned short type;
-
-    memset(tb, 0, sizeof(struct rtattr *) * (max + 1));
-    while (RTA_OK(rta, len)) {
-        type = rta->rta_type & ~flags;
-        if (type <= max)
-            tb[type] = rta;
-        rta = RTA_NEXT(rta, len);
-    }
+static inline void parse_rtattr(struct rtattr *tb[], int max,
+                                struct rtattr *rta, int len,
+                                unsigned short flags) {
+  unsigned short type;
+
+  memset(tb, 0, sizeof(struct rtattr *) * (max + 1));
+  while (RTA_OK(rta, len)) {
+    type = rta->rta_type & ~flags;
+    if (type <= max) tb[type] = rta;
+    rta = RTA_NEXT(rta, len);
+  }
 }
 
-int nl_process_state(interface_t * interface)
-{
-    nl_data_t * data = (nl_data_t*)interface->data;
-    int rc;
-
-    switch(data->state) {
-        case NL_STATE_UNDEFINED:
-        {
-            DEBUG("[nl_process_state] UNDEFINED->LINK_SENT");
-            struct {
-                struct nlmsghdr  header;
-                struct rtgenmsg payload;
-            } msg2 = {
-                .header = {
-                    .nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
-                    .nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
-                    .nlmsg_type = RTM_GETLINK,
-                    .nlmsg_pid = getpid(),
-                    .nlmsg_seq = 3,
-                },
+int nl_process_state(interface_t *interface) {
+  nl_data_t *data = (nl_data_t *)interface->data;
+  int rc;
+
+  switch (data->state) {
+    case NL_STATE_UNDEFINED: {
+      DEBUG("[nl_process_state] UNDEFINED->LINK_SENT");
+      struct {
+        struct nlmsghdr header;
+        struct rtgenmsg payload;
+      } msg2 = {.header =
+                    {
+                        .nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
+                        .nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
+                        .nlmsg_type = RTM_GETLINK,
+                        .nlmsg_pid = getpid(),
+                        .nlmsg_seq = 3,
+                    },
                 .payload = {
                     .rtgen_family = AF_PACKET,
-                }
-            };
-
-            rc = send(data->fd, &msg2, msg2.header.nlmsg_len, 0);
-            if (rc < 0)
-                printf("E: Error sending netlink query\n");
+                }};
 
-            data->state = NL_STATE_LINK_SENT;
-            break;
-        }
-
-        case NL_STATE_LINK_SENT:
-        {
-            DEBUG("[nl_process_state] LINK_SENT->ADDR_SENT");
-            /* Issue a first query to receive static state */
-            struct {
-                struct nlmsghdr  header;
-                struct ifaddrmsg payload;
-            } msg = {
-                .header = {
-                    .nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg)),
-                    .nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
-                    .nlmsg_type = RTM_GETADDR,
-                    .nlmsg_pid = getpid(),
-                    .nlmsg_seq = 7,
-                },
-                .payload = {
-                    .ifa_family = AF_INET,
-                }
-            };
+      rc = send(data->fd, &msg2, msg2.header.nlmsg_len, 0);
+      if (rc < 0) printf("E: Error sending netlink query\n");
 
-            rc = send(data->fd, &msg, msg.header.nlmsg_len, 0);
-            if (rc < 0)
-                printf("E: Error sending netlink query\n");
-
-            data->state = NL_STATE_ADDR_SENT;
-            break;
-        }
+      data->state = NL_STATE_LINK_SENT;
+      break;
+    }
 
-        case NL_STATE_ADDR_SENT:
-        {
-            DEBUG("[nl_process_state] ADDR_SENT->DONE");
-            data->state = NL_STATE_DONE;
-            break;
-        }
+    case NL_STATE_LINK_SENT: {
+      DEBUG("[nl_process_state] LINK_SENT->ADDR_SENT");
+      /* Issue a first query to receive static state */
+      struct {
+        struct nlmsghdr header;
+        struct ifaddrmsg payload;
+      } msg = {.header =
+                   {
+                       .nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg)),
+                       .nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
+                       .nlmsg_type = RTM_GETADDR,
+                       .nlmsg_pid = getpid(),
+                       .nlmsg_seq = 7,
+                   },
+               .payload = {
+                   .ifa_family = AF_INET,
+               }};
+
+      rc = send(data->fd, &msg, msg.header.nlmsg_len, 0);
+      if (rc < 0) printf("E: Error sending netlink query\n");
+
+      data->state = NL_STATE_ADDR_SENT;
+      break;
+    }
 
-        default: /* NL_STATE_DONE never called */
-            break;
+    case NL_STATE_ADDR_SENT: {
+      DEBUG("[nl_process_state] ADDR_SENT->DONE");
+      data->state = NL_STATE_DONE;
+      break;
     }
 
-    return 0;
+    default: /* NL_STATE_DONE never called */
+      break;
+  }
+
+  return 0;
 }
 
-int nl_initialize(interface_t * interface, void * cfg)
-{
-    nl_data_t * data = malloc(sizeof(nl_data_t));
-    if (!data)
-        goto ERR_MALLOC;
+int nl_initialize(interface_t *interface, void *cfg) {
+  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) {
-        ERROR("[nl_initialize] Failed to create netlink socket: %s", (char*)strerror(errno));
-        goto ERR_SOCKET;
-    }
+  data->fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
+  if (data->fd < 0) {
+    ERROR("[nl_initialize] Failed to create netlink socket: %s",
+          (char *)strerror(errno));
+    goto ERR_SOCKET;
+  }
 
-    data->state = NL_STATE_UNDEFINED;
+  data->state = NL_STATE_UNDEFINED;
 
-    struct sockaddr_nl  local;  // local addr struct
-    memset(&local, 0, sizeof(local));
-    local.nl_family = AF_NETLINK;       // set protocol family
-    // NOTE: RTNLGRP_LINK replaces obsolete RTMGRP_LINK, etc
-    local.nl_groups = 0
-        | RTMGRP_LINK
-        | RTMGRP_IPV4_IFADDR
-        | RTMGRP_IPV6_IFADDR
+  struct sockaddr_nl local;  // local addr struct
+  memset(&local, 0, sizeof(local));
+  local.nl_family = AF_NETLINK;  // set protocol family
+  // NOTE: RTNLGRP_LINK replaces obsolete RTMGRP_LINK, etc
+  local.nl_groups = 0 | RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR
 #if 0
         | RTMGRP_IPV4_ROUTE;
         | RTMGRP_IPV6_ROUTE;
 #endif
-        ;
-    local.nl_pid = getpid();    // set out id using current process id
+      ;
+  local.nl_pid = getpid();  // set out id using current process id
 
-    if (bind(data->fd, (struct sockaddr*)&local, sizeof(local)) < 0) {     // bind socket
-        ERROR("[nl_initialize] Failed to bind netlink socket: %s", (char*)strerror(errno));
-        goto ERR_BIND;
-    }
+  if (bind(data->fd, (struct sockaddr *)&local, sizeof(local)) <
+      0) {  // bind socket
+    ERROR("[nl_initialize] Failed to bind netlink socket: %s",
+          (char *)strerror(errno));
+    goto ERR_BIND;
+  }
 
-    interface->data = data;
+  interface->data = data;
 
-    if (interface_register_fd(interface, data->fd, NULL) < 0) {
-        ERROR("[nl_initialize] Error registering fd");
-        goto ERR_FD;
-    }
+  if (interface_register_fd(interface, data->fd, NULL) < 0) {
+    ERROR("[nl_initialize] Error registering fd");
+    goto ERR_FD;
+  }
 
 #if 1
-    nl_process_state(interface);
+  nl_process_state(interface);
 #endif
 
-    return 0;
+  return 0;
 
 ERR_FD:
 ERR_BIND:
-    close(data->fd);
+  close(data->fd);
 ERR_SOCKET:
-    free(data);
+  free(data);
 ERR_MALLOC:
-    return -1;
+  return -1;
 }
 
-int parse_link(struct nlmsghdr * h, facelet_t ** facelet,
-        char * interface_name, size_t interface_name_size,
-        bool * up, bool * running)
-{
-    struct ifinfomsg *ifi;  // structure for network interface info
-    struct rtattr *tb[IFLA_MAX + 1];
+int parse_link(struct nlmsghdr *h, facelet_t **facelet, char *interface_name,
+               size_t interface_name_size, bool *up, bool *running) {
+  struct ifinfomsg *ifi;  // structure for network interface info
+  struct rtattr *tb[IFLA_MAX + 1];
 
-    assert(facelet);
+  assert(facelet);
 
-    ifi = (struct ifinfomsg*) NLMSG_DATA(h);    // get information about changed network interface
-    parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), IFLA_PAYLOAD(h), 1<<15);
+  ifi = (struct ifinfomsg *)NLMSG_DATA(
+      h);  // get information about changed network interface
+  parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), IFLA_PAYLOAD(h), 1 << 15);
 
-    if (interface_name) {
-        assert(tb[IFLA_IFNAME]);
-        snprintf(interface_name, interface_name_size, "%s", (char*)RTA_DATA(tb[IFLA_IFNAME]));
-    }
+  if (interface_name) {
+    assert(tb[IFLA_IFNAME]);
+    snprintf(interface_name, interface_name_size, "%s",
+             (char *)RTA_DATA(tb[IFLA_IFNAME]));
+  }
 
-    if (up)
-        *up = ifi->ifi_flags & IFF_UP;
-    if (running)
-        *running = ifi->ifi_flags & IFF_RUNNING;
+  if (up) *up = ifi->ifi_flags & IFF_UP;
+  if (running) *running = ifi->ifi_flags & IFF_RUNNING;
 
+  netdevice_t *netdevice = netdevice_create_from_name(interface_name);
+  if (!netdevice) {
+    ERROR("[netlink.parse_link] error creating netdevice '%s'", interface_name);
+    goto ERR_ND;
+  }
 
-    netdevice_t * netdevice = netdevice_create_from_name(interface_name);
-    if (!netdevice) {
-        ERROR("[netlink.parse_link] error creating netdevice '%s'", interface_name);
-        goto ERR_ND;
-    }
+  *facelet = facelet_create();
+  if (!*facelet) {
+    ERROR("[netlink.parse_link] error creating facelet");
+    goto ERR_FACELET;
+  }
 
-    *facelet = facelet_create();
-    if (!*facelet) {
-        ERROR("[netlink.parse_link] error creating facelet");
-        goto ERR_FACELET;
-    }
-
-    if (facelet_set_netdevice(*facelet, *netdevice) < 0) {
-        ERROR("[netlink.parse_link] error setting netdevice");
-        goto ERR;
-    }
+  if (facelet_set_netdevice(*facelet, *netdevice) < 0) {
+    ERROR("[netlink.parse_link] error setting netdevice");
+    goto ERR;
+  }
 
 // FIXME Tags
 #if 0
@@ -252,160 +238,162 @@ int parse_link(struct nlmsghdr * h, facelet_t ** facelet,
 
 #endif
 
-    // TODO
-    //  - ifi_change
-    //  - IFLA_PROTINFO
+  // TODO
+  //  - ifi_change
+  //  - IFLA_PROTINFO
 
-    netdevice_free(netdevice);
-    return 0;
+  netdevice_free(netdevice);
+  return 0;
 
 ERR:
-    facelet_free(*facelet);
-    *facelet = NULL;
+  facelet_free(*facelet);
+  *facelet = NULL;
 ERR_FACELET:
-    netdevice_free(netdevice);
+  netdevice_free(netdevice);
 ERR_ND:
-    return -1;
+  return -1;
 }
 
-int parse_addr(struct nlmsghdr * h, facelet_t ** facelet,
-        char * interface_name, size_t interface_name_size,
-        char * interface_address, size_t interface_address_size)
-{
-    ip_address_t local_addr = IP_ADDRESS_EMPTY;
-    struct ifaddrmsg *ifa; // structure for network interface data
-    struct rtattr *tba[IFA_MAX+1];
-
-    assert(facelet);
-
-    ifa = (struct ifaddrmsg*)NLMSG_DATA(h); // get data from the network interface
-
-    parse_rtattr(tba, IFA_MAX, IFA_RTA(ifa), IFA_PAYLOAD(h), 0);
-
-    /* FIXME
-     *
-     * IFA_LOCAL ok for v4, not there for v6
-     *
-     * IFA_ADDRESS seems to work for both but with the following precaution
-     *
-     * IFA_ADDRESS is prefix address, rather than local interface address.
-     * It makes no difference for normally configured broadcast interfaces,
-     * but for point-to-point IFA_ADDRESS is DESTINATION address,
-     * local address is supplied in IFA_LOCAL attribute.
-     */
-    if (!tba[IFA_ADDRESS]) {
-        ERROR("[netlink.parse_addr] No local address");
-        return -1;
-    }
-
-    switch(ifa->ifa_family) {
-        case AF_INET:
-            local_addr.v4.as_inaddr = *(struct in_addr*)RTA_DATA(tba[IFA_ADDRESS]);
-            break;
-        case AF_INET6:
-            local_addr.v6.as_in6addr = *(struct in6_addr*)RTA_DATA(tba[IFA_ADDRESS]);
-            break;
-        default:
-            return 0;
-    }
-
-    /* See comment in parse_link */
-    if (interface_address) {
-        assert(tba[IFA_ADDRESS]);
-        ip_address_snprintf(interface_address, interface_address_size, &local_addr, ifa->ifa_family);
-    }
-
-    netdevice_t * netdevice = netdevice_create_from_index(ifa->ifa_index);
-    if (!netdevice) {
-        ERROR("[netlink.parse_addr] error creating netdevice from index '%d'", ifa->ifa_index);
-        goto ERR_ND;
-    }
-
-    if (interface_name) {
-        snprintf(interface_name, interface_name_size, "%s", netdevice->name);
-    }
-
-    *facelet = facelet_create();
-    if (!*facelet) {
-        ERROR("[netlink.parse_addr] error creating facelet");
-        goto ERR_FACELET;
-    }
-    if (facelet_set_netdevice(*facelet, *netdevice) < 0) {
-        ERROR("[netlink.parse_addr] error setting netdevice");
-        goto ERR;
-    }
-    if (facelet_set_family(*facelet, ifa->ifa_family) < 0) {
-        ERROR("[netlink.parse_addr] error setting family");
-        goto ERR;
-    }
-    if (facelet_set_local_addr(*facelet, local_addr) < 0) {
-        ERROR("[netlink.parse_addr] error setting local address");
-        goto ERR;
-    }
-
-    netdevice_free(netdevice);
-    return 0;
+int parse_addr(struct nlmsghdr *h, facelet_t **facelet, char *interface_name,
+               size_t interface_name_size, char *interface_address,
+               size_t interface_address_size) {
+  ip_address_t local_addr = IP_ADDRESS_EMPTY;
+  struct ifaddrmsg *ifa;  // structure for network interface data
+  struct rtattr *tba[IFA_MAX + 1];
+
+  assert(facelet);
+
+  ifa =
+      (struct ifaddrmsg *)NLMSG_DATA(h);  // get data from the network interface
+
+  parse_rtattr(tba, IFA_MAX, IFA_RTA(ifa), IFA_PAYLOAD(h), 0);
+
+  /* FIXME
+   *
+   * IFA_LOCAL ok for v4, not there for v6
+   *
+   * IFA_ADDRESS seems to work for both but with the following precaution
+   *
+   * IFA_ADDRESS is prefix address, rather than local interface address.
+   * It makes no difference for normally configured broadcast interfaces,
+   * but for point-to-point IFA_ADDRESS is DESTINATION address,
+   * local address is supplied in IFA_LOCAL attribute.
+   */
+  if (!tba[IFA_ADDRESS]) {
+    ERROR("[netlink.parse_addr] No local address");
+    return -1;
+  }
+
+  switch (ifa->ifa_family) {
+    case AF_INET:
+      local_addr.v4.as_inaddr = *(struct in_addr *)RTA_DATA(tba[IFA_ADDRESS]);
+      break;
+    case AF_INET6:
+      local_addr.v6.as_in6addr = *(struct in6_addr *)RTA_DATA(tba[IFA_ADDRESS]);
+      break;
+    default:
+      return 0;
+  }
+
+  /* See comment in parse_link */
+  if (interface_address) {
+    assert(tba[IFA_ADDRESS]);
+    ip_address_snprintf(interface_address, interface_address_size, &local_addr,
+                        ifa->ifa_family);
+  }
+
+  netdevice_t *netdevice = netdevice_create_from_index(ifa->ifa_index);
+  if (!netdevice) {
+    ERROR("[netlink.parse_addr] error creating netdevice from index '%d'",
+          ifa->ifa_index);
+    goto ERR_ND;
+  }
+
+  if (interface_name) {
+    snprintf(interface_name, interface_name_size, "%s", netdevice->name);
+  }
+
+  *facelet = facelet_create();
+  if (!*facelet) {
+    ERROR("[netlink.parse_addr] error creating facelet");
+    goto ERR_FACELET;
+  }
+  if (facelet_set_netdevice(*facelet, *netdevice) < 0) {
+    ERROR("[netlink.parse_addr] error setting netdevice");
+    goto ERR;
+  }
+  if (facelet_set_family(*facelet, ifa->ifa_family) < 0) {
+    ERROR("[netlink.parse_addr] error setting family");
+    goto ERR;
+  }
+  if (facelet_set_local_addr(*facelet, local_addr) < 0) {
+    ERROR("[netlink.parse_addr] error setting local address");
+    goto ERR;
+  }
+
+  netdevice_free(netdevice);
+  return 0;
 
 ERR:
-    facelet_free(*facelet);
-    *facelet = NULL;
+  facelet_free(*facelet);
+  *facelet = NULL;
 ERR_FACELET:
-    netdevice_free(netdevice);
+  netdevice_free(netdevice);
 ERR_ND:
-    return -1;
+  return -1;
 }
 
-int nl_callback(interface_t * interface, int fd, void * unused)
-{
-    nl_data_t * data = (nl_data_t*)interface->data;
+int nl_callback(interface_t *interface, int fd, void *unused) {
+  nl_data_t *data = (nl_data_t *)interface->data;
 
-    struct sockaddr_nl  local;  // local addr struct
-    memset(&local, 0, sizeof(local));
+  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
+  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_name = &local,                  // local address
-        .msg_namelen = sizeof(local),        // address size
-        .msg_iov = &iov,                     // io vector
-        .msg_iovlen = 1,                     // io size
-    };
+  // initialize protocol message header
+  struct msghdr msg = {
+      .msg_name = &local,            // local address
+      .msg_namelen = sizeof(local),  // address size
+      .msg_iov = &iov,               // io vector
+      .msg_iovlen = 1,               // io size
+  };
 
-    ssize_t status = recvmsg(data->fd, &msg, 0);
+  ssize_t status = recvmsg(data->fd, &msg, 0);
 
-    //  check status
-    if (status < 0) {
-/*
-        if (errno == EINTR || errno == EAGAIN)
-            continue;
-*/
+  //  check status
+  if (status < 0) {
+    /*
+            if (errno == EINTR || errno == EAGAIN)
+                continue;
+    */
 
-        printf("Failed to read netlink: %s", (char*)strerror(errno));
-        return -1;
-    }
+    printf("Failed to read netlink: %s", (char *)strerror(errno));
+    return -1;
+  }
 
-    if (msg.msg_namelen != sizeof(local)) { // check message length, just in case
-        printf("Invalid length of the sender address struct\n");
-        return -1;
-    }
+  if (msg.msg_namelen != sizeof(local)) {  // check message length, just in case
+    printf("Invalid length of the sender address struct\n");
+    return -1;
+  }
 
-    // message parser
-    struct nlmsghdr *h;
+  // 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);
+  for (h = (struct nlmsghdr *)buf;
+       status >= (ssize_t)sizeof(*h);) {  // read all messagess headers
+    int len = h->nlmsg_len;
+    int l = len - sizeof(*h);
 
-        if ((l < 0) || (len > status)) {
-            printf("Invalid message length: %i\n", len);
-            continue;
-        }
+    if ((l < 0) || (len > status)) {
+      printf("Invalid message length: %i\n", len);
+      continue;
+    }
 
-        switch(h->nlmsg_type) {
+    switch (h->nlmsg_type) {
 #if 0
             case RTM_NEWROUTE:
             case RTM_DELROUTE:
@@ -413,147 +401,123 @@ int nl_callback(interface_t * interface, int fd, void * unused)
                 break;
 #endif
 
-            case RTM_DELADDR:
-            {
-                facelet_t * facelet = NULL;
-                char interface_name[IFNAMSIZ];
-                char interface_address[MAXSZ_IP_ADDRESS] = {0};
-
-                if (parse_addr(h, &facelet, interface_name, IFNAMSIZ,
-                            interface_address, MAXSZ_IP_ADDRESS) < 0) {
-                    ERROR("Error parsing address message");
-                    break;
-                }
-
-                DEBUG("[NETLINK] Interface %s: address was removed", interface_name);
-                if (facelet) {
-                    facelet_set_event(facelet, FACELET_EVENT_SET_DOWN);
-                    facelet_set_attr_clean(facelet);
-                    interface_raise_event(interface, facelet);
-                }
-                break;
-            }
-
-            case RTM_NEWADDR:
-            {
-                facelet_t * facelet = NULL;
-                char interface_name[IFNAMSIZ];
-                char interface_address[MAXSZ_IP_ADDRESS] = {0};
-
-                if (parse_addr(h, &facelet, interface_name, IFNAMSIZ,
-                            interface_address, MAXSZ_IP_ADDRESS) < 0) {
-                    ERROR("Error parsing address message");
-                    break;
-                }
-
-                DEBUG("[NETLINK] Interface %s: new address was assigned: %s", interface_name, interface_address);
-
-                if (facelet) {
-                    facelet_set_event(facelet, FACELET_EVENT_UPDATE);
-                    facelet_set_attr_clean(facelet);
-                    interface_raise_event(interface, facelet);
-                }
-                break;
-            }
+      case RTM_DELADDR: {
+        facelet_t *facelet = NULL;
+        char interface_name[IFNAMSIZ];
+        char interface_address[MAXSZ_IP_ADDRESS] = {0};
 
-            case RTM_DELLINK:
-            {
-                /* This does not always seem to be called, hence we rely on
-                 * down, not running */
-                facelet_t * facelet = NULL;
-                char interface_name[IFNAMSIZ];
-                if (parse_link(h, &facelet, interface_name, IFNAMSIZ,
-                            NULL, NULL) < 0) {
-                    ERROR("Error parsing link message");
-                    break;
-                }
+        if (parse_addr(h, &facelet, interface_name, IFNAMSIZ, interface_address,
+                       MAXSZ_IP_ADDRESS) < 0) {
+          ERROR("Error parsing address message");
+          break;
+        }
 
-                DEBUG("[NETLINK] Network interface %s was removed", interface_name);
+        DEBUG("[NETLINK] Interface %s: address was removed", interface_name);
+        if (facelet) {
+          facelet_set_event(facelet, FACELET_EVENT_SET_DOWN);
+          facelet_set_attr_clean(facelet);
+          interface_raise_event(interface, facelet);
+        }
+        break;
+      }
+
+      case RTM_NEWADDR: {
+        facelet_t *facelet = NULL;
+        char interface_name[IFNAMSIZ];
+        char interface_address[MAXSZ_IP_ADDRESS] = {0};
+
+        if (parse_addr(h, &facelet, interface_name, IFNAMSIZ, interface_address,
+                       MAXSZ_IP_ADDRESS) < 0) {
+          ERROR("Error parsing address message");
+          break;
+        }
 
-                if (!facelet)
-                    break;
+        DEBUG("[NETLINK] Interface %s: new address was assigned: %s",
+              interface_name, interface_address);
 
-                facelet_set_event(facelet, FACELET_EVENT_DELETE);
-                facelet_set_attr_clean(facelet);
-                interface_raise_event(interface, facelet);
+        if (facelet) {
+          facelet_set_event(facelet, FACELET_EVENT_UPDATE);
+          facelet_set_attr_clean(facelet);
+          interface_raise_event(interface, facelet);
+        }
+        break;
+      }
+
+      case RTM_DELLINK: {
+        /* This does not always seem to be called, hence we rely on
+         * down, not running */
+        facelet_t *facelet = NULL;
+        char interface_name[IFNAMSIZ];
+        if (parse_link(h, &facelet, interface_name, IFNAMSIZ, NULL, NULL) < 0) {
+          ERROR("Error parsing link message");
+          break;
+        }
 
-                break;
-            }
-
-            case RTM_NEWLINK:
-            {
-                facelet_t * facelet = NULL;
-                char interface_name[IFNAMSIZ];
-                bool up, running;
-
-                if (parse_link(h, &facelet, interface_name, IFNAMSIZ, &up, &running) < 0) {
-                    ERROR("Error parsing link message");
-                    break;
-                }
-
-                // UP RUNNING
-                // UP NOT RUNNING
-                // DOWN NOT RUNNING
-#if 1
-                DEBUG("[NETLINK] New network interface %s, state: %s %s", interface_name,
-                        up ? "UP" : "DOWN",
-                        running ? "RUNNING" : "NOT_RUNNING");
-#endif
+        DEBUG("[NETLINK] Network interface %s was removed", interface_name);
 
-                if (!facelet)
-                    break;
-                if (up && running) {
-                    facelet_set_event(facelet, FACELET_EVENT_CREATE);
-                    //facelet_set_family(facelet, AF_INET);
-                    facelet_set_attr_clean(facelet);
-                    interface_raise_event(interface, facelet);
+        if (!facelet) break;
 
-#if 0
-                    facelet_t * facelet6 = facelet_dup(facelet);
-                    if (!facelet6) {
-                        ERROR("Could not duplicate face for v6");
-                        break;
-                    }
-                    facelet_set_family(facelet6, AF_INET6);
-                    interface_raise_event(interface, facelet6);
-#endif
-//                } else {
-//#if 1
-//                    facelet_set_event(facelet, FACELET_EVENT_SET_DOWN);
-//                    facelet_set_attr_clean(facelet);
-//                    interface_raise_event(interface, facelet);
-//#else
-//                    facelet_free(facelet);
-//#endif
-                }
-                break;
-            }
+        facelet_set_event(facelet, FACELET_EVENT_DELETE);
+        facelet_set_attr_clean(facelet);
+        interface_raise_event(interface, facelet);
 
-            case NLMSG_ERROR:
-                break;
-            case NLMSG_DONE:
-                nl_process_state(interface);
-                break;
-            default:
-                break;
+        break;
+      }
+
+      case RTM_NEWLINK: {
+        facelet_t *facelet = NULL;
+        char interface_name[IFNAMSIZ];
+        bool up, running;
 
+        if (parse_link(h, &facelet, interface_name, IFNAMSIZ, &up, &running) <
+            0) {
+          ERROR("Error parsing link message");
+          break;
         }
 
-        status -= NLMSG_ALIGN(len); // align offsets by the message length, this is important
+        // UP RUNNING
+        // UP NOT RUNNING
+        // DOWN NOT RUNNING
+#if 1
+        DEBUG("[NETLINK] New network interface %s, state: %s %s",
+              interface_name, up ? "UP" : "DOWN",
+              running ? "RUNNING" : "NOT_RUNNING");
+#endif
 
-        h = (struct nlmsghdr*)((char*)h + NLMSG_ALIGN(len));    // get next message
+        if (!facelet) break;
+        if (up && running) {
+          facelet_set_event(facelet, FACELET_EVENT_CREATE);
+          facelet_set_attr_clean(facelet);
+          interface_raise_event(interface, facelet);
+        } else {
+          facelet_free(facelet);
+        }
+        break;
+      }
+
+      case NLMSG_ERROR:
+        break;
+      case NLMSG_DONE:
+        nl_process_state(interface);
+        break;
+      default:
+        break;
     }
 
-    return 0;
-}
+    status -= NLMSG_ALIGN(
+        len);  // align offsets by the message length, this is important
 
-int nl_finalize(interface_t * interface)
-{
-    nl_data_t * data = (nl_data_t*)interface->data;
-    close(data->fd);
-    free(interface->data);
-    return 0;
+    h = (struct nlmsghdr *)((char *)h + NLMSG_ALIGN(len));  // get next message
+  }
+
+  return 0;
+}
 
+int nl_finalize(interface_t *interface) {
+  nl_data_t *data = (nl_data_t *)interface->data;
+  close(data->fd);
+  free(interface->data);
+  return 0;
 }
 
 const interface_ops_t netlink_ops = {
diff --git a/ctrl/facemgr/src/interfaces/network_framework/CMakeLists.txt b/ctrl/facemgr/src/interfaces/network_framework/CMakeLists.txt
index e8b0144b1..db96e390f 100644
--- a/ctrl/facemgr/src/interfaces/network_framework/CMakeLists.txt
+++ b/ctrl/facemgr/src/interfaces/network_framework/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/ctrl/facemgr/src/interfaces/network_framework/network_framework.c b/ctrl/facemgr/src/interfaces/network_framework/network_framework.c
index 2c4bff513..3adba0969 100644
--- a/ctrl/facemgr/src/interfaces/network_framework/network_framework.c
+++ b/ctrl/facemgr/src/interfaces/network_framework/network_framework.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -32,7 +32,7 @@
 #include <hicn/util/map.h>
 
 #include "../../common.h"
-#include <hicn/ctrl/face.h>
+#include <hicn/face.h>
 #include "../../interface.h"
 
 #include "network_framework.h"
@@ -41,7 +41,6 @@
 #error "Network frameork requires MacOSX 10.14+"
 #endif /* !defined(MAC_OS_X_VERSION_10_14) */
 
-
 /*
  * Bonjour service discovery for hICN forwarder
  *
@@ -70,144 +69,147 @@
 /* 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 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,
+  INTERFACE_TYPE_OTHER,
+  INTERFACE_TYPE_WIFI,
+  INTERFACE_TYPE_CELLULAR,
+  INTERFACE_TYPE_WIRED,
+  INTERFACE_TYPE_LOOPBACK,
 } _nw_interface_type_t;
 
-const char * interface_type_str[] = {
+const char *interface_type_str[] = {
     "OTHER", "WIFI", "CELLULAR", "WIRED", "LOOPBACK",
 };
 
 #if 1
 typedef enum {
-    PATH_STATUS_INVALID,
-    PATH_STATUS_SATISTIED,
-    PATH_STATUS_UNSATISFIED,
-    PATH_STATUS_SATISFIABLE,
+  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 *path_status_str[] = {
+    "INVALID",
+    "SATISFIED",
+    "UNSATISFIED",
+    "SATISFIABLE",
 };
 
-const char * endpoint_type_str[] = {
-    "INVALID", "ADDRESS", "HOST", "BONJOUR",
+const char *endpoint_type_str[] = {
+    "INVALID",
+    "ADDRESS",
+    "HOST",
+    "BONJOUR",
 };
 
-const char * connection_state_str[] = {
+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));
+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_MAP(map_cnx, nw_interface_t, nw_connection_t, cmp_iface);
 
 typedef struct {
-    network_framework_cfg_t cfg;
-    nw_path_monitor_t pm; /**< Main path monitor */
-//    map_cnx_t map_cnx;    /**< Map: interface -> connection for face status */
+  network_framework_cfg_t cfg;
+  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);
+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]);
+  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;
-        }
+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)
-{
+  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, "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_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);
+    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);
+    dump_endpoint(remote, indent + 1);
     nw_release(remote);
-}
+  }
 
-void
-dump_connection(nw_connection_t connection, int indent)
-{
+  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);
+    dump_endpoint(remote, indent + 1);
     printfi(indent, "Path:\n");
-    dump_path(path, indent+1);
+    dump_path(path, indent + 1);
 
     /*
     nw_connection_copy_protocol_metadata();
@@ -216,34 +218,34 @@ dump_connection(nw_connection_t connection, int indent)
 
     nw_release(remote);
     nw_release(path);
-}
+  }
 
 #if defined(MAC_OS_X_VERSION_10_15)
-void
-dump_browse_result(nw_browse_result_t result, int indent)
-{
+  void dump_browse_result(nw_browse_result_t result, int indent) {
     /* Endpoint */
     nw_endpoint_t browse_endpoint = nw_browse_result_copy_endpoint(result);
     if (!browse_endpoint) {
-        ERROR("[network_framework.dump_result] Failed to retrieve endpoint from Bonjour browse result");
-        return;
+      ERROR(
+          "[network_framework.dump_result] Failed to retrieve endpoint from "
+          "Bonjour browse result");
+      return;
     }
     printfi(indent + 1, "Endpoint:");
     dump_endpoint(browse_endpoint, indent + 2);
 
     /* Interfaces */
     printfi(indent + 1, "Interfaces:");
-    nw_browse_result_enumerate_interfaces(result, (nw_browse_result_enumerate_interface_t) ^(nw_interface_t interface) {
-        dump_interface(interface, indent + 2);
-        return true;
-    });
-}
+    nw_browse_result_enumerate_interfaces(
+        result,
+        (nw_browse_result_enumerate_interface_t) ^ (nw_interface_t interface) {
+          dump_interface(interface, indent + 2);
+          return true;
+        });
+  }
 #endif /* defined(MAC_OS_X_VERSION_10_15) */
 
-facelet_t *
-facelet_create_from_connection(nw_connection_t connection)
-{
-    facelet_t * facelet;
+  facelet_t *facelet_create_from_connection(nw_connection_t connection) {
+    facelet_t *facelet;
     ip_address_t local_addr, remote_addr;
     uint16_t remote_port;
 
@@ -252,34 +254,36 @@ facelet_create_from_connection(nw_connection_t connection)
     nw_endpoint_t remote = nw_path_copy_effective_remote_endpoint(path);
     __block nw_interface_t interface;
 
-    const struct sockaddr * local_sa = nw_endpoint_get_address(local);
-    const struct sockaddr * remote_sa = nw_endpoint_get_address(remote);
-
-    assert (local_sa->sa_family == remote_sa->sa_family);
-    switch(local_sa->sa_family) {
-        case AF_INET:
-            local_addr.v4.as_inaddr = ((struct sockaddr_in *)local_sa)->sin_addr;
-            remote_addr.v4.as_inaddr = ((struct sockaddr_in *)remote_sa)->sin_addr;
-            remote_port = ((struct sockaddr_in *)remote_sa)->sin_port;
-            break;
-        case AF_INET6:
-            local_addr.v6.as_in6addr = ((struct sockaddr_in6 *)local_sa)->sin6_addr;
-            remote_addr.v6.as_in6addr = ((struct sockaddr_in6 *)remote_sa)->sin6_addr;
-            remote_port = ((struct sockaddr_in6 *)remote_sa)->sin6_port;
-            break;
-        default:
-            ERROR("Unsupported address family: %d\n", local_sa->sa_family);
-            return NULL;
+    const struct sockaddr *local_sa = nw_endpoint_get_address(local);
+    const struct sockaddr *remote_sa = nw_endpoint_get_address(remote);
+
+    assert(local_sa->sa_family == remote_sa->sa_family);
+    switch (local_sa->sa_family) {
+      case AF_INET:
+        local_addr.v4.as_inaddr = ((struct sockaddr_in *)local_sa)->sin_addr;
+        remote_addr.v4.as_inaddr = ((struct sockaddr_in *)remote_sa)->sin_addr;
+        remote_port = ((struct sockaddr_in *)remote_sa)->sin_port;
+        break;
+      case AF_INET6:
+        local_addr.v6.as_in6addr = ((struct sockaddr_in6 *)local_sa)->sin6_addr;
+        remote_addr.v6.as_in6addr =
+            ((struct sockaddr_in6 *)remote_sa)->sin6_addr;
+        remote_port = ((struct sockaddr_in6 *)remote_sa)->sin6_port;
+        break;
+      default:
+        ERROR("Unsupported address family: %d\n", local_sa->sa_family);
+        return NULL;
     }
 
-
     /* Retrieving path interface type (a single one expected */
-    nw_path_enumerate_interfaces(path, (nw_path_enumerate_interfaces_block_t)^(nw_interface_t path_interface) {
-        interface = path_interface;
-        return false;
-    });
-
-    const char * name = nw_interface_get_name(interface);
+    nw_path_enumerate_interfaces(
+        path, (nw_path_enumerate_interfaces_block_t) ^
+                  (nw_interface_t path_interface) {
+                    interface = path_interface;
+                    return false;
+                  });
+
+    const char *name = nw_interface_get_name(interface);
     netdevice_t netdevice;
     snprintf(netdevice.name, IFNAMSIZ, "%s", name);
     netdevice_update_index(&netdevice);
@@ -287,25 +291,24 @@ facelet_create_from_connection(nw_connection_t connection)
     netdevice_type_t netdevice_type;
     nw_interface_type_t type = nw_interface_get_type(interface);
 
-    switch(type) {
-        case INTERFACE_TYPE_OTHER:
-            netdevice_type = NETDEVICE_TYPE_UNDEFINED;
-            break;
-        case INTERFACE_TYPE_WIFI:
-            netdevice_type = NETDEVICE_TYPE_WIFI;
-            break;
-        case INTERFACE_TYPE_CELLULAR:
-            netdevice_type = NETDEVICE_TYPE_CELLULAR;
-            break;
-        case INTERFACE_TYPE_WIRED:
-            netdevice_type = NETDEVICE_TYPE_WIRED;
-            break;
-        case INTERFACE_TYPE_LOOPBACK:
-            netdevice_type = NETDEVICE_TYPE_LOOPBACK;
-            break;
-        default:
-            break;
-
+    switch (type) {
+      case INTERFACE_TYPE_OTHER:
+        netdevice_type = NETDEVICE_TYPE_UNDEFINED;
+        break;
+      case INTERFACE_TYPE_WIFI:
+        netdevice_type = NETDEVICE_TYPE_WIFI;
+        break;
+      case INTERFACE_TYPE_CELLULAR:
+        netdevice_type = NETDEVICE_TYPE_CELLULAR;
+        break;
+      case INTERFACE_TYPE_WIRED:
+        netdevice_type = NETDEVICE_TYPE_WIRED;
+        break;
+      case INTERFACE_TYPE_LOOPBACK:
+        netdevice_type = NETDEVICE_TYPE_LOOPBACK;
+        break;
+      default:
+        break;
     }
 
     nw_release(local);
@@ -313,8 +316,7 @@ facelet_create_from_connection(nw_connection_t connection)
     nw_release(path);
 
     facelet = facelet_create();
-    if (!facelet)
-        return NULL;
+    if (!facelet) return NULL;
 
     facelet_set_netdevice(facelet, netdevice);
     facelet_set_netdevice_type(facelet, netdevice_type);
@@ -324,20 +326,21 @@ facelet_create_from_connection(nw_connection_t connection)
     facelet_set_remote_port(facelet, remote_port);
 
     return facelet;
-}
+  }
 
-void
-on_connection_state_event(interface_t * interface, nw_interface_t iface,
-        nw_connection_t cnx, nw_connection_state_t state, nw_error_t error)
-{
+  void on_connection_state_event(
+      interface_t * interface, nw_interface_t iface, nw_connection_t cnx,
+      nw_connection_state_t state, nw_error_t error) {
 #if 1
     DEBUG("Connection [new state = %s]:\n", connection_state_str[state]);
     nw_path_t path = nw_connection_copy_current_path(cnx);
-    nw_path_enumerate_interfaces(path, (nw_path_enumerate_interfaces_block_t)^(nw_interface_t interface) {
-        const char * name = nw_interface_get_name(interface);
-        printf("NAME=%s\n", name);
-        return true;
-    });
+    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
@@ -346,84 +349,71 @@ on_connection_state_event(interface_t * interface, nw_interface_t iface,
     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:
-            {
-                printf("info:\n");
-                warn("connection ready");
+    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: {
+        printf("info:\n");
+        warn("connection ready");
 #if 1
-            WITH_DEBUG({
-                dump_connection(cnx, 1);
-            });
+        WITH_DEBUG({ dump_connection(cnx, 1); });
 #endif
-            facelet_t * facelet = facelet_create_from_connection(cnx);
-            if (!facelet)
-                return;
-            facelet_set_event(facelet, FACELET_EVENT_CREATE);
-            interface_raise_event(interface, facelet);
-            break;
-            }
-        case nw_connection_state_failed:
-            /* Can we fail with bonjour, or are we always waiting ? */
-            warn("connect to %s port %u (%s) failed",
-                    nw_endpoint_get_hostname(remote),
-                    nw_endpoint_get_port(remote),
-                    BONJOUR_PROTOCOL_NAME);
-            break;
-
-        case nw_connection_state_cancelled:
-            // Release the primary reference on the connection
-            // that was taken at creation time
-            nw_release(cnx);
-            break;
-
-        default: /* nw_connection_state_invalid */
-            /* Should never be called */
-            break;
-
+        facelet_t *facelet = facelet_create_from_connection(cnx);
+        if (!facelet) return;
+        facelet_set_event(facelet, FACELET_EVENT_CREATE);
+        interface_raise_event(interface, facelet);
+        break;
+      }
+      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)
-{
+  void on_connection_path_event(interface_t * interface, nw_interface_t iface,
+                                nw_connection_t cnx, nw_path_t path) {
 #if 1
     DEBUG("Connection [path changed]:\n");
-    WITH_DEBUG({
-        dump_connection(cnx, 1);
-    });
+    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)
-{
+    /* 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
@@ -452,11 +442,10 @@ void on_interface_event(interface_t * interface, nw_interface_t iface)
 
     /* nw_parameters_create_secure_{udp,tcp} */
     nw_parameters_t parameters = nw_parameters_create_fn(
-                NW_PARAMETERS_DISABLE_PROTOCOL, /* no (d)tls */
-                NW_PARAMETERS_DEFAULT_CONFIGURATION /* default udp/tcp */);
+        NW_PARAMETERS_DISABLE_PROTOCOL, /* no (d)tls */
+        NW_PARAMETERS_DEFAULT_CONFIGURATION /* default udp/tcp */);
 
-    if (!parameters)
-        goto ERR_PARAMETERS;
+    if (!parameters) goto ERR_PARAMETERS;
 
     nw_parameters_require_interface(parameters, iface);
     nw_parameters_set_reuse_local_address(parameters, true);
@@ -467,49 +456,60 @@ void on_interface_event(interface_t * interface, nw_interface_t iface)
      * available services on the local network using the parameters specified
      * before.
      */
-    nw_browse_descriptor_t descriptor = nw_browse_descriptor_create_bonjour_service(BONJOUR_SERVICE_TYPE, BONJOUR_SERVICE_DOMAIN);
+    nw_browse_descriptor_t descriptor =
+        nw_browse_descriptor_create_bonjour_service(BONJOUR_SERVICE_TYPE,
+                                                    BONJOUR_SERVICE_DOMAIN);
     if (!descriptor) {
-        ERROR("[network_framework.on_interface_event] Failed to create a bonjour browse descriptor");
-        goto ERR_DESCRIPTOR;
+      ERROR(
+          "[network_framework.on_interface_event] Failed to create a bonjour "
+          "browse descriptor");
+      goto ERR_DESCRIPTOR;
     }
 
     nw_browser_t browser = nw_browser_create(descriptor, parameters);
     nw_browser_set_queue(browser, dispatch_get_main_queue());
-    nw_browser_set_browse_results_changed_handler(browser, ^(nw_browse_result_t result, nw_browse_result_t result2, bool flag) {
-        /* Dump result */
-        printfi(0, "NEW BROWSE RESULT");
-        printfi(1, "Result:");
-        dump_browse_result(result, 2);
-        printfi(1, "Result2:");
-        dump_browse_result(result2, 2);
-        printfi(1, "Flag: %s\n", (flag?"ON":"OFF"));
-
-        /* Changes */
-        nw_browse_result_change_t change = nw_browse_result_get_changes(result, result2);
-        switch(change) {
-            case nw_browse_result_change_identical:
-                printfi(2, "The compared services are identical.");
-                break;
-            case nw_browse_result_change_result_added:
-                printfi(2, "A new service was discovered.");
-                break;
-
-            case nw_browse_result_change_result_removed:
-                printfi(2, "A previously discovered service was removed.");
-                break;
-
-            case nw_browse_result_change_txt_record_changed:
-                printfi(2, "The service's associated TXT record changed.");
-                break;
-
-            case nw_browse_result_change_interface_added:
-                printfi(2, "The service was discovered over a new interface.");
-                break;
-
-            case nw_browse_result_change_interface_removed:
-                printfi(2, "The service was no longer discovered over a certain interface.");
-                break;
-        }
+    nw_browser_set_browse_results_changed_handler(browser, ^(
+                                                      nw_browse_result_t result,
+                                                      nw_browse_result_t
+                                                          result2,
+                                                      bool flag) {
+      /* Dump result */
+      printfi(0, "NEW BROWSE RESULT");
+      printfi(1, "Result:");
+      dump_browse_result(result, 2);
+      printfi(1, "Result2:");
+      dump_browse_result(result2, 2);
+      printfi(1, "Flag: %s\n", (flag ? "ON" : "OFF"));
+
+      /* Changes */
+      nw_browse_result_change_t change =
+          nw_browse_result_get_changes(result, result2);
+      switch (change) {
+        case nw_browse_result_change_identical:
+          printfi(2, "The compared services are identical.");
+          break;
+        case nw_browse_result_change_result_added:
+          printfi(2, "A new service was discovered.");
+          break;
+
+        case nw_browse_result_change_result_removed:
+          printfi(2, "A previously discovered service was removed.");
+          break;
+
+        case nw_browse_result_change_txt_record_changed:
+          printfi(2, "The service's associated TXT record changed.");
+          break;
+
+        case nw_browse_result_change_interface_added:
+          printfi(2, "The service was discovered over a new interface.");
+          break;
+
+        case nw_browse_result_change_interface_removed:
+          printfi(
+              2,
+              "The service was no longer discovered over a certain interface.");
+          break;
+      }
     });
 
     nw_browser_start(browser);
@@ -524,20 +524,20 @@ void on_interface_event(interface_t * interface, nw_interface_t iface)
     nw_endpoint_t endpoint;
 
     DEBUG("Creating bonjour service towards NAME=%s TYPE=%s DOMAIN=%s",
-            BONJOUR_SERVICE_NAME, BONJOUR_SERVICE_TYPE, BONJOUR_SERVICE_DOMAIN);
+          BONJOUR_SERVICE_NAME, BONJOUR_SERVICE_TYPE, BONJOUR_SERVICE_DOMAIN);
     endpoint = nw_endpoint_create_bonjour_service(
-            BONJOUR_SERVICE_NAME,
-            BONJOUR_SERVICE_TYPE,
-            BONJOUR_SERVICE_DOMAIN);
+        BONJOUR_SERVICE_NAME, BONJOUR_SERVICE_TYPE, BONJOUR_SERVICE_DOMAIN);
 
     if (!endpoint) {
-        ERROR("[network_framework.on_interface_event] Failed to create bound Bonjour connection");
-        goto ERR_ENDPOINT;
+      ERROR(
+          "[network_framework.on_interface_event] Failed to create bound "
+          "Bonjour "
+          "connection");
+      goto ERR_ENDPOINT;
     }
 
     nw_connection_t connection = nw_connection_create(endpoint, parameters);
-    if (!connection)
-        goto ERR_CONNECTION;
+    if (!connection) goto ERR_CONNECTION;
 
     nw_release(endpoint);
     nw_release(parameters);
@@ -547,108 +547,98 @@ void on_interface_event(interface_t * interface, nw_interface_t iface)
 
     /* Setup connection handlers */
 
-    nw_connection_set_state_changed_handler(connection, ^(nw_connection_state_t state, nw_error_t error) {
-        on_connection_state_event(interface, iface, connection, state, error);
-    });
+    nw_connection_set_state_changed_handler(
+        connection, ^(nw_connection_state_t state, nw_error_t error) {
+          on_connection_state_event(interface, iface, connection, state, error);
+        });
 
     nw_connection_set_path_changed_handler(connection, ^(nw_path_t path) {
-        on_connection_path_event(interface, iface, connection, path);
+      on_connection_path_event(interface, iface, connection, path);
     });
 
     nw_connection_set_better_path_available_handler(connection, ^(bool value) {
 #if 1
-        DEBUG("Connection [better path = %s]\n", (value ? "true" : "false"));
-        WITH_DEBUG({
-            dump_connection(connection, 1);
-        });
+      DEBUG("Connection [better path = %s]\n", (value ? "true" : "false"));
+      WITH_DEBUG({ dump_connection(connection, 1); });
 #endif
     });
 
     nw_connection_set_viability_changed_handler(connection, ^(bool value) {
 #if 1
-        DEBUG("Connection [viable = %s]\n", (value ? "true" : "false"));
-        WITH_DEBUG({
-            //dump_connection(connection, 1);
-        });
+      DEBUG("Connection [viable = %s]\n", (value ? "true" : "false"));
+      WITH_DEBUG({
+          // dump_connection(connection, 1);
+      });
 #endif
 
-        /*
-         * This is the first time we have a connection with address and port
-         * and thus the full identification of an hICN face
-         */
-        facelet_t * facelet = facelet_create_from_connection(connection);
-        if (!facelet)
-            return;
-        facelet_set_event(facelet, value ? FACELET_EVENT_CREATE : FACELET_EVENT_DELETE);
-        interface_raise_event(interface, facelet);
-
+      /*
+       * This is the first time we have a connection with address and port
+       * and thus the full identification of an hICN face
+       */
+      facelet_t *facelet = facelet_create_from_connection(connection);
+      if (!facelet) return;
+      facelet_set_event(facelet,
+                        value ? FACELET_EVENT_CREATE : FACELET_EVENT_DELETE);
+      interface_raise_event(interface, facelet);
     });
 
     nw_connection_start(connection);
 
     nw_connection_set_queue(connection, dispatch_get_main_queue());
-    nw_retain(connection); // Hold a reference until cancelled
+    nw_retain(connection);  // Hold a reference until cancelled
 
 #if 1
     DEBUG("Created Bonjour cnx on interface:");
-    WITH_DEBUG({
-        dump_interface(iface, 1);
-    });
+    WITH_DEBUG({ dump_interface(iface, 1); });
 #endif
 
     return;
 
-   nw_release(connection);
-ERR_CONNECTION:
+    nw_release(connection);
+  ERR_CONNECTION:
     nw_release(endpoint);
-ERR_ENDPOINT:
+  ERR_ENDPOINT:
 #if defined(MAC_OS_X_VERSION_10_15)
     nw_release(descriptor);
-ERR_DESCRIPTOR:
+  ERR_DESCRIPTOR:
 #endif /* defined(MAC_OS_X_VERSION_10_15) */
     nw_release(parameters);
 
-ERR_PARAMETERS:
+  ERR_PARAMETERS:
     return;
-}
+  }
 
-void on_path_event(interface_t * interface, nw_path_t path)
-{
+  void on_path_event(interface_t * interface, nw_path_t path) {
     /* Simplification: we handle path event only once.
      * Ideally, test whether we discover new interfaces or not
      */
 #if 1
     DEBUG("Path [event]:\n");
-    WITH_DEBUG({
-        dump_path(path, 1);
-    });
+    WITH_DEBUG({ dump_path(path, 1); });
 #endif
 
-    nw_path_enumerate_interfaces(path, (nw_path_enumerate_interfaces_block_t)^(nw_interface_t iface) {
-            on_interface_event(interface, iface);
-            return true;
-    });
-
-}
+    nw_path_enumerate_interfaces(
+        path, (nw_path_enumerate_interfaces_block_t) ^ (nw_interface_t iface) {
+          on_interface_event(interface, iface);
+          return true;
+        });
+  }
 
-int nf_initialize(interface_t * interface, void * cfg)
-{
-    nf_data_t * data = malloc(sizeof(nf_data_t));
-    if (!data)
-        goto ERR_MALLOC;
+  int nf_initialize(interface_t * interface, void *cfg) {
+    nf_data_t *data = malloc(sizeof(nf_data_t));
+    if (!data) goto ERR_MALLOC;
 
-    if (cfg)
-        data->cfg = * (network_framework_cfg_t *)cfg;
+    if (cfg) data->cfg = *(network_framework_cfg_t *)cfg;
 
     data->pm = nw_path_monitor_create();
-    if (!data->pm)
-        goto ERR_PM;
+    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_cancel_handler(data->pm, ^(){
+                                       });
     nw_path_monitor_set_update_handler(data->pm, ^(nw_path_t path) {
-            on_path_event(interface, path);
-            });
+      on_path_event(interface, path);
+    });
 
     // XXX NEEDED ?
     nw_retain(data->pm);
@@ -659,25 +649,24 @@ int nf_initialize(interface_t * interface, void * cfg)
     interface->data = data;
     return 0;
 
-ERR_PM:
+  ERR_PM:
     free(data);
-ERR_MALLOC:
+  ERR_MALLOC:
     return -1;
-}
+  }
 
-int nf_finalize(interface_t * interface)
-{
-    nf_data_t * data = (nf_data_t*)interface->data;
+  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;
+      nw_path_monitor_cancel(data->pm);
+      data->pm = NULL;
     }
     return 0;
-}
-
-const interface_ops_t network_framework_ops = {
-    .type = "network_framework",
-    .initialize = nf_initialize,
-    .finalize = nf_finalize,
-    .on_event = NULL,
-};
+  }
+
+  const interface_ops_t network_framework_ops = {
+      .type = "network_framework",
+      .initialize = nf_initialize,
+      .finalize = nf_finalize,
+      .on_event = NULL,
+  };
diff --git a/ctrl/facemgr/src/interfaces/network_framework/network_framework.h b/ctrl/facemgr/src/interfaces/network_framework/network_framework.h
index edb35e904..768edc253 100644
--- a/ctrl/facemgr/src/interfaces/network_framework/network_framework.h
+++ b/ctrl/facemgr/src/interfaces/network_framework/network_framework.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -19,4 +19,5 @@
  */
 
 typedef struct {
+  void *_;
 } network_framework_cfg_t;
diff --git a/ctrl/facemgr/src/interfaces/priority_controller/CMakeLists.txt b/ctrl/facemgr/src/interfaces/priority_controller/CMakeLists.txt
index 8d18800db..43ba31b0b 100644
--- a/ctrl/facemgr/src/interfaces/priority_controller/CMakeLists.txt
+++ b/ctrl/facemgr/src/interfaces/priority_controller/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/ctrl/facemgr/src/interfaces/priority_controller/priority_controller.c b/ctrl/facemgr/src/interfaces/priority_controller/priority_controller.c
index 67edc5e39..5d2f695f9 100644
--- a/ctrl/facemgr/src/interfaces/priority_controller/priority_controller.c
+++ b/ctrl/facemgr/src/interfaces/priority_controller/priority_controller.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -34,20 +34,21 @@
 #define PC_DEFAULT_PORT 9533
 
 typedef struct {
-    priority_controller_cfg_t cfg;
-    int fd;
+  priority_controller_cfg_t cfg;
+  int fd;
 #ifdef PRIORITY_CONTROLLER_INTERNAL
-    unsigned state;
-    JNIEnv * env;
-    jclass cls;
-    jmethodID mid;
+  unsigned state;
+  JNIEnv *env;
+  jclass cls;
+  jmethodID mid;
 #endif /* PRIORITY_CONTROLLER_INTERNAL */
 } pc_data_t;
 
 #ifdef PRIORITY_CONTROLLER_INTERNAL
 #include <jni.h>
 
-#define ERR_STR_JAVA "Java VM parameters are required in the interface configuration."
+#define ERR_STR_JAVA \
+  "Java VM parameters are required in the interface configuration."
 
 #define PREFER_CELLULAR 0
 #define PREFER_WIFI 1
@@ -55,147 +56,146 @@ typedef struct {
 
 #define INTERVAL_MS 500
 
-const char * prefer_str[] = { "Cellular", "WiFi", "both" };
+const char *prefer_str[] = {"Cellular", "WiFi", "both"};
 
-jclass find_class_global(JNIEnv* env, const char *name){
-    jclass c = (*env)->FindClass(env, name);
-    jclass c_global = 0;
-    if (c){
-        c_global = (jclass)(*env)->NewGlobalRef(env, c);
-        (*env)->DeleteLocalRef(env, c);
-    }
-    return c_global;
+jclass find_class_global(JNIEnv *env, const char *name) {
+  jclass c = (*env)->FindClass(env, name);
+  jclass c_global = 0;
+  if (c) {
+    c_global = (jclass)(*env)->NewGlobalRef(env, c);
+    (*env)->DeleteLocalRef(env, c);
+  }
+  return c_global;
 }
 
+int priority_controller_tick(interface_t *interface, int fd, void *unused) {
+  pc_data_t *data = (pc_data_t *)interface->data;
+  unsigned new_state = PREFER_BOTH;
 
-int priority_controller_tick(interface_t * interface, int fd, void * unused)
-{
-    pc_data_t * data = (pc_data_t*)interface->data;
-    unsigned new_state = PREFER_BOTH;
-
-    jint rssi = (*data->env)->CallStaticIntMethod(data->env, data->cls, data->mid);
-    DEBUG("[priority_controller_tick] rssi=%d\n", rssi);
-    if (rssi > -67) {
-        new_state = PREFER_WIFI;
+  jint rssi =
+      (*data->env)->CallStaticIntMethod(data->env, data->cls, data->mid);
+  DEBUG("[priority_controller_tick] rssi=%d\n", rssi);
+  if (rssi > -67) {
+    new_state = PREFER_WIFI;
 
 #if 0
     } else if ((rssi < -67) && (rssi > -70)) {
         new_state = PREFER_BOTH;
 #endif
 
-    } else { /* rssi < -70 */
-        new_state = PREFER_CELLULAR;
-    }
+  } else { /* rssi < -70 */
+    new_state = PREFER_CELLULAR;
+  }
 
-    if (new_state == data->state)
-        return 0;
+  if (new_state == data->state) return 0;
 
-    ERROR("[priority_controller_tick] Setting priority to %s", prefer_str[new_state]);
+  ERROR("[priority_controller_tick] Setting priority to %s",
+        prefer_str[new_state]);
 
-    /* XXX Factor this */
+  /* XXX Factor this */
 
-    facelet_t * facelet_w = facelet_create();
-    facelet_t * facelet_c = facelet_create();
-    facelet_set_netdevice_type(facelet_w, NETDEVICE_TYPE_WIFI);
-    facelet_set_netdevice_type(facelet_c, NETDEVICE_TYPE_CELLULAR);
-    facelet_set_attr_clean(facelet_w);
-    facelet_set_attr_clean(facelet_c);
+  facelet_t *facelet_w = facelet_create();
+  facelet_t *facelet_c = facelet_create();
+  facelet_set_netdevice_type(facelet_w, NETDEVICE_TYPE_WIFI);
+  facelet_set_netdevice_type(facelet_c, NETDEVICE_TYPE_CELLULAR);
+  facelet_set_attr_clean(facelet_w);
+  facelet_set_attr_clean(facelet_c);
 
-    switch(new_state) {
-        case PREFER_CELLULAR:
-            facelet_set_priority(facelet_w, 0);
-            facelet_set_priority(facelet_c, 10);
-            break;
-        case PREFER_WIFI:
-            facelet_set_priority(facelet_w, 10);
-            facelet_set_priority(facelet_c, 0);
-            break;
-        case PREFER_BOTH:
-            facelet_set_priority(facelet_w, 0);
-            facelet_set_priority(facelet_c, 0);
-            break;
-    }
+  switch (new_state) {
+    case PREFER_CELLULAR:
+      facelet_set_priority(facelet_w, 0);
+      facelet_set_priority(facelet_c, 10);
+      break;
+    case PREFER_WIFI:
+      facelet_set_priority(facelet_w, 10);
+      facelet_set_priority(facelet_c, 0);
+      break;
+    case PREFER_BOTH:
+      facelet_set_priority(facelet_w, 0);
+      facelet_set_priority(facelet_c, 0);
+      break;
+  }
 
-    facelet_set_event(facelet_w, FACELET_EVENT_UPDATE);
-    facelet_set_event(facelet_c, FACELET_EVENT_UPDATE);
+  facelet_set_event(facelet_w, FACELET_EVENT_UPDATE);
+  facelet_set_event(facelet_c, FACELET_EVENT_UPDATE);
 
-    interface_raise_event(interface, facelet_w);
-    interface_raise_event(interface, facelet_c);
+  interface_raise_event(interface, facelet_w);
+  interface_raise_event(interface, facelet_c);
 
-    data->state = new_state;
+  data->state = new_state;
 
-    return 0;
+  return 0;
 }
 #endif /* PRIORITY_CONTROLLER_INTERNAL */
 
-int priority_controller_initialize(interface_t * interface, void * cfg)
-{
-    INFO("Initializing priority controller");
+int priority_controller_initialize(interface_t *interface, void *cfg) {
+  INFO("Initializing priority controller");
 
-    pc_data_t * data = malloc(sizeof(pc_data_t));
-    if (!data) {
-        INFO("Priority controller data memory allocation error");
-        goto ERR_MALLOC;
-    }
+  pc_data_t *data = malloc(sizeof(pc_data_t));
+  if (!data) {
+    INFO("Priority controller data memory allocation error");
+    goto ERR_MALLOC;
+  }
 
-    interface->data = data;
+  interface->data = data;
 
-    data->cfg = * (priority_controller_cfg_t *) cfg;
+  data->cfg = *(priority_controller_cfg_t *)cfg;
 
 #ifdef PRIORITY_CONTROLLER_INTERNAL
 
-    if (!cfg) {
-        ERROR(ERR_STR_JAVA);
-        goto ERR_CFG;
-    }
-
-    /* Retrieve RSSI information from SDK through AndroidUtility class */
-    (*data->cfg.jvm)->AttachCurrentThread(data->cfg.jvm, &data->env, NULL);
-    data->cls = find_class_global(data->env, FACEMGR_ANDROID_UTILITY_CLASS);
-    if (data->cls == 0)
-        goto ERR_JAVA;
-    data->mid = (*data->env)->GetStaticMethodID(data->env, data->cls, "getWifiRSSI", "()I");
-
-    data->fd = interface_register_timer(interface, INTERVAL_MS,
-            priority_controller_tick, interface);
-    if (data->fd < 0) {
-        ERROR("[priority_controller_initialize] Could not initialize timer");
-        goto ERR_FD;
-    }
-    data->state = PREFER_BOTH;
+  if (!cfg) {
+    ERROR(ERR_STR_JAVA);
+    goto ERR_CFG;
+  }
+
+  /* Retrieve RSSI information from SDK through AndroidUtility class */
+  (*data->cfg.jvm)->AttachCurrentThread(data->cfg.jvm, &data->env, NULL);
+  data->cls = find_class_global(data->env, FACEMGR_ANDROID_UTILITY_CLASS);
+  if (data->cls == 0) goto ERR_JAVA;
+  data->mid =
+      (*data->env)
+          ->GetStaticMethodID(data->env, data->cls, "getWifiRSSI", "()I");
+
+  data->fd = interface_register_timer(interface, INTERVAL_MS,
+                                      priority_controller_tick, interface);
+  if (data->fd < 0) {
+    ERROR("[priority_controller_initialize] Could not initialize timer");
+    goto ERR_FD;
+  }
+  data->state = PREFER_BOTH;
 
 #else /* PRIORITY_CONTROLLER_INTERNAL */
-    struct sockaddr_in addr;
-
-    data->fd = socket(AF_INET, SOCK_DGRAM, 0);
-    //data->fd = socket(AF_INET, SOCK_STREAM, 0);
-    if (data->fd < 0) {
-        INFO("Priority controller socket error");
-        perror("socket error");
-        goto ERR_SOCKET;
-    }
-
-    memset(&addr, 0, sizeof(addr));
-    addr.sin_family = AF_INET;
-    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
-    addr.sin_port = htons(PC_DEFAULT_PORT);
-
-    if (bind(data->fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
-        INFO("Priority controller socket bind error");
-        perror("bind error");
-        goto ERR_BIND;
-    }
-
-    DEBUG("[priority_controller_initialize] register fd");
-    if (interface_register_fd(interface, data->fd, NULL) < 0) {
-        ERROR("[priority_controller_initialize] Error registering fd");
-        goto ERR_FD;
-    }
+  struct sockaddr_in addr;
+
+  data->fd = socket(AF_INET, SOCK_DGRAM, 0);
+  // data->fd = socket(AF_INET, SOCK_STREAM, 0);
+  if (data->fd < 0) {
+    INFO("Priority controller socket error");
+    perror("socket error");
+    goto ERR_SOCKET;
+  }
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+  addr.sin_addr.s_addr = inet_addr("127.0.0.1");
+  addr.sin_port = htons(PC_DEFAULT_PORT);
+
+  if (bind(data->fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+    INFO("Priority controller socket bind error");
+    perror("bind error");
+    goto ERR_BIND;
+  }
+
+  DEBUG("[priority_controller_initialize] register fd");
+  if (interface_register_fd(interface, data->fd, NULL) < 0) {
+    ERROR("[priority_controller_initialize] Error registering fd");
+    goto ERR_FD;
+  }
 
 #endif /* PRIORITY_CONTROLLER_INTERNAL */
 
-    INFO("Priority controller successfully initialized");
-    return 0;
+  INFO("Priority controller successfully initialized");
+  return 0;
 
 #ifdef PRIORITY_CONTROLLER_INTERNAL
 ERR_CFG:
@@ -204,86 +204,86 @@ ERR_JAVA:
 ERR_FD:
 #ifndef PRIORITY_CONTROLLER_INTERNAL
 ERR_BIND:
-    close(data->fd);
+  close(data->fd);
 ERR_SOCKET:
 #endif /* ! PRIORITY_CONTROLLER_INTERNAL */
-    free(data);
+  free(data);
 ERR_MALLOC:
-    return -1;
+  return -1;
 }
 
-int priority_controller_finalize(interface_t * interface)
-{
-    pc_data_t * data = (pc_data_t*)interface->data;
+int priority_controller_finalize(interface_t *interface) {
+  pc_data_t *data = (pc_data_t *)interface->data;
 
 #ifdef PRIORITY_CONTROLLER_INTERNAL
-    DEBUG("[priority_controller_finalize] unregister timer");
-    interface_unregister_timer(interface, data->fd);
+  DEBUG("[priority_controller_finalize] unregister timer");
+  interface_unregister_timer(interface, data->fd);
 #else
-    if (data->fd > 0) {
-        interface_unregister_fd(interface, data->fd);
-        close(data->fd);
-    }
-    free(data);
+  if (data->fd > 0) {
+    interface_unregister_fd(interface, data->fd);
+    close(data->fd);
+  }
+  free(data);
 #endif /* PRIORITY_CONTROLLER_INTERNAL */
 
-    return 0;
+  return 0;
 }
 
 #ifndef PRIORITY_CONTROLLER_INTERNAL
-int priority_controller_callback(interface_t * interface, int fd, void * unused)
-{
-    pc_data_t * data = (pc_data_t*)interface->data;
-    char buf[100];
-    int rc;
-
-    INFO("Priority controller receiving command");
-
-    rc = recv(data->fd, buf, 100, 0);
-
-    if (rc < 0) {
-        INFO("Priority controller read error");
-        return -1;
-    }
-
-    INFO("Priority controller received command: %02X", buf[0]);
-
-    facelet_t * facelet_w = facelet_create();
-    facelet_t * facelet_c = facelet_create();
-    facelet_set_netdevice_type(facelet_w, NETDEVICE_TYPE_WIFI);
-    facelet_set_netdevice_type(facelet_c, NETDEVICE_TYPE_CELLULAR);
-    facelet_set_attr_clean(facelet_w);
-    facelet_set_attr_clean(facelet_c);
-    switch(buf[0]) {
-        case '\0':
-            facelet_set_priority(facelet_w, 0);
-            facelet_set_priority(facelet_c, 10);
-            INFO("Priority controller configuring Cellular preferred");
-            break;
-        case '\1':
-            facelet_set_priority(facelet_w, 10);
-            facelet_set_priority(facelet_c, 0);
-            INFO("Priority controller configuring Wi-Fi preferred");
-            break;
-        case '\2':
-            facelet_set_priority(facelet_w, 0);
-            facelet_set_priority(facelet_c, 0);
-            INFO("Priority controller configuring both Cellular and Wi-Fi preferred");
-            break;
-        default:
-            INFO("Priority controller invalid data received from updown server. Ignoring...");
-            facelet_free(facelet_w);
-            facelet_free(facelet_c);
-            return 0;
-    }
-
-    facelet_set_event(facelet_w, FACELET_EVENT_UPDATE);
-    facelet_set_event(facelet_c, FACELET_EVENT_UPDATE);
-
-    interface_raise_event(interface, facelet_w);
-    interface_raise_event(interface, facelet_c);
-
-    return 0;
+int priority_controller_callback(interface_t *interface, int fd, void *unused) {
+  pc_data_t *data = (pc_data_t *)interface->data;
+  char buf[100];
+  int rc;
+
+  INFO("Priority controller receiving command");
+
+  rc = recv(data->fd, buf, 100, 0);
+
+  if (rc < 0) {
+    INFO("Priority controller read error");
+    return -1;
+  }
+
+  INFO("Priority controller received command: %02X", buf[0]);
+
+  facelet_t *facelet_w = facelet_create();
+  facelet_t *facelet_c = facelet_create();
+  facelet_set_netdevice_type(facelet_w, NETDEVICE_TYPE_WIFI);
+  facelet_set_netdevice_type(facelet_c, NETDEVICE_TYPE_CELLULAR);
+  facelet_set_attr_clean(facelet_w);
+  facelet_set_attr_clean(facelet_c);
+  switch (buf[0]) {
+    case '\0':
+      facelet_set_priority(facelet_w, 0);
+      facelet_set_priority(facelet_c, 10);
+      INFO("Priority controller configuring Cellular preferred");
+      break;
+    case '\1':
+      facelet_set_priority(facelet_w, 10);
+      facelet_set_priority(facelet_c, 0);
+      INFO("Priority controller configuring Wi-Fi preferred");
+      break;
+    case '\2':
+      facelet_set_priority(facelet_w, 0);
+      facelet_set_priority(facelet_c, 0);
+      INFO("Priority controller configuring both Cellular and Wi-Fi preferred");
+      break;
+    default:
+      INFO(
+          "Priority controller invalid data received from updown server. "
+          "Ignoring...");
+      facelet_free(facelet_w);
+      facelet_free(facelet_c);
+      return 0;
+  }
+
+  facelet_set_event(facelet_w, FACELET_EVENT_UPDATE);
+  facelet_set_event(facelet_c, FACELET_EVENT_UPDATE);
+
+  interface_raise_event(interface, facelet_w);
+  interface_raise_event(interface, facelet_c);
+
+  return 0;
 }
 #endif /* ! PRIORITY_CONTROLLER_INTERNAL */
 
diff --git a/ctrl/facemgr/src/interfaces/priority_controller/priority_controller.h b/ctrl/facemgr/src/interfaces/priority_controller/priority_controller.h
index 247fc3c57..7f257ffcf 100644
--- a/ctrl/facemgr/src/interfaces/priority_controller/priority_controller.h
+++ b/ctrl/facemgr/src/interfaces/priority_controller/priority_controller.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,7 +21,8 @@
 #ifndef FACEMGR_INTERFACE_PRIORITY_CONTROLLER
 #define FACEMGR_INTERFACE_PRIORITY_CONTROLLER
 
-#define FACEMGR_UTILITY_CLASS "com/cisco/hicn/facemgrlibrary/supportlibrary/FacemgrUtility"
+#define FACEMGR_UTILITY_CLASS \
+  "com/cisco/hicn/facemgrlibrary/supportlibrary/FacemgrUtility"
 
 /*
  * Uncomment this line to use a Priority controller interface internal to the
@@ -36,10 +37,9 @@
 typedef struct {
 #ifdef __ANDROID__
 #ifdef PRIORITY_CONTROLLER_INTERNAL
-    JavaVM * jvm;
+  JavaVM* jvm;
 #endif /* PRIORITY_CONTROLLER_INTERNAL */
 #endif /* __ANDROID__ */
 } priority_controller_cfg_t;
 
-
 #endif /* FACEMGR_INTERFACE_PRIORITY_CONTROLLER */
diff --git a/ctrl/facemgr/src/interfaces/updown/CMakeLists.txt b/ctrl/facemgr/src/interfaces/updown/CMakeLists.txt
index e5fd2167e..4c6c0ea6c 100644
--- a/ctrl/facemgr/src/interfaces/updown/CMakeLists.txt
+++ b/ctrl/facemgr/src/interfaces/updown/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/ctrl/facemgr/src/interfaces/updown/updown.c b/ctrl/facemgr/src/interfaces/updown/updown.c
index 7d305a5cd..8d31f6cd4 100644
--- a/ctrl/facemgr/src/interfaces/updown/updown.c
+++ b/ctrl/facemgr/src/interfaces/updown/updown.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -26,6 +26,7 @@
 #include <unistd.h>
 
 #include <hicn/facemgr.h>
+#include <hicn/util/sstrncpy.h>
 
 #include "../../common.h"
 #include "../../interface.h"
@@ -37,107 +38,101 @@
 #define UNIX_PATH "\0updownsrv"
 
 typedef struct {
-    int fd; /* Unix client socket */
+  int fd; /* Unix client socket */
 } updown_data_t;
 
-int updown_initialize(interface_t * interface, void * cfg)
-{
-    struct sockaddr_un addr;
-    char * socket_path = UNIX_PATH;
-
-    updown_data_t * data = malloc(sizeof(updown_data_t));
-    if (!data)
-        goto ERR_MALLOC;
-    interface->data = data;
-
-    data->fd = socket(AF_UNIX, SOCK_STREAM, 0);
-    if (data->fd == -1) {
-        perror("socket error");
-        goto ERR_SOCKET;
-    }
-
-    memset(&addr, 0, sizeof(addr));
-    addr.sun_family = AF_UNIX;
-    if (*socket_path == '\0') {
-        *addr.sun_path = '\0';
-        strncpy(addr.sun_path+1, socket_path+1, sizeof(addr.sun_path)-2);
-    } else {
-        strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path)-1);
-    }
-
-    if (connect(data->fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
-        perror("connect error");
-        goto ERR_CONNECT;
-    }
-
-    if (interface_register_fd(interface, data->fd, NULL) < 0) {
-        ERROR("[updown_initialize] Error registering fd");
-        goto ERR_FD;
-    }
-
-    return 0;
+int updown_initialize(interface_t* interface, void* cfg) {
+  struct sockaddr_un addr;
+  char* socket_path = UNIX_PATH;
+
+  updown_data_t* data = malloc(sizeof(updown_data_t));
+  if (!data) goto ERR_MALLOC;
+  interface->data = data;
+
+  data->fd = socket(AF_UNIX, SOCK_STREAM, 0);
+  if (data->fd == -1) {
+    perror("socket error");
+    goto ERR_SOCKET;
+  }
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sun_family = AF_UNIX;
+  if (*socket_path == '\0') {
+    *addr.sun_path = '\0';
+    strcpy_s(addr.sun_path + 1, sizeof(addr.sun_path) - 2, socket_path + 1);
+  } else {
+    strcpy_s(addr.sun_path, sizeof(addr.sun_path) - 1, socket_path);
+  }
+
+  if (connect(data->fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
+    perror("connect error");
+    goto ERR_CONNECT;
+  }
+
+  if (interface_register_fd(interface, data->fd, NULL) < 0) {
+    ERROR("[updown_initialize] Error registering fd");
+    goto ERR_FD;
+  }
+
+  return 0;
 
 ERR_FD:
 ERR_CONNECT:
-    close(data->fd);
+  close(data->fd);
 ERR_SOCKET:
-    free(data);
+  free(data);
 ERR_MALLOC:
-    return -1;
+  return -1;
 }
 
-int updown_finalize(interface_t * interface)
-{
-    updown_data_t * data = (updown_data_t*)interface->data;
+int updown_finalize(interface_t* interface) {
+  updown_data_t* data = (updown_data_t*)interface->data;
 
-    if (data->fd > 0)
-        close(data->fd);
-    free(data);
+  if (data->fd > 0) close(data->fd);
+  free(data);
 
-    return 0;
+  return 0;
 }
 
-int updown_callback(interface_t * interface, int fd, void * unused)
-{
-    updown_data_t * data = (updown_data_t*)interface->data;
-    char buf[100];
-    int rc;
-
-    rc = read(data->fd, buf, sizeof(buf));
-    if (rc < 0)
-        return -1;
-
-    /*
-     * If the process is paused (eg. in a debugger, we might have more than one
-     * read.
-     * XXX how big is the buffer
-     * XXX shall we drain the queue if it exceeds buffer size ?
-     */
-    //assert(rc == 1);
-
-    /* Raise facelet update event */
-    facelet_t * facelet = facelet_create();
-    facelet_set_netdevice_type(facelet, NETDEVICE_TYPE_WIFI); //CELLULAR);
-    facelet_set_attr_clean(facelet);
-    switch(buf[0]) {
-        case '\0':
-            facelet_set_admin_state(facelet, FACE_STATE_DOWN);
-            break;
-        case '\1':
-            facelet_set_admin_state(facelet, FACE_STATE_UP);
-            break;
-            break;
-        default:
-            ERROR("Invalid data received from updown server. Ignoring...");
-            facelet_free(facelet);
-            return -1;
-    }
-
-    facelet_set_event(facelet, FACELET_EVENT_UPDATE);
-
-    interface_raise_event(interface, facelet);
-
-    return 0;
+int updown_callback(interface_t* interface, int fd, void* unused) {
+  updown_data_t* data = (updown_data_t*)interface->data;
+  char buf[100];
+  int rc;
+
+  rc = read(data->fd, buf, sizeof(buf));
+  if (rc < 0) return -1;
+
+  /*
+   * If the process is paused (eg. in a debugger, we might have more than one
+   * read.
+   * XXX how big is the buffer
+   * XXX shall we drain the queue if it exceeds buffer size ?
+   */
+  // assert(rc == 1);
+
+  /* Raise facelet update event */
+  facelet_t* facelet = facelet_create();
+  facelet_set_netdevice_type(facelet, NETDEVICE_TYPE_WIFI);  // CELLULAR);
+  facelet_set_attr_clean(facelet);
+  switch (buf[0]) {
+    case '\0':
+      facelet_set_admin_state(facelet, FACE_STATE_DOWN);
+      break;
+    case '\1':
+      facelet_set_admin_state(facelet, FACE_STATE_UP);
+      break;
+      break;
+    default:
+      ERROR("Invalid data received from updown server. Ignoring...");
+      facelet_free(facelet);
+      return -1;
+  }
+
+  facelet_set_event(facelet, FACELET_EVENT_UPDATE);
+
+  interface_raise_event(interface, facelet);
+
+  return 0;
 }
 
 interface_ops_t updown_ops = {
diff --git a/ctrl/facemgr/src/loop_dispatcher.c b/ctrl/facemgr/src/loop_dispatcher.c
index 499a1ccac..ed4540f5c 100644
--- a/ctrl/facemgr/src/loop_dispatcher.c
+++ b/ctrl/facemgr/src/loop_dispatcher.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -33,52 +33,36 @@
 #include <hicn/facemgr/loop.h>
 #include <hicn/util/log.h>
 
-struct loop_s {
-};
+struct loop_s {};
 
-loop_t *
-loop_create()
-{
-    loop_t * loop = malloc(sizeof(loop_t));
-    if (!loop) {
-        ERROR("[loop_create] Failed to allocate memory");
-        goto ERR_MALLOC;
-    }
-    return loop;
+loop_t* loop_create() {
+  loop_t* loop = malloc(sizeof(loop_t));
+  if (!loop) {
+    ERROR("[loop_create] Failed to allocate memory");
+    goto ERR_MALLOC;
+  }
+  return loop;
 
 ERR_MALLOC:
-    return NULL;
+  return NULL;
 }
 
-void
-loop_free(loop_t * loop)
-{
-    /* Nothing to do */
+void loop_free(loop_t* loop) { /* Nothing to do */
 }
 
-int
-loop_dispatch(loop_t * loop)
-{
-    dispatch_main();
-    return 0;
+int loop_dispatch(loop_t* loop) {
+  dispatch_main();
+  return 0;
 }
 
-int
-loop_undispatch(loop_t * loop)
-{
-    /* Nothing to do */
-    return 0;
+int loop_undispatch(loop_t* loop) {
+  /* Nothing to do */
+  return 0;
 }
 
-void
-loop_break(loop_t * loop)
-{
-    exit(0);
-}
+void loop_break(loop_t* loop) { exit(0); }
 
-int
-loop_callback(loop_t * loop, facemgr_cb_type_t type, void * data)
-{
-    INFO("loop_callback not (yet) implemented");
-    return 0;
+int loop_callback(loop_t* loop, facemgr_cb_type_t type, void* data) {
+  INFO("loop_callback not (yet) implemented");
+  return 0;
 }
diff --git a/ctrl/facemgr/src/loop_libevent.c b/ctrl/facemgr/src/loop_libevent.c
index 674eee905..b619e02e6 100644
--- a/ctrl/facemgr/src/loop_libevent.c
+++ b/ctrl/facemgr/src/loop_libevent.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,13 +25,13 @@
 #include <assert.h>
 #include <event2/event.h>
 #include <event2/thread.h>
-#include <fcntl.h> // fcntl
+#include <fcntl.h>  // fcntl
 #ifdef WITH_THREAD
 #include <pthread.h>
 #endif /* WITH_THREAD */
 #include <stdlib.h>
 #include <sys/timerfd.h>
-#include <unistd.h> // fcntl
+#include <unistd.h>  // fcntl
 
 #include <hicn/facemgr/api.h>
 #include <hicn/util/log.h>
@@ -43,160 +43,150 @@
  * \brief Holds all callback parameters
  */
 typedef struct {
-    void * owner;
-    fd_callback_t callback;
-    void * data;
+  void *owner;
+  fd_callback_t callback;
+  void *data;
 } cb_wrapper_args_t;
 
 TYPEDEF_MAP_H(event_map, int, struct event *);
-TYPEDEF_MAP(event_map, int, struct event *, int_cmp, int_snprintf, generic_snprintf);
+TYPEDEF_MAP(event_map, int, struct event *, int_cmp, int_snprintf,
+            generic_snprintf);
 
 /* Map that associates timer fds with their associated cb_wrapper_args_t */
 TYPEDEF_MAP_H(timer_fd_map, int, cb_wrapper_args_t *);
-TYPEDEF_MAP(timer_fd_map, int, cb_wrapper_args_t *, int_cmp, int_snprintf, generic_snprintf);
+TYPEDEF_MAP(timer_fd_map, int, cb_wrapper_args_t *, int_cmp, int_snprintf,
+            generic_snprintf);
 
 struct loop_s {
-    struct event_base * event_base;
-    event_map_t * event_map;
-    timer_fd_map_t * timer_fd_map;
+  struct event_base *event_base;
+  event_map_t *event_map;
+  timer_fd_map_t *timer_fd_map;
 #ifdef WITH_THREAD
-    pthread_t thread;
+  pthread_t thread;
 #endif /* WITH_THREAD */
 };
 
 /* Forward declarations */
-int _loop_unregister_fd(loop_t * loop, int fd);
-int _loop_unregister_timer(loop_t * loop, int fd);
-
-loop_t *
-loop_create()
-{
-    loop_t * loop = malloc(sizeof(loop_t));
-    if (!loop) {
-        ERROR("[loop_create] Failed to allocate memory");
-        goto ERR_MALLOC;
-    }
+int _loop_unregister_fd(loop_t *loop, int fd);
+int _loop_unregister_timer(loop_t *loop, int fd);
+
+loop_t *loop_create() {
+  loop_t *loop = malloc(sizeof(loop_t));
+  if (!loop) {
+    ERROR("[loop_create] Failed to allocate memory");
+    goto ERR_MALLOC;
+  }
 
 #ifdef WITH_THREAD
-    evthread_use_pthreads();
+  evthread_use_pthreads();
 #endif /* WITH_THREAD */
 
-    loop->event_base = event_base_new();
-    if (!loop)
-        goto ERR_EVENT;
+  loop->event_base = event_base_new();
+  if (!loop) goto ERR_EVENT;
 
-    loop->event_map = event_map_create();
-    if (!loop->event_map) {
-        ERROR("[loop_create] Failed to create event_map");
-        goto ERR_EVENT_MAP;
-    }
+  loop->event_map = event_map_create();
+  if (!loop->event_map) {
+    ERROR("[loop_create] Failed to create event_map");
+    goto ERR_EVENT_MAP;
+  }
 
-    loop->timer_fd_map = timer_fd_map_create();
-    if (!loop->timer_fd_map) {
-        ERROR("[loop_create] Failed to create timer_fd_map");
-        goto ERR_TIMER_FD_MAP;
-    }
+  loop->timer_fd_map = timer_fd_map_create();
+  if (!loop->timer_fd_map) {
+    ERROR("[loop_create] Failed to create timer_fd_map");
+    goto ERR_TIMER_FD_MAP;
+  }
 
-    event_set_log_callback(NULL);
+  event_set_log_callback(NULL);
 
-    return loop;
+  return loop;
 
-    timer_fd_map_free(loop->timer_fd_map);
 ERR_TIMER_FD_MAP:
-    event_map_free(loop->event_map);
+  event_map_free(loop->event_map);
 ERR_EVENT_MAP:
-    event_base_free(loop->event_base);
+  event_base_free(loop->event_base);
 ERR_EVENT:
-    free(loop);
+  free(loop);
 ERR_MALLOC:
-    return NULL;
+  return NULL;
 }
 
-void
-loop_free(loop_t * loop)
-{
-    /*
-     * Release all timer cb_wrapper_args_t
-     *
-     * We need to stop all timers, this should release associated fd events at
-     * the same time... for that reason, this code has to be called before
-     * releasing events
-     */
-
-    int * timer_fd_map_array;
-    int n = timer_fd_map_get_key_array(loop->timer_fd_map, &timer_fd_map_array);
-    if (n < 0) {
-        ERROR("[loop_free] Could not get event map array");
-    } else {
-        for (unsigned i = 0; i < n; i++) {
-            int fd = timer_fd_map_array[i];
-            if (_loop_unregister_timer(loop, fd) < 0) {
-                ERROR("[loop_free] Could not unregister timer");
-            }
-        }
-        free(timer_fd_map_array);
+void loop_free(loop_t *loop) {
+  /*
+   * Release all timer cb_wrapper_args_t
+   *
+   * We need to stop all timers, this should release associated fd events at
+   * the same time... for that reason, this code has to be called before
+   * releasing events
+   */
+
+  int *timer_fd_map_array;
+  int n = timer_fd_map_get_key_array(loop->timer_fd_map, &timer_fd_map_array);
+  if (n < 0) {
+    ERROR("[loop_free] Could not get event map array");
+  } else {
+    for (unsigned i = 0; i < n; i++) {
+      int fd = timer_fd_map_array[i];
+      if (_loop_unregister_timer(loop, fd) < 0) {
+        ERROR("[loop_free] Could not unregister timer");
+      }
     }
-    timer_fd_map_free(loop->timer_fd_map);
-
-    /* Release all events */
-
-    int * event_map_array;
-    n = event_map_get_key_array(loop->event_map, &event_map_array);
-    if (n < 0) {
-        ERROR("[loop_free] Could not get event map array");
-    } else {
-        for (unsigned i = 0; i < n; i++) {
-            int fd = event_map_array[i];
-            if (_loop_unregister_fd(loop, fd) < 0) {
-                ERROR("[loop_free] Could not unregister fd");
-            }
-        }
-        free(event_map_array);
+    free(timer_fd_map_array);
+  }
+  timer_fd_map_free(loop->timer_fd_map);
+
+  /* Release all events */
+
+  int *event_map_array;
+  n = event_map_get_key_array(loop->event_map, &event_map_array);
+  if (n < 0) {
+    ERROR("[loop_free] Could not get event map array");
+  } else {
+    for (unsigned i = 0; i < n; i++) {
+      int fd = event_map_array[i];
+      if (_loop_unregister_fd(loop, fd) < 0) {
+        ERROR("[loop_free] Could not unregister fd");
+      }
     }
-    event_map_free(loop->event_map);
+    free(event_map_array);
+  }
+  event_map_free(loop->event_map);
 
-    event_base_free(loop->event_base);
+  event_base_free(loop->event_base);
 
-    free(loop);
+  free(loop);
 }
 
-int
-loop_dispatch(loop_t * loop)
-{
+int loop_dispatch(loop_t *loop) {
 #ifdef WITH_THREAD
-    if (pthread_create(&loop->thread, NULL, (void * (*)(void *))event_base_dispatch, loop->event_base)) {
-        fprintf(stderr, "Error creating thread\n");
-        return -1;
-    }
+  if (pthread_create(&loop->thread, NULL,
+                     (void *(*)(void *))event_base_dispatch,
+                     loop->event_base)) {
+    fprintf(stderr, "Error creating thread\n");
+    return -1;
+  }
 #else
-    event_base_dispatch(loop->event_base);
+  event_base_dispatch(loop->event_base);
 #endif /* WITH_THREAD */
-    return 0;
+  return 0;
 }
 
-int
-loop_undispatch(loop_t * loop)
-{
+int loop_undispatch(loop_t *loop) {
 #ifdef WITH_THREAD
-    DEBUG("Waiting for loop to terminate...");
-    if(pthread_join(loop->thread, NULL)) {
-        fprintf(stderr, "Error joining thread\n");
-        return -1;
-    }
-    DEBUG("Loop terminated !");
+  DEBUG("Waiting for loop to terminate...");
+  if (pthread_join(loop->thread, NULL)) {
+    ERROR("Error joining thread\n");
+    return -1;
+  }
+  DEBUG("Loop terminated !");
 #endif /* WITH_THREAD */
-    return 0;
+  return 0;
 }
 
-void
-loop_break(loop_t * loop)
-{
-    event_base_loopbreak(loop->event_base);
-}
+void loop_break(loop_t *loop) { event_base_loopbreak(loop->event_base); }
 
-void cb_wrapper(evutil_socket_t fd, short what, void * arg) {
-    cb_wrapper_args_t * cb_wrapper_args = arg;
-    cb_wrapper_args->callback(cb_wrapper_args->owner, fd, cb_wrapper_args->data);
+void cb_wrapper(evutil_socket_t fd, short what, void *arg) {
+  cb_wrapper_args_t *cb_wrapper_args = arg;
+  cb_wrapper_args->callback(cb_wrapper_args->owner, fd, cb_wrapper_args->data);
 }
 
 /**
@@ -208,42 +198,41 @@ void cb_wrapper(evutil_socket_t fd, short what, void * arg) {
  * \param [in] callback_data - User data to pass alongside callback invocation
  * \return 0 in case of success, -1 otherwise
  */
-int
-_loop_register_fd(loop_t * loop, int fd, void * callback_owner,
-        fd_callback_t callback, void * callback_data)
-{
-    /* This will be freed with the event */
-    cb_wrapper_args_t * cb_wrapper_args = malloc(sizeof(cb_wrapper_args_t));
-    *cb_wrapper_args = (cb_wrapper_args_t) {
-        .owner = callback_owner,
-        .callback = callback,
-        .data = callback_data,
-    };
-
-    evutil_make_socket_nonblocking(fd);
-    struct event * event = event_new(loop->event_base, fd, EV_READ | EV_PERSIST, cb_wrapper, cb_wrapper_args);
-    if (!event) {
-        ERROR("[_loop_register_fd] event_new");
-        goto ERR_EVENT_NEW;
-    }
-
-    if (event_add(event, NULL) < 0) {
-        ERROR("[_loop_register_fd] event_add");
-        goto ERR_EVENT_ADD;
-    }
-
-    if (event_map_add(loop->event_map, fd, event) < 0) {
-        ERROR("[_loop_register_fd] event_map_add");
-        goto ERR_EVENT_MAP;
-    }
-
-    return 0;
+int _loop_register_fd(loop_t *loop, int fd, void *callback_owner,
+                      fd_callback_t callback, void *callback_data) {
+  /* This will be freed with the event */
+  cb_wrapper_args_t *cb_wrapper_args = malloc(sizeof(cb_wrapper_args_t));
+  *cb_wrapper_args = (cb_wrapper_args_t){
+      .owner = callback_owner,
+      .callback = callback,
+      .data = callback_data,
+  };
+
+  evutil_make_socket_nonblocking(fd);
+  struct event *event = event_new(loop->event_base, fd, EV_READ | EV_PERSIST,
+                                  cb_wrapper, cb_wrapper_args);
+  if (!event) {
+    ERROR("[_loop_register_fd] event_new");
+    goto ERR_EVENT_NEW;
+  }
+
+  if (event_add(event, NULL) < 0) {
+    ERROR("[_loop_register_fd] event_add");
+    goto ERR_EVENT_ADD;
+  }
+
+  if (event_map_add(loop->event_map, fd, event) < 0) {
+    ERROR("[_loop_register_fd] event_map_add");
+    goto ERR_EVENT_MAP;
+  }
+
+  return 0;
 
 ERR_EVENT_MAP:
 ERR_EVENT_ADD:
-    event_free(event);
+  event_free(event);
 ERR_EVENT_NEW:
-    return -1;
+  return -1;
 }
 
 /**
@@ -251,183 +240,169 @@ ERR_EVENT_NEW:
  * \param [in] fd - File descriptor to unregister
  * \return 0 in case of success, -1 otherwise
  */
-int
-_loop_unregister_fd(loop_t * loop, int fd)
-{
-    struct event * event = NULL;
+int _loop_unregister_fd(loop_t *loop, int fd) {
+  struct event *event = NULL;
 
-    if (event_map_remove(loop->event_map, fd, &event) < 0) {
-        ERROR("[_loop_unregister_fd] Error removing event associated to fd");
-        return -1;
-    }
+  if (event_map_remove(loop->event_map, fd, &event) < 0) {
+    ERROR("[_loop_unregister_fd] Error removing event associated to fd");
+    return -1;
+  }
 
-    assert(event);
+  assert(event);
 
-    cb_wrapper_args_t * cb_wrapper_args = event_get_callback_arg(event);
-    free(cb_wrapper_args);
+  cb_wrapper_args_t *cb_wrapper_args = event_get_callback_arg(event);
+  free(cb_wrapper_args);
 
-    event_del(event);
-    event_free(event);
+  event_del(event);
+  event_free(event);
 
-    return 0;
+  return 0;
 }
 
-int
-loop_timer_callback(loop_t * loop, int fd, void * data)
-{
-    char buf[1024]; /* size is not important */
-    cb_wrapper_args_t * cb_wrapper_args = data;
-    while (read(fd, &buf, sizeof(buf)) > 0)
-        ;
+int loop_timer_callback(loop_t *loop, int fd, void *data) {
+  char buf[1024]; /* size is not important */
+  cb_wrapper_args_t *cb_wrapper_args = data;
+  while (read(fd, &buf, sizeof(buf)) > 0)
+    ;
 
-    int rc = cb_wrapper_args->callback(cb_wrapper_args->owner, fd,
-            cb_wrapper_args->data);
+  int rc = cb_wrapper_args->callback(cb_wrapper_args->owner, fd,
+                                     cb_wrapper_args->data);
 
-    return rc;
+  return rc;
 }
 
-int
-_loop_register_timer(loop_t * loop, timer_callback_data_t * timer_callback_data)
-{
-    int fd = timerfd_create(CLOCK_MONOTONIC, 0);
-    if (fd == -1) {
-        perror("timerfd_create");
-        return -1;
-    }
+int _loop_register_timer(loop_t *loop,
+                         timer_callback_data_t *timer_callback_data) {
+  int fd = timerfd_create(CLOCK_MONOTONIC, 0);
+  if (fd == -1) {
+    perror("timerfd_create");
+    return -1;
+  }
 
-    if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
-        perror("fcntl");
-        return -1;
-    }
+  if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
+    perror("fcntl");
+    return -1;
+  }
+
+  struct itimerspec ts = {
+      .it_interval =
+          {
+              .tv_sec = timer_callback_data->delay_ms / 1000,
+              .tv_nsec = (timer_callback_data->delay_ms % 1000) * 1000000,
+          },
+      .it_value = {
+          .tv_sec = timer_callback_data->delay_ms / 1000,
+          .tv_nsec = (timer_callback_data->delay_ms % 1000) * 1000000,
+      }};
+
+  if (timerfd_settime(fd, 0, &ts, NULL) == -1) {
+    perror("timerfd_settime");
+    return -1;
+  }
+
+  /* This should be freed together with the timer release */
+  cb_wrapper_args_t *cb_wrapper_args = malloc(sizeof(cb_wrapper_args_t));
+  *cb_wrapper_args = (cb_wrapper_args_t){
+      .owner = timer_callback_data->owner,
+      .callback = timer_callback_data->callback,
+      .data = timer_callback_data->data,
+  };
+
+  if (timer_fd_map_add(loop->timer_fd_map, fd, cb_wrapper_args) < 0) {
+    ERROR("[_loop_register_timer] Could not add cb_wrapper to timer map");
+    return -1;
+  }
 
-    struct itimerspec ts = {
-        .it_interval = {
-            .tv_sec = timer_callback_data->delay_ms / 1000,
-            .tv_nsec = (timer_callback_data->delay_ms % 1000) * 1000000,
-        },
-        .it_value = {
-            .tv_sec = timer_callback_data->delay_ms / 1000,
-            .tv_nsec = (timer_callback_data->delay_ms % 1000) * 1000000,
-        }
-    };
-
-    if (timerfd_settime(fd, 0, &ts, NULL) == -1) {
-        perror("timerfd_settime");
-        return -1;
-    }
+  if (_loop_register_fd(loop, fd, loop, (fd_callback_t)loop_timer_callback,
+                        cb_wrapper_args) < 0) {
+    ERROR("[_loop_register_timer] Error registering fd to event loop");
+    return -1;
+  }
 
-    /* This should be freed together with the timer release */
-    cb_wrapper_args_t * cb_wrapper_args = malloc(sizeof(cb_wrapper_args_t));
-    *cb_wrapper_args = (cb_wrapper_args_t) {
-        .owner = timer_callback_data->owner,
-            .callback = timer_callback_data->callback,
-            .data = timer_callback_data->data,
-    };
+  return fd;
+}
 
-    if (timer_fd_map_add(loop->timer_fd_map, fd, cb_wrapper_args) < 0) {
-        ERROR("[_loop_register_timer] Could not add cb_wrapper to timer map");
-        return -1;
-    }
+int _loop_unregister_timer(loop_t *loop, int fd) {
+  struct itimerspec ts = {.it_interval =
+                              {
+                                  .tv_sec = 0,
+                                  .tv_nsec = 0,
+                              },
+                          .it_value = {
+                              /* This value disables the timer */
+                              .tv_sec = 0,
+                              .tv_nsec = 0,
+                          }};
+  ts.it_value.tv_sec = 0;
+
+  if (timerfd_settime(fd, 0, &ts, NULL) == -1) {
+    perror("timerfd_settime");
+    return -1;
+  }
 
-    if (_loop_register_fd(loop, fd, loop,
-                (fd_callback_t) loop_timer_callback, cb_wrapper_args) < 0) {
-        ERROR("[_loop_register_timer] Error registering fd to event loop");
-        return -1;
-    }
+  cb_wrapper_args_t *cb_wrapper_args;
+  if (timer_fd_map_remove(loop->timer_fd_map, fd, &cb_wrapper_args) < 0) {
+    ERROR(
+        "[_loop_unregister_timer] Could not remove cb_wrapper from timer map");
+    return -1;
+  }
+  assert(cb_wrapper_args);
+  free(cb_wrapper_args);
+
+  if (_loop_unregister_fd(loop, fd) < 0) {
+    ERROR("[_loop_unregister_timer] Error unregistering fd from event loop");
+    return -1;
+  }
 
-    return fd;
+  close(fd);
+
+  return 0;
 }
 
-int
-_loop_unregister_timer(loop_t * loop, int fd)
-{
-    struct itimerspec ts = {
-        .it_interval = {
-            .tv_sec = 0,
-            .tv_nsec = 0,
-        },
-        .it_value = { /* This value disables the timer */
-            .tv_sec = 0,
-            .tv_nsec = 0,
-        }
-    };
-    ts.it_value.tv_sec = 0;
-
-    if (timerfd_settime(fd, 0, &ts, NULL) == -1) {
-        perror("timerfd_settime");
+int loop_callback(loop_t *loop, facemgr_cb_type_t type, void *data) {
+  switch (type) {
+    case FACEMGR_CB_TYPE_REGISTER_FD: {
+      fd_callback_data_t *fd_callback_data = (fd_callback_data_t *)data;
+      if (_loop_register_fd(loop, fd_callback_data->fd, fd_callback_data->owner,
+                            fd_callback_data->callback,
+                            fd_callback_data->data) < 0) {
+        ERROR("[loop_callback] Error registering fd to event loop");
         return -1;
+      }
+      break;
     }
 
-    cb_wrapper_args_t * cb_wrapper_args;
-    if (timer_fd_map_remove(loop->timer_fd_map, fd, &cb_wrapper_args) < 0) {
-        ERROR("[_loop_unregister_timer] Could not remove cb_wrapper from timer map");
+    case FACEMGR_CB_TYPE_UNREGISTER_FD: {
+      fd_callback_data_t *fd_callback_data = (fd_callback_data_t *)data;
+      /* We need a map to associate fd and events */
+      if (_loop_unregister_fd(loop, fd_callback_data->fd) < 0) {
+        ERROR("[loop_callback] Error unregistering fd from event loop");
         return -1;
+      }
+      break;
     }
-    assert(cb_wrapper_args);
-    free(cb_wrapper_args);
 
-    if (_loop_unregister_fd(loop, fd) < 0) {
-        ERROR("[_loop_unregister_timer] Error unregistering fd from event loop");
+    case FACEMGR_CB_TYPE_REGISTER_TIMER: {
+      timer_callback_data_t *timer_callback_data =
+          (timer_callback_data_t *)data;
+
+      int fd = _loop_register_timer(loop, timer_callback_data);
+      if (fd < 0) {
+        ERROR("[loop_callback] Error registering timer to event loop");
         return -1;
+      }
+      return fd;
     }
 
-    return 0;
-}
+    case FACEMGR_CB_TYPE_UNREGISTER_TIMER: {
+      int fd = *(int *)data;
 
-int
-loop_callback(loop_t * loop, facemgr_cb_type_t type, void * data)
-{
-    switch(type) {
-        case FACEMGR_CB_TYPE_REGISTER_FD:
-        {
-            fd_callback_data_t * fd_callback_data = (fd_callback_data_t *)data;
-            if (_loop_register_fd(loop, fd_callback_data->fd,
-                    fd_callback_data->owner,
-                    fd_callback_data->callback,
-                    fd_callback_data->data) < 0) {
-
-                ERROR("[loop_callback] Error registering fd to event loop");
-                return -1;
-            }
-            break;
-        }
-
-        case FACEMGR_CB_TYPE_UNREGISTER_FD:
-        {
-            fd_callback_data_t * fd_callback_data = (fd_callback_data_t *)data;
-            /* We need a map to associate fd and events */
-            if (_loop_unregister_fd(loop, fd_callback_data->fd) < 0) {
-                ERROR("[loop_callback] Error unregistering fd from event loop");
-                return -1;
-            }
-            break;
-        }
-
-        case FACEMGR_CB_TYPE_REGISTER_TIMER:
-        {
-            timer_callback_data_t * timer_callback_data = (timer_callback_data_t *)data;
-
-            int fd = _loop_register_timer(loop, timer_callback_data);
-            if (fd < 0) {
-                ERROR("[loop_callback] Error registering timer to event loop");
-                return -1;
-            }
-            return fd;
-
-        }
-
-        case FACEMGR_CB_TYPE_UNREGISTER_TIMER:
-        {
-            int fd = *(int*)data;
-
-            if (_loop_unregister_timer(loop, fd) < 0) {
-                ERROR("[loop_callback] Error unregistering timer from event loop");
-                return -1;
-            }
-            return 0;
-
-        }
+      if (_loop_unregister_timer(loop, fd) < 0) {
+        ERROR("[loop_callback] Error unregistering timer from event loop");
+        return -1;
+      }
+      return 0;
     }
-    return 0;
+  }
+  return 0;
 }
-
diff --git a/ctrl/facemgr/src/main.c b/ctrl/facemgr/src/main.c
index 344b034ae..18d2f8f7c 100644
--- a/ctrl/facemgr/src/main.c
+++ b/ctrl/facemgr/src/main.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -24,7 +24,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
-#include <unistd.h> // sleep
+#include <unistd.h>  // sleep
 
 #include <hicn/facemgr.h>
 #include <hicn/facemgr/cfg.h>
@@ -41,7 +41,7 @@
 #if 0
 static struct event_base * loop;
 #endif
-static loop_t * loop = NULL;
+static loop_t* loop = NULL;
 
 #ifdef __linux__
 #ifdef WITH_THREAD
@@ -49,210 +49,193 @@ static bool stop = false;
 #endif /* WITH_THREAD */
 #endif /* __linux__ */
 
-static struct option long_options[] =
-{
-    {"config",  required_argument, 0, 'c'},
-    {0, 0, 0, 0}
-};
+static struct option long_options[] = {{"config", required_argument, 0, 'c'},
+                                       {0, 0, 0, 0}};
 
 typedef struct {
-    char * cfgfile;
+  char* cfgfile;
 } facemgr_options_t;
 
-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");
+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");
 }
 
 void facemgr_signal_handler(int signal) {
-    fprintf(stderr, "Received ^C... quitting !\n");
-    if (loop) {
-        loop_break(loop);
+  fprintf(stderr, "Received ^C... quitting !\n");
+  if (loop) {
+    loop_break(loop);
 #ifdef __linux__
 #ifdef WITH_THREAD
     stop = true;
 #endif /* WITH_THREAD */
 #endif /* __linux__ */
-    }
+  }
 }
 
-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 = optarg;
-                break;
-            case ':':
-            case '?':
-            default:
-                usage(argv[0]);
-                exit(EXIT_FAILURE);
-        }
-
+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 = optarg;
+        break;
+      case ':':
+      case '?':
+      default:
+        usage(argv[0]);
+        exit(EXIT_FAILURE);
     }
-    return 0;
+  }
+  return 0;
 }
 
-#ifdef __linux__
-
-#endif /* __linux__ */
-
-int
-dump_facelet(const facemgr_t * facemgr, const facelet_t * facelet,
-        void * user_data)
-{
-    char facelet_s[MAXSZ_FACELET];
-    facelet_snprintf(facelet_s, MAXSZ_FACELET, facelet);
-    DEBUG("%s", facelet_s);
-    return 0;
+int dump_facelet(const facemgr_t* facemgr, const facelet_t* facelet,
+                 void* user_data) {
+  char facelet_s[MAXSZ_FACELET];
+  facelet_snprintf(facelet_s, MAXSZ_FACELET, facelet);
+  DEBUG("%s", facelet_s);
+  return 0;
 }
 
-int main(int argc, char ** argv)
-{
-    facemgr_cfg_t * cfg = NULL;
-    facemgr_t * facemgr;
+int main(int argc, char** argv) {
+  facemgr_cfg_t* cfg = NULL;
+  facemgr_t* facemgr;
 
-    struct sigaction sigIntHandler;
-    sigIntHandler.sa_handler = facemgr_signal_handler;
-    sigemptyset(&sigIntHandler.sa_mask);
-    sigIntHandler.sa_flags = 0;
-    sigaction(SIGINT, &sigIntHandler, NULL);
+  struct sigaction sigIntHandler;
+  sigIntHandler.sa_handler = facemgr_signal_handler;
+  sigemptyset(&sigIntHandler.sa_mask);
+  sigIntHandler.sa_flags = 0;
+  sigaction(SIGINT, &sigIntHandler, NULL);
 
-    char cfgfile[PATH_MAX];
+  char cfgfile[PATH_MAX];
 
-    // TODO: default < config < commandline on a per option basis
+  // 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");
-        goto ERR_CMDLINE;
-    }
+  /* Commandline */
+  facemgr_options_t cmdline_opts = {0};
+  if (parse_cmdline(argc, argv, &cmdline_opts) < 0) {
+    ERROR("Error parsing commandline");
+    goto ERR_CMDLINE;
+  }
 
-    /* Configuration file */
-    //facemgr_options_t cfgfile_opts;
+  /* Configuration file */
+  // facemgr_options_t cfgfile_opts;
 
-    if (cmdline_opts.cfgfile) {
-        if (strcasecmp(cmdline_opts.cfgfile, "none") == 0)
-            goto NO_CFGFILE;
+  if (cmdline_opts.cfgfile) {
+    if (strcasecmp(cmdline_opts.cfgfile, "none") == 0) goto NO_CFGFILE;
 
-        if (!realpath(cmdline_opts.cfgfile, (char*)&cfgfile))
-            goto ERR_PATH;
+    if (!realpath(cmdline_opts.cfgfile, (char*)&cfgfile)) goto ERR_PATH;
 
-        goto PARSE_CFGFILE;
-    }
+    goto PARSE_CFGFILE;
+  }
 
-    /* No commandline path specifed, probe default locations... */
+  /* No commandline path specifed, probe default locations... */
 
-    if (probe_cfgfile(cfgfile) < 0)
-        goto NO_CFGFILE;
+  if (probe_cfgfile(cfgfile) < 0) goto NO_CFGFILE;
 
 PARSE_CFGFILE:
 
-    DEBUG("Using configuration file %s", cfgfile);
-    cfg = facemgr_cfg_create();
-    if (!cfg)
-        goto ERR_FACEMGR_CFG;
+  DEBUG("Using configuration file %s", cfgfile);
+  cfg = facemgr_cfg_create();
+  if (!cfg) goto ERR_FACEMGR_CFG;
 
-    if (parse_config_file(cfgfile, cfg) < 0) {
-        ERROR("Error parsing configuration file %s", cfgfile);
-        goto ERR_PARSE;
-    }
+  if (parse_config_file(cfgfile, cfg) < 0) {
+    ERROR("Error parsing configuration file %s", cfgfile);
+    goto ERR_PARSE;
+  }
 
-    facemgr = facemgr_create_with_config(cfg);
-    if (!facemgr)
-        goto ERR_FACEMGR_CONFIG;
+  facemgr = facemgr_create_with_config(cfg);
+  if (!facemgr) goto ERR_FACEMGR_CONFIG;
 
-    goto MAIN_LOOP;
+  goto MAIN_LOOP;
 
 NO_CFGFILE:
 
-    facemgr = facemgr_create();
-    if (!facemgr)
-        goto ERR_FACEMGR;
+  facemgr = facemgr_create();
+  if (!facemgr) goto ERR_FACEMGR;
 
 MAIN_LOOP:
 
-    /* Main loop */
-    loop = loop_create();
-    facemgr_set_callback(facemgr, loop, (void*)loop_callback);
+  /* Main loop */
+  loop = loop_create();
+  if (!loop) {
+    ERROR("Failed to create main loop");
+    goto ERR_LOOP;
+  }
+  facemgr_set_callback(facemgr, loop, (void*)loop_callback);
 
 #ifdef __ANDROID__
-    facemgr_set_jvm(facemgr, NULL);
+  facemgr_set_jvm(facemgr, NULL);
 #endif /* __ ANDROID__ */
 
-    DEBUG("Bootstrap...");
+  DEBUG("Bootstrap...");
 
-    if (facemgr_bootstrap(facemgr) < 0 )
-        goto ERR_BOOTSTRAP;
+  if (facemgr_bootstrap(facemgr) < 0) goto ERR_BOOTSTRAP;
 
-    if (loop_dispatch(loop) < 0) {
-        ERROR("Failed to run main loop");
-        return EXIT_FAILURE;
-    }
+  if (loop_dispatch(loop) < 0) {
+    ERROR("Failed to run main loop");
+    goto ERR_DISPATCH;
+  }
 
 #ifdef __linux__
 #ifdef WITH_THREAD
-    unsigned cpt = 0;
-    while(!stop) {
-        if (cpt == 10) {
-            DEBUG("<facelets>");
+  unsigned cpt = 0;
+  while (!stop) {
+    if (cpt == 10) {
+      DEBUG("<facelets>");
 #if 1
-            facemgr_list_facelets(facemgr, dump_facelet, NULL);
+      facemgr_list_facelets(facemgr, dump_facelet, NULL);
 #else
-            char * buffer;
-            int n = facemgr_list_facelets_json(facemgr, &buffer);
-            printf("%s\n", buffer);
-            free(buffer);
+      char* buffer;
+      int n = facemgr_list_facelets_json(facemgr, &buffer);
+      printf("%s\n", buffer);
+      free(buffer);
 #endif
 
-            DEBUG("</facelets>");
-            cpt = 0;
-        }
-        usleep(500000);
-        cpt++;
+      DEBUG("</facelets>");
+      cpt = 0;
     }
+    usleep(500000);
+    cpt++;
+  }
 #endif /* WITH_THREAD */
 #endif /* __linux__ */
 
-    facemgr_stop(facemgr);
+  facemgr_stop(facemgr);
 
-    if (loop_undispatch(loop) < 0) {
-        ERROR("Failed to terminate main loop");
-        return EXIT_FAILURE;
-    }
+  if (loop_undispatch(loop) < 0) {
+    ERROR("Failed to terminate main loop");
+  }
 
-    facemgr_free(facemgr);
+  facemgr_free(facemgr);
 
-    if (cfg)
-        facemgr_cfg_free(cfg);
+  if (cfg) facemgr_cfg_free(cfg);
 
-    loop_free(loop);
+  loop_free(loop);
 
-    return EXIT_SUCCESS;
+  return EXIT_SUCCESS;
 
 ERR_BOOTSTRAP:
+  facemgr_free(facemgr);
+ERR_DISPATCH:
+  loop_free(loop);
+ERR_LOOP:
 
-    facemgr_free(facemgr);
-    loop_free(loop);
 ERR_FACEMGR_CONFIG:
 ERR_FACEMGR:
 ERR_PARSE:
-    if (cfg)
-        facemgr_cfg_free(cfg);
+  if (cfg) facemgr_cfg_free(cfg);
 ERR_FACEMGR_CFG:
 
 ERR_PATH:
 ERR_CMDLINE:
-    return EXIT_FAILURE;
-
-
+  return EXIT_FAILURE;
 }
diff --git a/ctrl/libhicnctrl/CMakeLists.txt b/ctrl/libhicnctrl/CMakeLists.txt
index 22f81401f..bf5ffd699 100644
--- a/ctrl/libhicnctrl/CMakeLists.txt
+++ b/ctrl/libhicnctrl/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,50 +11,65 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+##############################################################
+# Project and cmake version
+##############################################################
 cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
-
 project(libhicnctrl)
 
-if (NOT CMAKE_BUILD_TYPE)
-    message(STATUS "${PROJECT_NAME}: No build type selected, default to Release")
-    set(CMAKE_BUILD_TYPE "Release")
-endif()
 
+##############################################################
+# Cmake modules
+##############################################################
 set(CMAKE_MODULE_PATH
   ${CMAKE_MODULE_PATH}
   "${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/Modules"
-  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
 )
 
-include(BuildMacros)
-
-set(CMAKE_C_STANDARD 11)
-set(CMAKE_C_STANDARD_REQUIRED ON)
-
-set(CMAKE_MACOSX_RPATH ON)
-
 
+##############################################################
+# Libs and Bins names
+##############################################################
 set(LIBHICNCTRL hicnctrl)
-
 set(LIBHICNCTRL ${LIBHICNCTRL} CACHE INTERNAL "" FORCE)
 set(LIBHICNCTRL_SHARED ${LIBHICNCTRL}.shared CACHE INTERNAL "" FORCE)
 set(LIBHICNCTRL_STATIC ${LIBHICNCTRL}.static CACHE INTERNAL "" FORCE)
 set(HICNCTRL hicnctrl CACHE INTERNAL "" FORCE)
-set(LIBHICNCTRL_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/includes CACHE INTERNAL "" FORCE)
+set(LIBHICNCTRL_COMPONENT lib${LIBHICNCTRL})
+set(LIBHICNCTRL_COMPONENT_MODULES ${LIBHICNCTRL_COMPONENT}-modules)
+
+
+##############################################################
+# Packaging and versioning
+##############################################################
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../versions.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/packaging.cmake)
 
+
+##############################################################
+# C Standard
+##############################################################
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+set(CMAKE_MACOSX_RPATH ON)
+
+
+##############################################################
+# Check if building as subproject or as root project
+##############################################################
 if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-  if (BUILD_HICNPLUGIN AND "${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
-    find_package_wrapper(HicnPlugin REQUIRED)
-  endif()
+  include(CommonSetup)
 
-  find_package_wrapper(Libhicn REQUIRED)
-  list(APPEND HICN_LIBRARIES ${LIBHICN_SHARED})
+  find_package(Libhicn ${CURRENT_VERSION} REQUIRED NO_MODULE)
 
-  set(HICN_INCLUDE_DIRS
-      ${HICN_INCLUDE_DIRS}
-      ${HICNPLUGIN_INCLUDE_DIRS}
-      ${SAFE_VAPI_INCLUDE_DIRS})
+  if (DISABLE_SHARED_LIBRARIES)
+    set(LIBTYPE static)
+  else()
+    set(LIBTYPE shared)
+  endif()
 
+  list(APPEND HICN_LIBRARIES hicn::hicn.${LIBTYPE})
 else()
   if (DISABLE_SHARED_LIBRARIES)
     if (WIN32)
@@ -65,36 +80,21 @@ else()
     list(APPEND DEPENDENCIES
       ${LIBHICN_STATIC}
     )
-  elseif (BUILD_HICNPLUGIN AND "${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
-    set(
-      HICN_INCLUDE_DIRS
-      ${HICN_INCLUDE_DIRS}
-      ${HICNPLUGIN_INCLUDE_DIRS}
-      ${SAFE_VAPI_INCLUDE_DIRS}
-    )
-
-    list(APPEND DEPENDENCIES
-        hicn_plugin
-        ${SAFE_VAPI_SHARED}
-    )
   else ()
     set(HICN_LIBRARIES ${LIBHICN_SHARED})
     list(APPEND DEPENDENCIES
       ${LIBHICN_SHARED}
     )
   endif ()
-
 endif()
 
-set(LIBHICNCTRL_COMPONENT lib${LIBHICNCTRL})
-set (LIBHICNCTRL_COMPONENT_MODULES ${LIBHICNCTRL_COMPONENT}-modules)
 
+##############################################################
+# Include directories
+##############################################################
 add_subdirectory(includes)
 add_subdirectory(src)
 
-include(Packaging)
-
 if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-    include(Packager)
-    make_packages()
+  make_packages()
 endif()
diff --git a/ctrl/libhicnctrl/cmake/Modules/Packaging.cmake b/ctrl/libhicnctrl/cmake/packaging.cmake
index 2851375be..74905d6c4 100644
--- a/ctrl/libhicnctrl/cmake/Modules/Packaging.cmake
+++ b/ctrl/libhicnctrl/cmake/packaging.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -31,7 +31,7 @@ set(${LIBHICNCTRL_COMPONENT}_DEB_DEPENDENCIES
 )
 
 set(${LIBHICNCTRL_COMPONENT}-dev_DEB_DEPENDENCIES
-  "${LIBHICNCTRL_COMPONENT} (>= stable_version)"
+  "${LIBHICNCTRL_COMPONENT} (= stable_version)"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
@@ -41,16 +41,16 @@ set(${LIBHICNCTRL_COMPONENT}_RPM_DEPENDENCIES
 )
 
 set(${LIBHICNCTRL_COMPONENT}-dev_RPM_DEPENDENCIES
-  "${LIBHICNCTRL_COMPONENT} >= stable_version"
+  "${LIBHICNCTRL_COMPONENT} = stable_version"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(${LIBHICNCTRL_COMPONENT_MODULES}_DEB_DEPENDENCIES
-  "hicn-plugin (>= stable_version)"
+  "hicn-plugin (= stable_version)"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(${LIBHICNCTRL_COMPONENT_MODULES}_RPM_DEPENDENCIES
-  "hicn-plugin >= stable_version"
+  "hicn-plugin = stable_version"
   CACHE STRING "Dependencies for deb/rpm package."
 )
diff --git a/ctrl/libhicnctrl/examples/create_face.c b/ctrl/libhicnctrl/examples/create_face.c
index 5f92f5906..ebd451de1 100644
--- a/ctrl/libhicnctrl/examples/create_face.c
+++ b/ctrl/libhicnctrl/examples/create_face.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -22,125 +22,122 @@
  */
 
 #include <stdlib.h>
-#include <sys/types.h> // getifaddrs
-#include <ifaddrs.h> // getifaddrs
+#include <sys/types.h>  // getifaddrs
+#include <ifaddrs.h>    // getifaddrs
 #include <stdio.h>
-#include <string.h> /* for strncpy */
-#include <sys/socket.h> // socket
-#include <sys/ioctl.h> // ioctl
+#include <sys/socket.h>  // socket
+#include <sys/ioctl.h>   // ioctl
 #include <unistd.h>
 
 #include <hicn/ctrl.h>
 #include <hicn/util/log.h>
 
-int get_local_info(char * if_name, ip_address_t * local_ip) {
-    struct ifaddrs *addrs;
-    struct ifreq ifr = {
-        .ifr_addr.sa_family = AF_INET,
-    };
-    int ret = -1;
-
-    int fd = socket(AF_INET, SOCK_DGRAM, 0);
-
-    getifaddrs(&addrs);
-
-    for (struct ifaddrs * tmp = addrs; tmp; tmp = tmp->ifa_next) {
-        if (!tmp->ifa_addr || tmp->ifa_addr->sa_family != AF_PACKET)
-            continue;
-        if (strcmp(tmp->ifa_name, "lo") == 0)
-            continue;
-        snprintf(if_name, IFNAMSIZ, "%s", tmp->ifa_name);
-
-        snprintf(ifr.ifr_name, IFNAMSIZ, "%s", tmp->ifa_name);
-        if (ioctl(fd, SIOCGIFADDR, &ifr) == -1) {
-            //perror("ioctl");
-            continue;
-        }
-
-        *local_ip = IP_ADDRESS_EMPTY;
-        local_ip->v4.as_inaddr = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
-        if (ip_address_empty(local_ip))
-            continue;
-
-        ret = 0;
-        break;
-    }
-
-    freeifaddrs(addrs);
-    close(fd);
-    return ret;
-}
+int get_local_info(char *if_name, ip_address_t *local_ip) {
+  struct ifaddrs *addrs;
+  struct ifreq ifr = {
+      .ifr_addr.sa_family = AF_INET,
+  };
+  int ret = -1;
 
-int main() {
-    char remote_ip_str[INET_ADDRSTRLEN] = "1.1.1.1";
+  int fd = socket(AF_INET, SOCK_DGRAM, 0);
 
-    ip_address_t local_ip;
-    ip_address_t remote_ip;
-    char if_name[IFNAMSIZ];
+  getifaddrs(&addrs);
 
-    /* Retrieving local info */
+  for (struct ifaddrs *tmp = addrs; tmp; tmp = tmp->ifa_next) {
+    if (!tmp->ifa_addr || tmp->ifa_addr->sa_family != AF_PACKET) continue;
+    if (strcmp(tmp->ifa_name, "lo") == 0) continue;
+    snprintf(if_name, IFNAMSIZ, "%s", tmp->ifa_name);
 
-    if (get_local_info(if_name, &local_ip) < 0) {
-        DEBUG("Error getting local information");
-        goto ERR_INIT;
+    snprintf(ifr.ifr_name, IFNAMSIZ, "%s", tmp->ifa_name);
+    if (ioctl(fd, SIOCGIFADDR, &ifr) == -1) {
+      // perror("ioctl");
+      continue;
     }
 
-    char local_ip_str[MAXSZ_IP_ADDRESS];
-    ip_address_snprintf(local_ip_str, MAXSZ_IP_ADDRESS, &local_ip, AF_INET);
-    DEBUG("Local information :");
-    DEBUG("  - Interface name : %s", if_name);
-    DEBUG("  - IP address     : %s", local_ip_str);
+    *local_ip = IP_ADDRESS_EMPTY;
+    local_ip->v4.as_inaddr = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
+    if (ip_address_empty(local_ip)) continue;
 
-    if (ip_address_pton (remote_ip_str, &remote_ip) < 0){
-        DEBUG("Error parsing remote IP address");
-        goto ERR_INIT;
-    }
+    ret = 0;
+    break;
+  }
+
+  freeifaddrs(addrs);
+  close(fd);
+  return ret;
+}
 
-    /* Filling face information */
-    hc_face_t face = {
-        .face = {
-            .type = FACE_TYPE_UDP,
-            .family = AF_INET,
-            .local_addr = local_ip,
-            .remote_addr = remote_ip,
-            .local_port = 6000,
-            .remote_port = 6000,
-            .admin_state = FACE_STATE_UNDEFINED,
-            .state = FACE_STATE_UNDEFINED,
+int main() {
+  char remote_ip_str[INET_ADDRSTRLEN] = "1.1.1.1";
+
+  ip_address_t local_ip;
+  ip_address_t remote_ip;
+  char if_name[IFNAMSIZ];
+
+  /* Retrieving local info */
+
+  if (get_local_info(if_name, &local_ip) < 0) {
+    DEBUG("Error getting local information");
+    goto ERR_INIT;
+  }
+
+  char local_ip_str[MAXSZ_IP_ADDRESS];
+  ip_address_snprintf(local_ip_str, MAXSZ_IP_ADDRESS, &local_ip, AF_INET);
+  DEBUG("Local information :");
+  DEBUG("  - Interface name : %s", if_name);
+  DEBUG("  - IP address     : %s", local_ip_str);
+
+  if (ip_address_pton(remote_ip_str, &remote_ip) < 0) {
+    DEBUG("Error parsing remote IP address");
+    goto ERR_INIT;
+  }
+
+  /* Filling face information */
+  hc_face_t face = {
+      .face =
+          {
+              .type = FACE_TYPE_UDP,
+              .family = AF_INET,
+              .local_addr = local_ip,
+              .remote_addr = remote_ip,
+              .local_port = 6000,
+              .remote_port = 6000,
+              .admin_state = FACE_STATE_UNDEFINED,
+              .state = FACE_STATE_UNDEFINED,
 #ifdef WITH_POLICY
-            .priority = 0,
-            .tags = POLICY_TAGS_EMPTY,
+              .priority = 0,
+              .tags = POLICY_TAGS_EMPTY,
 #endif /* WITH_POLICY */
-        },
-    };
-    if (netdevice_set_name(&face.face.netdevice, if_name) < 0) {
-        DEBUG("Error setting face netdevice name");
-        goto ERR_INIT;
-    }
+          },
+  };
+  if (netdevice_set_name(&face.face.netdevice, if_name) < 0) {
+    DEBUG("Error setting face netdevice name");
+    goto ERR_INIT;
+  }
 
-    /* Connecting to socket and creating face */
+  /* Connecting to socket and creating face */
 
-    hc_sock_t * socket = hc_sock_create();
-    if (!socket){
-        DEBUG("Error creating libhicnctrl socket");
-        goto ERR_SOCK;
-    }
+  hc_sock_t *socket = hc_sock_create();
+  if (!socket) {
+    DEBUG("Error creating libhicnctrl socket");
+    goto ERR_SOCK;
+  }
 
-    if (hc_sock_connect(socket) < 0){
-        DEBUG("Error connecting to forwarder");
-        goto ERR;
-    }
+  if (hc_sock_connect(socket) < 0) {
+    DEBUG("Error connecting to forwarder");
+    goto ERR;
+  }
 
-    if (hc_face_create(socket, &face) < 0){
-        DEBUG("Error creating face");
-        goto ERR;
-    }
+  if (hc_face_create(socket, &face) < 0) {
+    DEBUG("Error creating face");
+    goto ERR;
+  }
 
-    DEBUG("Face created successfully");
+  DEBUG("Face created successfully");
 
 ERR:
-    hc_sock_free(socket);
+  hc_sock_free(socket);
 ERR_SOCK:
 ERR_INIT:
-    return 0;
+  return 0;
 }
diff --git a/ctrl/libhicnctrl/examples/update_priority.c b/ctrl/libhicnctrl/examples/update_priority.c
index d350f71c9..bbe174c2f 100644
--- a/ctrl/libhicnctrl/examples/update_priority.c
+++ b/ctrl/libhicnctrl/examples/update_priority.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -24,37 +24,36 @@
 #include <hicn/ctrl.h>
 #include <hicn/util/log.h>
 
-int main(int argc, char **argv)
-{
-    if (argc != 3) {
-        fprintf(stderr, "Usage: %s FACE_ID PRIORITY\n", argv[0]);
-        exit(EXIT_FAILURE);
-    }
-    unsigned face_id = atoi(argv[1]);
-    unsigned priority = atoi(argv[2]);
-    char face_id_s[SYMBOLIC_NAME_LEN];
-
-    hc_sock_t * socket = hc_sock_create();
-    if (!socket){
-        DEBUG("Error creating libhicnctrl socket");
-        goto ERR_SOCK;
-    }
-
-    if (hc_sock_connect(socket) < 0){
-        DEBUG("Error connecting to forwarder");
-        goto ERR;
-    }
-
-    snprintf(face_id_s, SYMBOLIC_NAME_LEN, "%d", face_id);
-    if (hc_face_set_priority(socket, face_id_s, priority) < 0) {
-        DEBUG("Error setting face priority");
-        goto ERR;
-    }
-
-    DEBUG("Face priority updated successfully");
+int main(int argc, char **argv) {
+  if (argc != 3) {
+    fprintf(stderr, "Usage: %s FACE_ID PRIORITY\n", argv[0]);
+    exit(EXIT_FAILURE);
+  }
+  unsigned face_id = atoi(argv[1]);
+  unsigned priority = atoi(argv[2]);
+  char face_id_s[SYMBOLIC_NAME_LEN];
+
+  hc_sock_t *socket = hc_sock_create();
+  if (!socket) {
+    DEBUG("Error creating libhicnctrl socket");
+    goto ERR_SOCK;
+  }
+
+  if (hc_sock_connect(socket) < 0) {
+    DEBUG("Error connecting to forwarder");
+    goto ERR;
+  }
+
+  snprintf(face_id_s, SYMBOLIC_NAME_LEN, "%d", face_id);
+  if (hc_face_set_priority(socket, face_id_s, priority) < 0) {
+    DEBUG("Error setting face priority");
+    goto ERR;
+  }
+
+  DEBUG("Face priority updated successfully");
 
 ERR:
-    hc_sock_free(socket);
+  hc_sock_free(socket);
 ERR_SOCK:
-    return 0;
+  return 0;
 }
diff --git a/ctrl/libhicnctrl/includes/CMakeLists.txt b/ctrl/libhicnctrl/includes/CMakeLists.txt
index 50cfa4ad5..1a90690a4 100644
--- a/ctrl/libhicnctrl/includes/CMakeLists.txt
+++ b/ctrl/libhicnctrl/includes/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,17 +11,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-set(LIBHICNCTRL_INCLUDE_DIRS
-  ${CMAKE_CURRENT_SOURCE_DIR} ""
+##############################################################
+# Public headers directory
+##############################################################
+set(Libhicnctrl_INCLUDE_DIRS
+  ${CMAKE_CURRENT_SOURCE_DIR}
   CACHE INTERNAL
   "" FORCE
 )
 
+
+##############################################################
+# To install header files
+##############################################################
 set(TO_INSTALL_HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/ctrl.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/ctrl/api.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/hicn/ctrl/commands.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/hicn/ctrl/face.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn/ctrl/hicn-light.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn/ctrl/hicn-light-ng.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/ctrl/route.h
   PARENT_SCOPE
 )
diff --git a/ctrl/libhicnctrl/includes/ctrl.h b/ctrl/libhicnctrl/includes/ctrl.h
index e61b7a482..477afd152 100644
--- a/ctrl/libhicnctrl/includes/ctrl.h
+++ b/ctrl/libhicnctrl/includes/ctrl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/ctrl/libhicnctrl/includes/hicn/ctrl.h b/ctrl/libhicnctrl/includes/hicn/ctrl.h
index e61b7a482..477afd152 100644
--- a/ctrl/libhicnctrl/includes/hicn/ctrl.h
+++ b/ctrl/libhicnctrl/includes/hicn/ctrl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/ctrl/libhicnctrl/includes/hicn/ctrl/api.h b/ctrl/libhicnctrl/includes/hicn/ctrl/api.h
index b5a968800..8a59cf4d8 100644
--- a/ctrl/libhicnctrl/includes/hicn/ctrl/api.h
+++ b/ctrl/libhicnctrl/includes/hicn/ctrl/api.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -67,15 +67,24 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include <stddef.h>  // object_offset_t
 
 #include <hicn/util/ip_address.h>
-#include <hicn/ctrl/commands.h>
-#include "face.h"
+#include <hicn/face.h>
+#include <hicn/strategy.h>
+/*
+ * This has to be common between hicn-light and hicn-plugin. We now we keep the
+ * minimum of the two
+ */
+#define SYMBOLIC_NAME_LEN 16
 
 #define HICN_DEFAULT_PORT 9695
 
 #define HOTFIXMARGIN 0
 
+#define INVALID_FACE_ID ~0
+#define INVALID_NETDEVICE_ID ~0
+
 /**
  * \brief Defines the default size for the allocated data arrays holding the
  * results of API calls.
@@ -99,26 +108,70 @@
  * Message helper types and aliases
  ******************************************************************************/
 
-#define foreach_command \
-  _(UNDEFINED)          \
-  _(CREATE)             \
-  _(UPDATE)             \
-  _(DELETE)             \
-  _(LIST)               \
-  _(SET)                \
+/* Action */
+
+#define foreach_action \
+  _(UNDEFINED)         \
+  _(CREATE)            \
+  _(UPDATE)            \
+  _(DELETE)            \
+  _(LIST)              \
+  _(SET)               \
+  _(SERVE)             \
+  _(STORE)             \
+  _(CLEAR)             \
   _(N)
 
 typedef enum {
 #define _(x) ACTION_##x,
-  foreach_command
+  foreach_action
 #undef _
 } hc_action_t;
 
+extern const char *action_str[];
+
+#define action_str(x) action_str[x]
+
+hc_action_t action_from_str(const char *action_str);
+
+/* Object type */
+
+#define foreach_object \
+  _(UNDEFINED)         \
+  _(CONNECTION)        \
+  _(LISTENER)          \
+  _(ROUTE)             \
+  _(FACE)              \
+  _(STRATEGY)          \
+  _(PUNTING)           \
+  _(POLICY)            \
+  _(CACHE)             \
+  _(MAPME)             \
+  _(LOCAL_PREFIX)      \
+  _(PROBE)             \
+  _(SUBSCRIPTION)      \
+  _(N)
+
+typedef enum {
+#define _(x) OBJECT_##x,
+  foreach_object
+#undef _
+} hc_object_type_t;
+
+extern const char *object_str[];
+
+#define object_str(x) object_str[x]
+
+hc_object_type_t object_from_str(const char *object_str);
+
+#define IS_VALID_OBJECT_TYPE(x) IS_VALID_ENUM_TYPE(OBJECT, x)
+#define IS_VALID_ACTION(x) IS_VALID_ENUM_TYPE(ACTION, x)
+
 /**
  * \brief hICN control message header
  */
 typedef struct hc_msg_s hc_msg_t;
-
+typedef struct hc_result_s hc_result_t;
 /******************************************************************************
  * Control Data
  ******************************************************************************/
@@ -140,7 +193,8 @@ typedef struct hc_data_s {
   bool complete;
 
   /* Callbacks */
-  data_callback_t complete_cb;  // XXX int (*complete_cb)(struct hc_data_s * data);
+  data_callback_t
+      complete_cb;  // XXX int (*complete_cb)(struct hc_data_s * data);
   void *complete_cb_data;
   int ret;
 } hc_data_t;
@@ -149,7 +203,8 @@ typedef struct hc_data_s {
  * Create a structure holding the results of an hICN control request.
  * \result The newly create data structure.
  */
-hc_data_t *hc_data_create(size_t in_element_size, size_t out_element_size, data_callback_t complete_cb);
+hc_data_t *hc_data_create(size_t in_element_size, size_t out_element_size,
+                          data_callback_t complete_cb);
 
 /**
  * Free a structure holding the results of an hICN control request.
@@ -214,38 +269,49 @@ int hc_data_reset(hc_data_t *data);
  * \param [out] found - A pointer to the element, or NULL if not found.
  * \return Error code
  */
-#define GENERATE_FIND_HEADER(TYPE)                                          \
-int                                                                         \
-hc_ ## TYPE ## _find(hc_data_t * data, const hc_ ## TYPE ## _t * element,   \
-        hc_ ## TYPE ## _t **found)
-
-#define GENERATE_FIND(TYPE)                                                 \
-int                                                                         \
-hc_ ## TYPE ## _find(hc_data_t * data, const hc_ ## TYPE ## _t * element,   \
-        hc_ ## TYPE ## _t **found)                                          \
-{                                                                           \
-    foreach_type(hc_ ## TYPE ## _t, x, data) {                              \
-        if (hc_ ## TYPE ## _cmp(x, element) == 0) {                         \
-            *found = x;                                                     \
-            return 0;                                                       \
-        }                                                                   \
-    };                                                                      \
-    *found = NULL; /* this is optional */                                   \
-    return 0;                                                               \
-}
+#define GENERATE_FIND_HEADER(TYPE)                                    \
+  int hc_##TYPE##_find(hc_data_t *data, const hc_##TYPE##_t *element, \
+                       hc_##TYPE##_t **found)
+
+#define GENERATE_FIND(TYPE)                                           \
+  int hc_##TYPE##_find(hc_data_t *data, const hc_##TYPE##_t *element, \
+                       hc_##TYPE##_t **found) {                       \
+    foreach_type(hc_##TYPE##_t, x, data) {                            \
+      if (hc_##TYPE##_cmp(x, element) == 0) {                         \
+        *found = x;                                                   \
+        return 0;                                                     \
+      }                                                               \
+    };                                                                \
+    *found = NULL; /* this is optional */                             \
+    return 0;                                                         \
+  }
 
 /******************************************************************************
  * Control socket
  ******************************************************************************/
 
-/* This should be at least equal to the maximum packet size */
-#define RECV_BUFLEN 8192
+/* With UDP, the buffer should be able to receieve a full packet, and thus MTU
+ * (max 9000) is sufficient. Messages will be received fully one by one.
+ * With TCP, the buffer should be at least able to receive a message header and
+ * the maximum size of a data element, so any reasonable size will be correct,
+ * it might just optimize performance. Messages might arrive in chunks that the
+ * library is able to parse.
+ */
+#define JUMBO_MTU 9000
+#define RECV_BUFLEN 65535
+
+#define foreach_forwarder_type \
+  _(UNDEFINED)                 \
+  _(HICNLIGHT)                 \
+  _(HICNLIGHT_NG)              \
+  _(VPP)                       \
+  _(N)
 
 typedef enum {
-  HICNLIGHT,
-  VPP,
-  UNDEFINED
-} forwarder_t;
+#define _(x) x,
+  foreach_forwarder_type
+#undef _
+} forwarder_type_t;
 
 /**
  * \brief Holds the state of an hICN control socket
@@ -257,22 +323,26 @@ typedef struct hc_sock_s hc_sock_t;
  * \param [in] url - The URL to connect to.
  * \return an hICN control socket
  */
-hc_sock_t *
-hc_sock_create_url(const char * url);
+hc_sock_t *hc_sock_create_url(const char *url);
 
 /**
  * \brief Create an hICN control socket using the provided forwarder.
  * \return an hICN control socket
  */
-hc_sock_t *
-hc_sock_create_forwarder(forwarder_t forwarder);
+hc_sock_t *hc_sock_create_forwarder(forwarder_type_t forwarder);
+
+/**
+ * \brief Create an hICN control socket using the provided forwarder and a URL.
+ * \return an hICN control socket
+ */
+hc_sock_t *hc_sock_create_forwarder_url(forwarder_type_t forwarder,
+                                        const char *url);
 
 /**
  * \brief Create an hICN control socket using the default connection type.
  * \return an hICN control socket
  */
-hc_sock_t *
-hc_sock_create(void);
+hc_sock_t *hc_sock_create(void);
 
 /**
  * \brief Frees an hICN control socket
@@ -324,7 +394,7 @@ int hc_sock_get_available(hc_sock_t *s, u8 **buffer, size_t *size);
  * \param [in] msglen - Length of the message to send
  * \return Error code
  */
-int hc_sock_send(hc_sock_t *s, hc_msg_t *msg, size_t msglen, int seq);
+int hc_sock_send(hc_sock_t *s, hc_msg_t *msg, size_t msglen, uint32_t seq);
 
 /**
  * \brief Helper for reading socket contents
@@ -356,6 +426,13 @@ int hc_sock_callback(hc_sock_t *s, hc_data_t **data);
  */
 int hc_sock_reset(hc_sock_t *s);
 
+void hc_sock_increment_woff(hc_sock_t *s, size_t bytes);
+
+int hc_sock_prepare_send(hc_sock_t *s, hc_result_t *result,
+                         data_callback_t complete_cb, void *complete_cb_data);
+
+int hc_sock_set_recv_timeout_ms(hc_sock_t *s, long timeout_ms);
+
 /******************************************************************************
  * Command-specific structures and functions
  ******************************************************************************/
@@ -420,50 +497,11 @@ int hc_sock_reset(hc_sock_t *s);
        VAR < (TYPE *)(data->buffer + data->size * data->out_element_size); \
        VAR++)
 
-/**
- * New type is defined to reconciliate different enum for add and list.
- * Also, values not implemented have been removed for clarity.
- */
-#define foreach_connection_type \
-  _(UNDEFINED)                  \
-  _(TCP)                        \
-  _(UDP)                        \
-  _(HICN)                       \
-  _(N)
-
-typedef enum {
-#define _(x) CONNECTION_TYPE_##x,
-  foreach_connection_type
-#undef _
-} hc_connection_type_t;
-
-#define MAXSZ_HC_CONNECTION_TYPE_ 9
-#define MAXSZ_HC_CONNECTION_TYPE MAXSZ_HC_CONNECTION_TYPE_ + NULLTERM + HOTFIXMARGIN
-
-extern const char *connection_type_str[];
-
-hc_connection_type_t connection_type_from_str(const char *str);
-
-/* Same order as connection_state_t in hicn/core/connectionState.h */
-#define foreach_connection_state \
-  _(UNDEFINED)                   \
-  _(DOWN)                        \
-  _(UP)                          \
-  _(N)
-
-typedef enum {
-#define _(x) HC_CONNECTION_STATE_##x,
-  foreach_connection_state
-#undef _
-} hc_connection_state_t;
-
-#define MAXSZ_HC_CONNECTION_STATE_ 9
-#define MAXSZ_HC_CONNECTION_STATE MAXSZ_HC_CONNECTION_STATE_ + NULLTERM
-
-extern const char *connection_state_str[];
-
 typedef int (*HC_PARSE)(const u8 *, u8 *);
 
+#define INPUT_ERROR -2
+#define UNSUPPORTED_CMD_ERROR -3
+
 /*----------------------------------------------------------------------------*
  * Listeners
  *----------------------------------------------------------------------------*/
@@ -473,27 +511,28 @@ typedef struct {
   char name[SYMBOLIC_NAME_LEN]; /* K.w */  // XXX clarify what used for
   char interface_name[INTERFACE_LEN];      /* Kr. */
   u32 id;
-  hc_connection_type_t type; /* .rw */
-  int family;                /* .rw */
-  ip_address_t local_addr;   /* .rw */
-  u16 local_port;            /* .rw */
+  face_type_t type;        /* .rw */
+  int family;              /* .rw */
+  ip_address_t local_addr; /* .rw */
+  u16 local_port;          /* .rw */
 } hc_listener_t;
 
 int hc_listener_create(hc_sock_t *s, hc_listener_t *listener);
 /* listener_found might eventually be allocated, and needs to be freed */
+hc_result_t *hc_listener_create_conf(hc_sock_t *s, hc_listener_t *listener);
 int hc_listener_get(hc_sock_t *s, hc_listener_t *listener,
                     hc_listener_t **listener_found);
 int hc_listener_delete(hc_sock_t *s, hc_listener_t *listener);
 int hc_listener_list(hc_sock_t *s, hc_data_t **pdata);
+hc_result_t *hc_listener_list_conf(hc_sock_t *s);
 
 int hc_listener_validate(const hc_listener_t *listener);
 int hc_listener_cmp(const hc_listener_t *l1, const hc_listener_t *l2);
-int hc_listener_parse(void *in, hc_listener_t *listener);
 
 #define foreach_listener(VAR, data) foreach_type(hc_listener_t, VAR, data)
 
 #define MAXSZ_HC_LISTENER_ \
-  INTERFACE_LEN + SPACE + MAXSZ_URL_ + SPACE + MAXSZ_HC_CONNECTION_TYPE_
+  INTERFACE_LEN + SPACE + MAXSZ_URL_ + SPACE + MAXSZ_FACE_TYPE_
 #define MAXSZ_HC_LISTENER MAXSZ_HC_LISTENER_ + NULLTERM
 
 GENERATE_FIND_HEADER(listener);
@@ -506,28 +545,30 @@ int hc_listener_snprintf(char *s, size_t size, hc_listener_t *listener);
 
 /*
  * NOTE :
- *  - interface_name is mainly used to derive listeners from connections, but is
- *  not itself used to create connections.
+ *  - interface_name is mainly used to derive listeners from connections,
+ * but is not itself used to create connections.
  */
 typedef struct {
   u32 id;                             /* Kr. */
   char name[SYMBOLIC_NAME_LEN];       /* K.w */
   char interface_name[INTERFACE_LEN]; /* Kr. */
-  hc_connection_type_t type;          /* .rw */
+  face_type_t type;                   /* .rw */
   int family;                         /* .rw */
   ip_address_t local_addr;            /* .rw */
   u16 local_port;                     /* .rw */
   ip_address_t remote_addr;           /* .rw */
   u16 remote_port;                    /* .rw */
-  hc_connection_state_t admin_state;  /* .rw */
+  face_state_t admin_state;           /* .rw */
 #ifdef WITH_POLICY
-    uint32_t priority;           /* .rw */
-    policy_tags_t tags;          /* .rw */
-#endif /* WITH_POLICY */
-    hc_connection_state_t state; /* .r. */
+  uint32_t priority;  /* .rw */
+  policy_tags_t tags; /* .rw */
+#endif                /* WITH_POLICY */
+  face_state_t state; /* .r. */
 } hc_connection_t;
 
 int hc_connection_create(hc_sock_t *s, hc_connection_t *connection);
+hc_result_t *hc_connection_create_conf(hc_sock_t *s,
+                                       hc_connection_t *connection);
 /* connection_found will be allocated, and must be freed */
 int hc_connection_get(hc_sock_t *s, hc_connection_t *connection,
                       hc_connection_t **connection_found);
@@ -536,6 +577,8 @@ int hc_connection_update_by_id(hc_sock_t *s, int hc_connection_id,
 int hc_connection_update(hc_sock_t *s, hc_connection_t *connection_current,
                          hc_connection_t *connection_updated);
 int hc_connection_delete(hc_sock_t *s, hc_connection_t *connection);
+hc_result_t *hc_connection_delete_conf(hc_sock_t *s,
+                                       hc_connection_t *connection);
 /*
 int hc_connection_remove_by_id(hc_sock_t * s, char * name);
 int hc_connection_remove_by_name(hc_sock_t * s, char * name);
@@ -544,19 +587,21 @@ int hc_connection_list(hc_sock_t *s, hc_data_t **pdata);
 
 int hc_connection_validate(const hc_connection_t *connection);
 int hc_connection_cmp(const hc_connection_t *c1, const hc_connection_t *c2);
-int hc_connection_parse(void *in, hc_connection_t *connection);
 
-int hc_connection_set_admin_state(hc_sock_t * s, const char * conn_id_or_name, face_state_t state);
+int hc_connection_set_admin_state(hc_sock_t *s, const char *conn_id_or_name,
+                                  face_state_t state);
 #ifdef WITH_POLICY
-int hc_connection_set_priority(hc_sock_t * s, const char * conn_id_or_name, uint32_t priority);
-int hc_connection_set_tags(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t tags);
+int hc_connection_set_priority(hc_sock_t *s, const char *conn_id_or_name,
+                               uint32_t priority);
+int hc_connection_set_tags(hc_sock_t *s, const char *conn_id_or_name,
+                           policy_tags_t tags);
 #endif /* WITH_POLICY */
 
 #define foreach_connection(VAR, data) foreach_type(hc_connection_t, VAR, data)
 
-#define MAXSZ_HC_CONNECTION_                                            \
-  MAXSZ_HC_CONNECTION_STATE_ + INTERFACE_LEN + SPACE + 2 * MAXSZ_URL_ + \
-      MAXSZ_HC_CONNECTION_TYPE_ + SPACES(3)
+#define MAXSZ_HC_CONNECTION_                                   \
+  MAXSZ_FACE_STATE_ + INTERFACE_LEN + SPACE + 2 * MAXSZ_URL_ + \
+      MAXSZ_FACE_TYPE_ + SPACES(3)
 #define MAXSZ_HC_CONNECTION MAXSZ_HC_CONNECTION_ + NULLTERM
 
 GENERATE_FIND_HEADER(connection);
@@ -591,14 +636,17 @@ typedef struct {
  */
 int hc_face_create(hc_sock_t *s, hc_face_t *face);
 int hc_face_get(hc_sock_t *s, hc_face_t *face, hc_face_t **face_found);
-int hc_face_delete(hc_sock_t *s, hc_face_t *face);
+int hc_face_delete(hc_sock_t *s, hc_face_t *face, uint8_t delete_listener);
 int hc_face_list(hc_sock_t *s, hc_data_t **pdata);
 int hc_face_list_async(hc_sock_t *s);  //, hc_data_t ** pdata);
 
-int hc_face_set_admin_state(hc_sock_t * s, const char * conn_id_or_name, face_state_t state);
+int hc_face_set_admin_state(hc_sock_t *s, const char *conn_id_or_name,
+                            face_state_t state);
 #ifdef WITH_POLICY
-int hc_face_set_priority(hc_sock_t * s, const char * conn_id_or_name, uint32_t priority);
-int hc_face_set_tags(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t tags);
+int hc_face_set_priority(hc_sock_t *s, const char *conn_id_or_name,
+                         uint32_t priority);
+int hc_face_set_tags(hc_sock_t *s, const char *conn_id_or_name,
+                     policy_tags_t tags);
 #endif /* WITH_POLICY */
 
 #define foreach_face(VAR, data) foreach_type(hc_face_t, VAR, data)
@@ -609,7 +657,8 @@ int hc_face_set_tags(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t
 #define MAXSZ_FACE_NAME_ SYMBOLIC_NAME_LEN
 #define MAXSZ_FACE_NAME MAXSZ_FACE_NAME_ + NULLTERM
 
-#define MAXSZ_HC_FACE_ MAXSZ_FACE_ID_ + MAXSZ_FACE_NAME_ + MAXSZ_FACE_ + 5 + HOTFIXMARGIN
+#define MAXSZ_HC_FACE_ \
+  MAXSZ_FACE_ID_ + MAXSZ_FACE_NAME_ + MAXSZ_FACE_ + 5 + HOTFIXMARGIN
 #define MAXSZ_HC_FACE MAXSZ_HC_FACE_ + NULLTERM
 
 int hc_face_snprintf(char *s, size_t size, hc_face_t *face);
@@ -619,20 +668,20 @@ int hc_face_snprintf(char *s, size_t size, hc_face_t *face);
  *----------------------------------------------------------------------------*/
 
 typedef struct {
-  face_id_t face_id;               /* Kr. */
-  int family;               /* Krw */
-  ip_address_t remote_addr; /* krw */
-  u8 len;                   /* krw */
-  u16 cost;                 /* .rw */
-  hc_face_t face;
+  face_id_t face_id;            /* Kr.  use when name == NULL */
+  char name[SYMBOLIC_NAME_LEN]; /* Kr.  use by default vs face_id */
+  int family;                   /* Krw */
+  ip_address_t remote_addr;     /* krw */
+  u8 len;                       /* krw */
+  u16 cost;                     /* .rw */
+  hc_face_t face;               /* TODO remove, used by hicn_plugin_api */
 } hc_route_t;
 
-int hc_route_parse(void *in, hc_route_t *route);
-
-int hc_route_create(hc_sock_t * s, hc_route_t * route);
-int hc_route_delete(hc_sock_t * s, hc_route_t * route);
-int hc_route_list(hc_sock_t * s, hc_data_t ** pdata);
-int hc_route_list_async(hc_sock_t * s);
+int hc_route_create(hc_sock_t *s, hc_route_t *route);
+hc_result_t *hc_route_create_conf(hc_sock_t *s, hc_route_t *route);
+int hc_route_delete(hc_sock_t *s, hc_route_t *route);
+int hc_route_list(hc_sock_t *s, hc_data_t **pdata);
+int hc_route_list_async(hc_sock_t *s);
 
 #define foreach_route(VAR, data) foreach_type(hc_route_t, VAR, data)
 
@@ -646,6 +695,7 @@ int hc_route_list_async(hc_sock_t * s);
 #define MAXSZ_HC_ROUTE MAXSZ_HC_ROUTE_ + NULLTERM
 
 int hc_route_snprintf(char *s, size_t size, hc_route_t *route);
+int hc_route_validate(const hc_route_t *route);
 
 /*----------------------------------------------------------------------------*
  * Punting
@@ -653,9 +703,9 @@ int hc_route_snprintf(char *s, size_t size, hc_route_t *route);
 
 typedef struct {
   face_id_t face_id; /* Kr. */  // XXX listener id, could be NULL for all ?
-  int family;            /* Krw */
-  ip_address_t prefix;   /* krw */
-  u8 prefix_len;         /* krw */
+  int family;                   /* Krw */
+  ip_address_t prefix;          /* krw */
+  u8 prefix_len;                /* krw */
 } hc_punting_t;
 
 int hc_punting_create(hc_sock_t *s, hc_punting_t *punting);
@@ -666,7 +716,6 @@ int hc_punting_list(hc_sock_t *s, hc_data_t **pdata);
 
 int hc_punting_validate(const hc_punting_t *punting);
 int hc_punting_cmp(const hc_punting_t *c1, const hc_punting_t *c2);
-int hc_punting_parse(void *in, hc_punting_t *punting);
 
 #define foreach_punting(VAR, data) foreach_type(hc_punting_t, VAR, data)
 
@@ -681,8 +730,23 @@ int hc_punting_snprintf(char *s, size_t size, hc_punting_t *punting);
  * Cache
  *----------------------------------------------------------------------------*/
 
-int hc_cache_set_store(hc_sock_t *s, int enabled);
-int hc_cache_set_serve(hc_sock_t *s, int enabled);
+typedef struct {
+  uint8_t serve;  // 1 = on, 0 = off
+  uint8_t store;  // 1 = on, 0 = off
+} hc_cache_t;
+
+typedef struct {
+  bool store;
+  bool serve;
+  size_t cs_size;
+  size_t num_stale_entries;
+} hc_cache_info_t;
+
+int hc_cache_set_store(hc_sock_t *s, hc_cache_t *cache);
+int hc_cache_set_serve(hc_sock_t *s, hc_cache_t *cache);
+int hc_cache_clear(hc_sock_t *s, hc_cache_t *cache);
+int hc_cache_list(hc_sock_t *s, hc_data_t **pdata);
+int hc_cache_snprintf(char *s, size_t size, const hc_cache_info_t *cache_info);
 
 /*----------------------------------------------------------------------------*
  * Strategy
@@ -691,7 +755,13 @@ int hc_cache_set_serve(hc_sock_t *s, int enabled);
 #define MAXSZ_STRATEGY_NAME 255
 
 typedef struct {
+  // The name is not set by the controller
+  // but populated by the daemon
   char name[MAXSZ_STRATEGY_NAME];
+  strategy_type_t type;
+  ip_address_t address, local_address;
+  int family, local_family;
+  u8 len, local_len;
 } hc_strategy_t;
 
 int hc_strategy_list(hc_sock_t *s, hc_data_t **data);
@@ -704,8 +774,11 @@ int hc_strategy_list(hc_sock_t *s, hc_data_t **data);
 int hc_strategy_snprintf(char *s, size_t size, hc_strategy_t *strategy);
 
 // per prefix
-int hc_strategy_set(hc_sock_t *s /* XXX */);
-
+int hc_strategy_set(hc_sock_t *s, hc_strategy_t *strategy);
+hc_result_t *hc_strategy_set_conf(hc_sock_t *s, hc_strategy_t *strategy);
+int hc_strategy_add_local_prefix(hc_sock_t *s, hc_strategy_t *strategy);
+hc_result_t *hc_strategy_add_local_prefix_conf(hc_sock_t *s,
+                                               hc_strategy_t *strategy);
 /*----------------------------------------------------------------------------*
  * WLDR
  *----------------------------------------------------------------------------*/
@@ -717,10 +790,45 @@ int hc_wldr_set(hc_sock_t *s /* XXX */);
  * MAP-Me
  *----------------------------------------------------------------------------*/
 
-int hc_mapme_set(hc_sock_t *s, int enabled);
-int hc_mapme_set_discovery(hc_sock_t *s, int enabled);
-int hc_mapme_set_timescale(hc_sock_t *s, double timescale);
-int hc_mapme_set_retx(hc_sock_t *s, double timescale);
+typedef enum {
+  MAPME_TARGET_ENABLE,
+  MAPME_TARGET_DISCOVERY,
+  MAPME_TARGET_TIMESCALE,
+  MAPME_TARGET_RETX,
+} mapme_target_t;
+
+static inline mapme_target_t mapme_target_from_str(char *mapme_target_str) {
+  if (strcasecmp(mapme_target_str, "enable") == 0)
+    return MAPME_TARGET_ENABLE;
+  else if (strcasecmp(mapme_target_str, "discovery") == 0)
+    return MAPME_TARGET_DISCOVERY;
+  else if (strcasecmp(mapme_target_str, "timescale") == 0)
+    return MAPME_TARGET_TIMESCALE;
+  else
+    return MAPME_TARGET_RETX;
+}
+
+#define MAX_MAPME_ARG_LEN 30
+
+typedef struct {
+  mapme_target_t target;
+  // Command argument stored as a string
+  // before being parsed into 'enabled' or 'timescale'
+  char unparsed_arg[MAX_MAPME_ARG_LEN];
+
+  uint8_t enabled;     // 1 = on, 0 = off
+  uint32_t timescale;  // Milliseconds
+
+  ip_address_t address;
+  int family;
+  u8 len;
+} hc_mapme_t;
+
+int hc_mapme_set(hc_sock_t *s, hc_mapme_t *mapme);
+int hc_mapme_set_discovery(hc_sock_t *s, hc_mapme_t *mapme);
+int hc_mapme_set_timescale(hc_sock_t *s, hc_mapme_t *mapme);
+int hc_mapme_set_retx(hc_sock_t *s, hc_mapme_t *mapme);
+int hc_mapme_send_update(hc_sock_t *s, hc_mapme_t *mapme);
 
 /*----------------------------------------------------------------------------*
  * Policies
@@ -732,11 +840,9 @@ typedef struct {
   int family;               /* Krw */
   ip_address_t remote_addr; /* krw */
   u8 len;                   /* krw */
-  hicn_policy_t policy;          /* .rw */
+  hicn_policy_t policy;     /* .rw */
 } hc_policy_t;
 
-int hc_policy_parse(void *in, hc_policy_t *policy);
-
 int hc_policy_create(hc_sock_t *s, hc_policy_t *policy);
 int hc_policy_delete(hc_sock_t *s, hc_policy_t *policy);
 int hc_policy_list(hc_sock_t *s, hc_data_t **pdata);
@@ -748,7 +854,114 @@ int hc_policy_list(hc_sock_t *s, hc_data_t **pdata);
 #define MAXSZ_HC_POLICY MAXSZ_HC_POLICY_ + NULLTERM
 
 int hc_policy_snprintf(char *s, size_t size, hc_policy_t *policy);
+int hc_policy_validate(const hc_policy_t *policy);
 
 #endif /* WITH_POLICY */
 
+/*----------------------------------------------------------------------------*
+ * Subscription
+ *----------------------------------------------------------------------------*/
+// Topics
+
+#undef PUNTING  // TODO(eloparco): Undefined to avoid collisions
+                // Fix the collision
+
+// Used only to create 'hc_topic_t'
+typedef struct {
+#define _(x) char x;
+  foreach_object
+#undef _
+} object_offset_t;
+
+// Flags for topic subscriptions
+typedef enum {
+#define _(x) TOPIC_##x = (1 << offsetof(object_offset_t, x)),
+  foreach_object
+#undef _
+} hc_topic_t;
+
+static inline hc_object_type_t object_from_topic(hc_topic_t topic) {
+#define _(x) \
+  if (topic == TOPIC_##x) return OBJECT_##x;
+  foreach_object
+#undef _
+      return OBJECT_UNDEFINED;
+}
+
+#define NUM_TOPICS OBJECT_N  // Because a topic is created for each object
+#define ALL_TOPICS ~0
+
+// Subscriptions
+typedef uint32_t hc_topics_t;
+typedef struct {
+  hc_topics_t topics;
+} hc_subscription_t;
+
+int hc_subscription_create(hc_sock_t *s, hc_subscription_t *subscription);
+int hc_subscription_delete(hc_sock_t *s, hc_subscription_t *subscription);
+hc_result_t *hc_subscription_create_conf(hc_sock_t *s,
+                                         hc_subscription_t *subscription);
+hc_result_t *hc_subscription_delete_conf(hc_sock_t *s,
+                                         hc_subscription_t *subscription);
+
+/*----------------------------------------------------------------------------*
+ * Events
+ *----------------------------------------------------------------------------*/
+#define foreach_event_type \
+  _(UNDEFINED)             \
+  _(INTERFACE_UPDATE)      \
+  _(N)
+typedef enum {
+#define _(x) EVENT_##x,
+  foreach_event_type
+#undef _
+} event_type_t;
+
+extern const char *event_str[];
+#define event_str(x) event_str[x]
+
+typedef enum {
+  FLAG_INTERFACE_TYPE_WIRED = 0x1,
+  FLAG_INTERFACE_TYPE_WIFI = 0x2,
+  FLAG_INTERFACE_TYPE_CELLULAR = 0x4,
+} flag_interface_type_t;
+
+typedef struct {
+  flag_interface_type_t interface_type;
+} hc_event_interface_update_t;
+
+/* Result */
+
+hc_msg_t *hc_result_get_msg(hc_sock_t *s, hc_result_t *result);
+int hc_result_get_cmd_id(hc_sock_t *s, hc_result_t *result);
+bool hc_result_get_success(hc_sock_t *s, hc_result_t *result);
+void hc_result_free(hc_result_t *result);
+
+/* Object */
+
+typedef struct {
+  hc_object_type_t type;
+  union {
+    hc_connection_t connection;
+    hc_listener_t listener;
+    hc_route_t route;
+    hc_face_t face;
+    // hc_data_t *data;
+    hc_punting_t punting;
+    hc_strategy_t strategy;
+#ifdef WITH_POLICY
+    hc_policy_t policy;
+#endif /* WITH_POLICY */
+    hc_subscription_t subscription;
+    hc_cache_t cache;
+    hc_mapme_t mapme;
+    uint8_t as_uint8;
+  };
+} hc_object_t;
+
+typedef struct {
+  hc_action_t action;
+  hc_object_t object;
+} hc_command_t;
+
 #endif /* HICNTRL_API */
diff --git a/ctrl/libhicnctrl/includes/hicn/ctrl/commands.h b/ctrl/libhicnctrl/includes/hicn/ctrl/commands.h
deleted file mode 100644
index 3758f0f41..000000000
--- a/ctrl/libhicnctrl/includes/hicn/ctrl/commands.h
+++ /dev/null
@@ -1,434 +0,0 @@
-/*
- * 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 commands.h
- * @brief All hicn-light commands: 14 in total.
- *
- * Header and payload in binary format.
- */
-
-#ifndef commands_h
-#define commands_h
-
-#ifndef _WIN32
-#include <netinet/in.h>
-#include <sys/socket.h>
-#endif
-
-#include <stdint.h>
-#include <stdlib.h>
-
-#include <hicn/util/ip_address.h>
-#ifdef WITH_POLICY
-#include <hicn/policy.h>
-#endif /* WITH_POLICY */
-
-#define SYMBOLIC_NAME_LEN 16
-#define MAX_FWD_STRATEGY_RELATED_PREFIXES 10
-
-typedef struct in6_addr ipv6_addr_t;
-typedef uint32_t ipv4_addr_t;
-
-typedef enum {
-  REQUEST_LIGHT = 0xc0, // this is a command
-  RESPONSE_LIGHT,
-  ACK_LIGHT,
-  NACK_LIGHT,
-  LAST_MSG_TYPE_VALUE
-} message_type;
-
-typedef enum {
-  ADD_LISTENER = 0,
-  ADD_CONNECTION,
-  LIST_CONNECTIONS,
-  ADD_ROUTE,
-  LIST_ROUTES,
-  REMOVE_CONNECTION,
-  REMOVE_LISTENER,
-  REMOVE_ROUTE,
-  CACHE_STORE,
-  CACHE_SERVE,
-  CACHE_CLEAR,
-  SET_STRATEGY,
-  SET_WLDR,
-  ADD_PUNTING,
-  LIST_LISTENERS,
-  MAPME_ENABLE,
-  MAPME_DISCOVERY,
-  MAPME_TIMESCALE,
-  MAPME_RETX,
-  MAPME_SEND_UPDATE,
-  CONNECTION_SET_ADMIN_STATE,
-#ifdef WITH_POLICY
-  ADD_POLICY,
-  LIST_POLICIES,
-  REMOVE_POLICY,
-  UPDATE_CONNECTION,
-  CONNECTION_SET_PRIORITY,
-  CONNECTION_SET_TAGS,
-#endif /* WITH_POLICY */
-  LAST_COMMAND_VALUE
-} command_id;
-
-typedef enum {
-  ADDR_INET = 1,
-  ADDR_INET6,
-  ADDR_LINK,
-  ADDR_IFACE,
-  ADDR_UNIX /* PF_UNIX */
-} address_type;
-
-typedef enum {
-  UDP_CONN,
-  TCP_CONN,
-  GRE_CONN,  // not implemented
-  HICN_CONN
-} connection_type;
-
-typedef enum { ACTIVATE_ON, ACTIVATE_OFF } activate_type;
-
-//==========    HEADER    ==========
-
-typedef struct {
-  uint8_t messageType;
-  uint8_t commandID;
-  uint16_t length;  // tells the number of structures in the payload
-  uint32_t seqNum;
-} header_control_message;
-// for the moment has to be at least 8 bytes
-
-// SIZE=8
-
-//==========  [00]  ADD LISTENER    ==========
-
-typedef enum { ETHER_MODE, IP_MODE, HICN_MODE } listener_mode;
-
-typedef struct {
-  char symbolic[SYMBOLIC_NAME_LEN];
-  char interfaceName[SYMBOLIC_NAME_LEN];
-  ip_address_t address;
-  uint16_t port;
-  // uint16_t etherType;
-  uint8_t addressType;
-  uint8_t listenerMode;
-  uint8_t connectionType;
-} add_listener_command;
-
-// SIZE=56
-
-//==========  [01]  ADD CONNECTION    ==========
-
-typedef struct {
-  char symbolic[SYMBOLIC_NAME_LEN];
-  //char interfaceName[SYMBOLIC_NAME_LEN];
-  ip_address_t remoteIp;
-  ip_address_t localIp;
-  uint16_t remotePort;
-  uint16_t localPort;
-  uint8_t ipType;
-  uint8_t connectionType;
-  uint8_t admin_state;
-#ifdef WITH_POLICY
-  uint32_t priority;
-  policy_tags_t tags;
-#endif /* WITH_POLICY */
-} add_connection_command;
-
-// SIZE=56
-
-//==========  [02]  LIST CONNECTIONS    ==========
-
-typedef enum {
-  CONN_GRE,
-  CONN_TCP,
-  CONN_UDP,
-  CONN_MULTICAST,
-  CONN_L2,
-  CONN_HICN
-} list_connections_type;
-
-typedef enum {
-  IFACE_UP = 0,
-  IFACE_DOWN = 1,
-  IFACE_UNKNOWN = 2  // not used actually
-} connection_state;
-
-typedef struct {
-  add_connection_command connectionData;
-  uint32_t connid;
-  uint8_t state;
-  char interfaceName[SYMBOLIC_NAME_LEN];
-  char connectionName[SYMBOLIC_NAME_LEN];
-} list_connections_command;
-
-// SIZE=80
-
-//==========  [03]  ADD ROUTE    ==========
-
-typedef struct {
-  char symbolicOrConnid[SYMBOLIC_NAME_LEN];
-  ip_address_t address;
-  uint16_t cost;
-  uint8_t addressType;
-  uint8_t len;
-} add_route_command;
-
-// SIZE=36
-
-//==========  [04]  LIST ROUTE    ==========
-
-typedef struct {
-  ip_address_t address;
-  uint32_t connid;
-  uint16_t cost;
-  uint8_t addressType;
-  uint8_t len;
-} list_routes_command;
-
-// SIZE=24
-
-//==========  [05]  REMOVE CONNECTION    ==========
-typedef struct {
-  char symbolicOrConnid[SYMBOLIC_NAME_LEN];
-} remove_connection_command;
-
-//==========  [06]  REMOVE LISTENER    ==========
-typedef struct {
-  char symbolicOrListenerid[SYMBOLIC_NAME_LEN];
-} remove_listener_command;
-
-// SIZE=16
-
-//==========  [07]  REMOVE ROUTE    ==========
-
-typedef struct {
-  char symbolicOrConnid[SYMBOLIC_NAME_LEN];
-  ip_address_t address;
-  uint8_t addressType;
-  uint8_t len;
-} remove_route_command;
-
-// SIZE=36
-
-//==========  [08]  CACHE STORE    ==========
-
-typedef struct {
-  uint8_t activate;
-} cache_store_command;
-
-// SIZE=1
-
-//==========  [09]  CACHE SERVE    ==========
-
-typedef struct {
-  uint8_t activate;
-} cache_serve_command;
-
-// SIZE=1
-
-//==========  [10]  SET STRATEGY    ==========
-
-typedef enum {
-  SET_STRATEGY_LOADBALANCER,
-  SET_STRATEGY_RANDOM,
-  SET_STRATEGY_LOW_LATENCY,
-  LAST_STRATEGY_VALUE
-} strategy_type;
-
-typedef struct {
-  ip_address_t address;
-  uint8_t strategyType;
-  uint8_t addressType;
-  uint8_t len;
-  uint8_t related_prefixes;
-  ip_address_t addresses[MAX_FWD_STRATEGY_RELATED_PREFIXES];
-  uint8_t lens[MAX_FWD_STRATEGY_RELATED_PREFIXES];
-  uint8_t addresses_type[MAX_FWD_STRATEGY_RELATED_PREFIXES];
-} set_strategy_command;
-
-// SIZE=208
-
-//==========  [11]  SET WLDR    ==========
-
-typedef struct {
-  char symbolicOrConnid[SYMBOLIC_NAME_LEN];
-  uint8_t activate;
-} set_wldr_command;
-
-// SIZE=17
-
-//==========  [12]  ADD PUNTING    ==========
-
-typedef struct {
-  char symbolicOrConnid[SYMBOLIC_NAME_LEN];
-  ip_address_t address;
-  uint8_t addressType;
-  uint8_t len;
-} add_punting_command;
-
-// SIZE=36
-
-//==========  [13]  LIST LISTENER    ==========
-
-typedef struct {
-  ip_address_t address;
-  char listenerName[SYMBOLIC_NAME_LEN];
-  char interfaceName[SYMBOLIC_NAME_LEN];
-  uint32_t connid;
-  uint16_t port;
-  uint8_t addressType;
-  uint8_t encapType;
-} list_listeners_command;
-
-// SIZE=56
-
-//==========  [14]  MAPME    ==========
-
-//  (enable/discovery/timescale/retx)
-
-typedef struct {
-  uint8_t activate;
-} mapme_activator_command;
-
-// SIZE=1
-
-typedef struct {
-  uint32_t timePeriod;
-} mapme_timing_command;
-
-typedef struct {
-  ip_address_t address;
-  uint8_t addressType;
-  uint8_t len;
-} mapme_send_update_command;
-
-// SIZE=1
-
-typedef struct {
-  char symbolicOrConnid[SYMBOLIC_NAME_LEN];
-  uint8_t admin_state;
-  uint8_t pad8[3];
-} connection_set_admin_state_command;
-
-#ifdef WITH_POLICY
-
-typedef struct {
-  ip_address_t address;
-  uint8_t addressType;
-  uint8_t len;
-  hicn_policy_t policy;
-} add_policy_command;
-
-typedef struct {
-  ip_address_t address;
-  uint8_t addressType;
-  uint8_t len;
-  hicn_policy_t policy;
-} list_policies_command;
-
-typedef struct {
-  ip_address_t address;
-  uint8_t addressType;
-  uint8_t len;
-} remove_policy_command;
-
-typedef struct {
-  char symbolicOrConnid[SYMBOLIC_NAME_LEN];
-  uint8_t admin_state;
-  uint32_t priority;
-  policy_tags_t tags;
-} update_connection_command;
-
-typedef struct {
-  char symbolicOrConnid[SYMBOLIC_NAME_LEN];
-  uint32_t priority;
-} connection_set_priority_command;
-
-typedef struct {
-  char symbolicOrConnid[SYMBOLIC_NAME_LEN];
-  policy_tags_t tags;
-} connection_set_tags_command;
-
-#endif /* WITH_POLICY */
-
-//===== size of commands ======
-// REMINDER: when a new_command is added, the following switch has to be
-// updated.
-static inline int payloadLengthDaemon(command_id id) {
-  switch (id) {
-    case ADD_LISTENER:
-      return sizeof(add_listener_command);
-    case ADD_CONNECTION:
-      return sizeof(add_connection_command);
-    case LIST_CONNECTIONS:
-      return 0;  // list connections: payload always 0
-    case ADD_ROUTE:
-      return sizeof(add_route_command);
-    case LIST_ROUTES:
-      return 0;  // list routes: payload always 0
-    case REMOVE_CONNECTION:
-      return sizeof(remove_connection_command);
-    case REMOVE_LISTENER:
-      return sizeof(remove_listener_command);
-    case REMOVE_ROUTE:
-      return sizeof(remove_route_command);
-    case CACHE_STORE:
-      return sizeof(cache_store_command);
-    case CACHE_SERVE:
-      return sizeof(cache_serve_command);
-    case CACHE_CLEAR:
-      return 0;  // cache clear
-    case SET_STRATEGY:
-      return sizeof(set_strategy_command);
-    case SET_WLDR:
-      return sizeof(set_wldr_command);
-    case ADD_PUNTING:
-      return sizeof(add_punting_command);
-    case LIST_LISTENERS:
-      return 0;  // list listeners: payload always 0
-    case MAPME_ENABLE:
-      return sizeof(mapme_activator_command);
-    case MAPME_DISCOVERY:
-      return sizeof(mapme_activator_command);
-    case MAPME_TIMESCALE:
-      return sizeof(mapme_timing_command);
-    case MAPME_RETX:
-      return sizeof(mapme_timing_command);
-    case MAPME_SEND_UPDATE:
-      return sizeof(mapme_send_update_command);
-    case CONNECTION_SET_ADMIN_STATE:
-      return sizeof(connection_set_admin_state_command);
-#ifdef WITH_POLICY
-    case ADD_POLICY:
-      return sizeof(add_policy_command);
-    case LIST_POLICIES:
-      return 0; // list policies: payload always 0
-    case REMOVE_POLICY:
-      return sizeof(remove_policy_command);
-    case UPDATE_CONNECTION:
-      return sizeof(update_connection_command);
-    case CONNECTION_SET_PRIORITY:
-      return sizeof(connection_set_priority_command);
-    case CONNECTION_SET_TAGS:
-      return sizeof(connection_set_tags_command);
-#endif /* WITH_POLICY */
-    case LAST_COMMAND_VALUE:
-      return 0;
-    default:
-      return 0;
-  }
-}
-#endif
diff --git a/ctrl/libhicnctrl/includes/hicn/ctrl/face.h b/ctrl/libhicnctrl/includes/hicn/ctrl/face.h
deleted file mode 100644
index 49a6a783c..000000000
--- a/ctrl/libhicnctrl/includes/hicn/ctrl/face.h
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * 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 <hicn/policy.h>
-
-#include <hicn/util/ip_address.h>
-
-//typedef unsigned int hash_t; //incompatible with vpp
-
-/* Netdevice type */
-
-#include <net/if.h> // IFNAMSIZ
-
-#define foreach_netdevice_type  \
-    _(UNDEFINED)                \
-    _(LOOPBACK)                 \
-    _(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 */
-
-/**
- * \brief Netdevice type
- *
- * NOTE
- *  - This struct cannot be made opaque as it is currently part of face_t
- *  - We recommand using the API as to keep redundant attributes consistent
- */
-typedef struct {
-    u32 index;
-    char name[IFNAMSIZ];
-} netdevice_t;
-
-#define NETDEVICE_EMPTY (netdevice_t) { \
-    .index = 0,                         \
-    .name = {0},                        \
-}
-
-netdevice_t * netdevice_create_from_index(u32 index);
-netdevice_t * netdevice_create_from_name(const char * name);
-#define netdevice_initialize_from_index netdevice_set_index
-#define netdevice_initialize_from_name netdevice_set_name
-void netdevice_free(netdevice_t * netdevice);
-int netdevice_get_index(const netdevice_t * netdevice, u32 * index);
-int netdevice_set_index(netdevice_t * netdevice, u32 index);
-int netdevice_get_name(const netdevice_t * netdevice, const char ** name);
-int netdevice_set_name(netdevice_t * netdevice, const char * name);
-int netdevice_update_index(netdevice_t * netdevice);
-int netdevice_update_name(netdevice_t * netdevice);
-int netdevice_cmp(const netdevice_t * nd1, const netdevice_t * nd2);
-
-#define NETDEVICE_UNDEFINED_INDEX 0
-
-/* Face state */
-
-#define foreach_face_state      \
-    _(UNDEFINED)                \
-    _(DOWN)                     \
-    _(UP)                       \
-    _(N)
-
-
-#define MAXSZ_FACE_STATE_ 9
-#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[];
-
-#ifdef WITH_POLICY
-#define MAXSZ_FACE_ MAXSZ_FACE_TYPE_ + 2 * MAXSZ_URL_ + 2 * MAXSZ_FACE_STATE_ + MAXSZ_POLICY_TAGS_ + 7
-#else
-#define MAXSZ_FACE_ MAXSZ_FACE_TYPE_ + 2 * MAXSZ_URL_ + 2 * MAXSZ_FACE_STATE_ + 4
-#endif /* WITH_POLICY */
-#define MAXSZ_FACE MAXSZ_FACE_ + 1
-
-/* Face */
-
-typedef u32 face_id_t;
-
-typedef struct {
-    face_type_t type;
-    face_state_t admin_state;
-    face_state_t state;
-#ifdef WITH_POLICY
-    uint32_t priority;
-    policy_tags_t tags; /**< \see policy_tag_t */
-#endif /* WITH_POLICY */
-
-    /*
-     * Depending on the face type, some of the following fields will be unused
-     */
-    netdevice_t netdevice;
-    int family; /* To access family independently of face type */
-    ip_address_t local_addr;
-    ip_address_t remote_addr;
-    u16 local_port;
-    u16 remote_port;
-} face_t;
-
-int face_initialize(face_t * face);
-int face_initialize_udp(face_t * face, const char * interface_name,
-        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 char * interface_name,
-        const struct sockaddr * local_addr, const struct sockaddr * remote_addr);
-
-face_t * face_create();
-face_t * face_create_udp(const char * interface_name,
-        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 char * interface_name,
-        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);
-unsigned int face_hash(const face_t * face);
-
-size_t
-face_snprintf(char * s, size_t size, const face_t * face);
-
-policy_tags_t face_get_tags(const face_t * face);
-int face_set_tags(face_t * face, policy_tags_t tags);
-
-#endif /* HICN_FACE_H */
-
diff --git a/ctrl/libhicnctrl/includes/hicn/ctrl/hicn-light-ng.h b/ctrl/libhicnctrl/includes/hicn/ctrl/hicn-light-ng.h
new file mode 100644
index 000000000..7d105a84b
--- /dev/null
+++ b/ctrl/libhicnctrl/includes/hicn/ctrl/hicn-light-ng.h
@@ -0,0 +1,427 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * @file commands.h
+ * @brief All hicn-light commands: 14 in total.
+ *
+ * Header and payload in binary format.
+ */
+
+#ifndef HICN_CTRL_HICNLIGHTNG_H
+#define HICN_CTRL_HICNLIGHTNG_H
+
+#ifndef _WIN32
+#include <netinet/in.h>
+#include <sys/socket.h>
+#endif
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <hicn/policy.h>
+#include <hicn/strategy.h>
+#include <hicn/util/ip_address.h>
+
+#define SYMBOLIC_NAME_LEN 16
+
+typedef struct in6_addr ipv6_addr_t;
+typedef uint32_t ipv4_addr_t;
+
+typedef enum {
+  MESSAGE_COMMAND_SUBTYPE_UNDEFINED,
+  REQUEST_LIGHT = 0xc0,  // this is a command
+  RESPONSE_LIGHT,
+  ACK_LIGHT,
+  NACK_LIGHT,
+  NOTIFICATION_LIGHT,
+  MESSAGE_COMMAND_SUBTYPE_N
+} message_command_subtype_t;
+
+#define message_type_is_valid(message_type)    \
+  ((message_type != MESSAGE_TYPE_UNDEFINED) && \
+   (message_type != MESSAGE_COMMAND_SUBTYPE_N))
+
+#define message_type_from_uchar(x)                               \
+  (((x) < REQUEST_LIGHT) || (((x) >= MESSAGE_COMMAND_SUBTYPE_N)) \
+       ? MESSAGE_COMMAND_SUBTYPE_N                               \
+       : (message_command_subtype_t)(x))
+
+#define foreach_command_type                                \
+  _(listener_add, LISTENER_ADD)                             \
+  _(listener_remove, LISTENER_REMOVE)                       \
+  _(listener_list, LISTENER_LIST)                           \
+  _(connection_add, CONNECTION_ADD)                         \
+  _(connection_remove, CONNECTION_REMOVE)                   \
+  _(connection_list, CONNECTION_LIST)                       \
+  _(connection_set_admin_state, CONNECTION_SET_ADMIN_STATE) \
+  _(connection_update, CONNECTION_UPDATE)                   \
+  _(connection_set_priority, CONNECTION_SET_PRIORITY)       \
+  _(connection_set_tags, CONNECTION_SET_TAGS)               \
+  _(route_add, ROUTE_ADD)                                   \
+  _(route_remove, ROUTE_REMOVE)                             \
+  _(route_list, ROUTE_LIST)                                 \
+  _(cache_set_store, CACHE_SET_STORE)                       \
+  _(cache_set_serve, CACHE_SET_SERVE)                       \
+  _(cache_clear, CACHE_CLEAR)                               \
+  _(cache_list, CACHE_LIST)                                 \
+  _(strategy_set, STRATEGY_SET)                             \
+  _(strategy_add_local_prefix, STRATEGY_ADD_LOCAL_PREFIX)   \
+  _(wldr_set, WLDR_SET)                                     \
+  _(punting_add, PUNTING_ADD)                               \
+  _(mapme_enable, MAPME_ENABLE)                             \
+  _(mapme_set_discovery, MAPME_SET_DISCOVERY)               \
+  _(mapme_set_timescale, MAPME_SET_TIMESCALE)               \
+  _(mapme_set_retx, MAPME_SET_RETX)                         \
+  _(mapme_send_update, MAPME_SEND_UPDATE)                   \
+  _(policy_add, POLICY_ADD)                                 \
+  _(policy_remove, POLICY_REMOVE)                           \
+  _(policy_list, POLICY_LIST)                               \
+  _(subscription_add, SUBSCRIPTION_ADD)                     \
+  _(subscription_remove, SUBSCRIPTION_REMOVE)
+
+typedef enum {
+  COMMAND_TYPE_UNDEFINED,
+#define _(l, u) COMMAND_TYPE_##u,
+  foreach_command_type
+#undef _
+      COMMAND_TYPE_N,
+} command_type_t;
+
+extern const char *command_type_str[];
+
+#define command_type_str(x) command_type_str[x]
+
+#define command_type_is_valid(command_type) \
+  ((command_type != COMMAND_TYPE_UNDEFINED) && (command_type != COMMAND_TYPE_N))
+
+#define command_type_from_uchar(x) \
+  (((x) >= COMMAND_TYPE_N) ? COMMAND_TYPE_N : (command_type_t)(x))
+
+/* Should be at least 8 bytes */
+typedef struct {
+  uint8_t message_type;
+  uint8_t command_id;
+  uint16_t length; /* Number of structures in the payload */
+  uint32_t seq_num;
+} cmd_header_t;
+
+typedef struct {
+  cmd_header_t header;
+} msg_header_t;
+
+/* Listener */
+
+typedef struct {
+  char symbolic[SYMBOLIC_NAME_LEN];
+  char interface_name[SYMBOLIC_NAME_LEN];
+  ip_address_t address;
+  uint16_t port;
+  uint8_t family;
+  uint8_t type;
+} cmd_listener_add_t;
+
+typedef struct {
+  char symbolicOrListenerid[SYMBOLIC_NAME_LEN];
+} cmd_listener_remove_t;
+
+typedef struct {
+  void *_;  // Otherwise empty structs result in clang build error
+} cmd_listener_list_t;
+
+// Sync this struct with `hc_listener_t` in `api.h`
+typedef struct {
+  char name[SYMBOLIC_NAME_LEN];
+  char interface_name[SYMBOLIC_NAME_LEN];
+  uint32_t id;
+  uint8_t type;
+  uint8_t family;
+  ip_address_t address;
+  uint16_t port;
+} cmd_listener_list_item_t;
+
+/* Connection */
+
+typedef struct {
+  char symbolic[SYMBOLIC_NAME_LEN];
+  // char interface_name[SYMBOLIC_NAME_LEN];
+  ip_address_t remote_ip;
+  ip_address_t local_ip;
+  uint16_t remote_port;
+  uint16_t local_port;
+  uint8_t family;
+  uint8_t type;
+  uint8_t admin_state;
+#ifdef WITH_POLICY
+  uint32_t priority;
+  policy_tags_t tags;
+#endif /* WITH_POLICY */
+} cmd_connection_add_t;
+
+typedef struct {
+  char symbolic_or_connid[SYMBOLIC_NAME_LEN];
+} cmd_connection_remove_t;
+
+typedef struct {
+  void *_;
+} cmd_connection_list_t;
+
+// Sync this struct with `hc_connection_t` in `api.h`
+typedef struct {
+  uint32_t id;
+  char name[SYMBOLIC_NAME_LEN];
+  char interface_name[SYMBOLIC_NAME_LEN];
+  uint8_t type;
+  uint8_t family;
+  ip_address_t local_addr;
+  uint16_t local_port;
+  ip_address_t remote_addr;
+  uint16_t remote_port;
+  uint8_t admin_state;
+#ifdef WITH_POLICY
+  uint32_t priority;
+  policy_tags_t tags;
+#endif /* WITH_POLICY */
+  uint8_t state;
+} cmd_connection_list_item_t;
+
+typedef struct {
+  char symbolic_or_connid[SYMBOLIC_NAME_LEN];
+  uint8_t admin_state;
+  uint8_t pad8[3];
+} cmd_connection_set_admin_state_t;
+
+typedef struct {
+  char symbolic_or_connid[SYMBOLIC_NAME_LEN];
+  uint8_t admin_state;
+#ifdef WITH_POLICY
+  uint32_t priority;
+  policy_tags_t tags;
+#endif /* WITH_POLICY */
+} cmd_connection_update_t;
+
+typedef struct {
+  char symbolic_or_connid[SYMBOLIC_NAME_LEN];
+  uint32_t priority;
+} cmd_connection_set_priority_t;
+
+typedef struct {
+  char symbolic_or_connid[SYMBOLIC_NAME_LEN];
+  policy_tags_t tags;
+} cmd_connection_set_tags_t;
+
+/* Route */
+
+typedef struct {
+  char symbolic_or_connid[SYMBOLIC_NAME_LEN];
+  ip_address_t address;
+  uint16_t cost;
+  uint8_t family;
+  uint8_t len;
+} cmd_route_add_t;
+
+typedef struct {
+  char symbolic_or_connid[SYMBOLIC_NAME_LEN];
+  ip_address_t address;
+  uint8_t family;
+  uint8_t len;
+} cmd_route_remove_t;
+
+typedef struct {
+  void *_;
+} cmd_route_list_t;
+
+// Sync this struct with `hc_route_t` in `api.h`
+typedef struct {
+  ip_address_t address;
+  uint32_t connection_id;
+  uint16_t cost;
+  uint8_t family;
+  uint8_t len;
+} cmd_route_list_item_t;
+
+/* Cache */
+
+typedef struct {
+  uint8_t activate;
+} cmd_cache_set_store_t;
+
+typedef struct {
+  uint8_t activate;
+} cmd_cache_set_serve_t;
+
+typedef struct {
+  void *_;
+} cmd_cache_clear_t;
+
+typedef struct {
+  void *_;
+} cmd_cache_list_t;
+
+typedef struct {
+  uint8_t store_in_cs;
+  uint8_t serve_from_cs;
+  uint32_t cs_size;
+  uint32_t num_stale_entries;
+} cmd_cache_list_reply_t;
+
+typedef struct {
+  cmd_header_t header;
+  cmd_cache_list_reply_t payload;
+} msg_cache_list_reply_t;
+
+/* WLDR */
+
+typedef struct {
+  char symbolic_or_connid[SYMBOLIC_NAME_LEN];
+  uint8_t activate;
+} cmd_wldr_set_t;
+
+/* Strategy */
+
+typedef struct {
+  ip_address_t address;
+  uint8_t family;
+  uint8_t len;
+  uint8_t type;
+  uint8_t related_prefixes;
+  union {
+    struct {
+      ip_address_t addresses[MAX_FWD_STRATEGY_RELATED_PREFIXES];
+      uint8_t lens[MAX_FWD_STRATEGY_RELATED_PREFIXES];
+      uint8_t families[MAX_FWD_STRATEGY_RELATED_PREFIXES];
+    } low_latency;
+  };
+} cmd_strategy_set_t;
+
+typedef struct {
+  uint8_t type;
+  ip_address_t address;
+  uint8_t family;
+  uint8_t len;
+  ip_address_t local_address;
+  uint8_t local_family;
+  uint8_t local_len;
+} cmd_strategy_add_local_prefix_t;
+
+/* Punting */
+
+typedef struct {
+  char symbolic_or_connid[SYMBOLIC_NAME_LEN];
+  ip_address_t address;
+  uint8_t family;
+  uint8_t len;
+} cmd_punting_add_t;
+
+/* MAP-Me */
+
+typedef struct {
+  uint8_t activate;
+} cmd_mapme_activator_t;
+
+typedef cmd_mapme_activator_t cmd_mapme_enable_t;
+typedef cmd_mapme_activator_t cmd_mapme_set_discovery_t;
+
+typedef struct {
+  uint32_t timePeriod;
+} cmd_mapme_timing_t;
+
+typedef cmd_mapme_timing_t cmd_mapme_set_timescale_t;
+typedef cmd_mapme_timing_t cmd_mapme_set_retx_t;
+
+typedef struct {
+  void *_;
+} cmd_mapme_send_update_t;
+
+/* Policy */
+
+typedef struct {
+  ip_address_t address;
+  uint8_t family;
+  uint8_t len;
+  hicn_policy_t policy;
+} cmd_policy_add_t;
+
+typedef struct {
+  ip_address_t address;
+  uint8_t family;
+  uint8_t len;
+} cmd_policy_remove_t;
+
+typedef struct {
+  void *_;
+} cmd_policy_list_t;
+
+typedef struct {
+  ip_address_t address;
+  uint8_t family;
+  uint8_t len;
+  hicn_policy_t policy;
+} cmd_policy_list_item_t;
+
+/* Subscription */
+
+typedef struct {
+  uint32_t topics;
+} cmd_subscription_add_t;
+
+typedef struct {
+  uint32_t topics;
+} cmd_subscription_remove_t;
+
+/* Full messages */
+
+#define _(l, u)          \
+  typedef struct {       \
+    cmd_header_t header; \
+    cmd_##l##_t payload; \
+  } msg_##l##_t;
+foreach_command_type
+#undef _
+
+    typedef struct {
+  cmd_header_t header;
+  cmd_listener_list_item_t payload;
+} msg_listener_list_reply_t;
+
+typedef struct {
+  cmd_header_t header;
+  cmd_connection_list_item_t payload;
+} msg_connection_list_reply_t;
+
+typedef struct {
+  cmd_header_t header;
+  cmd_route_list_item_t payload;
+} msg_route_list_reply_t;
+
+typedef struct {
+  cmd_header_t header;
+  cmd_policy_list_item_t payload;
+} msg_policy_list_reply_t;
+
+//===== size of commands ======
+// REMINDER: when a new_command is added, the following switch has to be
+// updated.
+static inline int command_get_payload_len(command_type_t command_type) {
+  switch (command_type) {
+#define _(l, u)          \
+  case COMMAND_TYPE_##u: \
+    return sizeof(cmd_##l##_t);
+    foreach_command_type
+#undef _
+        case COMMAND_TYPE_UNDEFINED : case COMMAND_TYPE_N : return 0;
+  }
+}
+#endif /* HICN_CTRL_HICNLIGHTNG_H */
diff --git a/hicn-light/src/hicn/utils/commands.h b/ctrl/libhicnctrl/includes/hicn/ctrl/hicn-light.h
index 3758f0f41..69ede1985 100644
--- a/hicn-light/src/hicn/utils/commands.h
+++ b/ctrl/libhicnctrl/includes/hicn/ctrl/hicn-light.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -20,8 +20,8 @@
  * Header and payload in binary format.
  */
 
-#ifndef commands_h
-#define commands_h
+#ifndef HICN_CTRL_HICNLIGHT_H
+#define HICN_CTRL_HICNLIGHT_H
 
 #ifndef _WIN32
 #include <netinet/in.h>
@@ -43,7 +43,7 @@ typedef struct in6_addr ipv6_addr_t;
 typedef uint32_t ipv4_addr_t;
 
 typedef enum {
-  REQUEST_LIGHT = 0xc0, // this is a command
+  REQUEST_LIGHT = 0xc0,  // this is a command
   RESPONSE_LIGHT,
   ACK_LIGHT,
   NACK_LIGHT,
@@ -133,7 +133,7 @@ typedef struct {
 
 typedef struct {
   char symbolic[SYMBOLIC_NAME_LEN];
-  //char interfaceName[SYMBOLIC_NAME_LEN];
+  // char interfaceName[SYMBOLIC_NAME_LEN];
   ip_address_t remoteIp;
   ip_address_t localIp;
   uint16_t remotePort;
@@ -415,7 +415,7 @@ static inline int payloadLengthDaemon(command_id id) {
     case ADD_POLICY:
       return sizeof(add_policy_command);
     case LIST_POLICIES:
-      return 0; // list policies: payload always 0
+      return 0;  // list policies: payload always 0
     case REMOVE_POLICY:
       return sizeof(remove_policy_command);
     case UPDATE_CONNECTION:
@@ -431,4 +431,4 @@ static inline int payloadLengthDaemon(command_id id) {
       return 0;
   }
 }
-#endif
+#endif /* HICN_CTRL_HICNLIGHT_H */
diff --git a/ctrl/libhicnctrl/includes/hicn/ctrl/route.h b/ctrl/libhicnctrl/includes/hicn/ctrl/route.h
index d7ef6a26f..81f011d4d 100644
--- a/ctrl/libhicnctrl/includes/hicn/ctrl/route.h
+++ b/ctrl/libhicnctrl/includes/hicn/ctrl/route.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,7 +21,7 @@
 #define HICN_ROUTE_H
 
 #include <hicn/util/ip_address.h>
-#include <hicn/ctrl/face.h>
+#include <hicn/face.h>
 
 typedef u16 route_cost_t;
 
@@ -30,18 +30,23 @@ typedef struct hicn_route_s hicn_route_t;
 #define MAXSZ_ROUTE_ MAXSZ_PREFIX + 3 + MAXSZ_COST
 #define MAXSZ_ROUTE MAXSZ_ROUTE_ + NULLTERM
 
-hicn_route_t * hicn_route_create(ip_prefix_t * prefix, face_id_t face_id, route_cost_t cost);
-hicn_route_t * hicn_route_dup(const hicn_route_t * route);
-void hicn_route_free(hicn_route_t * route);
+#define MIN_ROUTE_COST 1
+#define MAX_ROUTE_COST 255
+#define IS_VALID_ROUTE_COST(x) ((x >= MIN_ROUTE_COST) && (x <= MAX_ROUTE_COST))
 
-int hicn_route_cmp(const hicn_route_t * route1, const hicn_route_t * route2);
+hicn_route_t* hicn_route_create(ip_prefix_t* prefix, face_id_t face_id,
+                                route_cost_t cost);
+hicn_route_t* hicn_route_dup(const hicn_route_t* route);
+void hicn_route_free(hicn_route_t* route);
 
-int hicn_route_get_prefix(const hicn_route_t * route, ip_prefix_t * prefix);
-int hicn_route_set_prefix(hicn_route_t * route, const ip_prefix_t prefix);
+int hicn_route_cmp(const hicn_route_t* route1, const hicn_route_t* route2);
 
-int hicn_route_get_cost(const hicn_route_t * route, int * cost);
-int hicn_route_set_cost(hicn_route_t * route, const int cost);
+int hicn_route_get_prefix(const hicn_route_t* route, ip_prefix_t* prefix);
+int hicn_route_set_prefix(hicn_route_t* route, const ip_prefix_t prefix);
 
-size_t hicn_route_snprintf(char * s, size_t size, const hicn_route_t * route);
+int hicn_route_get_cost(const hicn_route_t* route, int* cost);
+int hicn_route_set_cost(hicn_route_t* route, const int cost);
+
+size_t hicn_route_snprintf(char* s, size_t size, const hicn_route_t* route);
 
 #endif
diff --git a/ctrl/libhicnctrl/src/CMakeLists.txt b/ctrl/libhicnctrl/src/CMakeLists.txt
index f9934d70e..c8a93c56c 100644
--- a/ctrl/libhicnctrl/src/CMakeLists.txt
+++ b/ctrl/libhicnctrl/src/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,80 +11,127 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-list(APPEND COMPILER_DEFINITIONS
-  "-DWITH_POLICY"
-)
-
+##############################################################
+# Source files
+##############################################################
 set(SOURCE_FILES
-    face.c
-    route.c
-    api.c
+  route.c
+  api.c
 )
 
 set(HEADER_FILES
-    api_private.h
+  api_private.h
 )
 
+
+##############################################################
+# Libraries to link
+##############################################################
 set(LIBRARIES
-    m
-    dl
-    ${HICN_LIBRARIES}
+  m
+  dl
+  ${HICN_LIBRARIES}
 )
 
+
+##############################################################
+# Include directories
+##############################################################
 set(INCLUDE_DIRS
+  PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}
-    ${CMAKE_CURRENT_SOURCE_DIR}/../includes/
-    ${HICN_INCLUDE_DIRS}
+  PUBLIC
+    $<BUILD_INTERFACE:${Libhicnctrl_INCLUDE_DIRS}>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
 )
 
-# Android requires static libraries
+
+##############################################################
+# Library type
+##############################################################
 if (DISABLE_SHARED_LIBRARIES)
-    set(LIBRARIES ${LIBRARIES} ${LIBHICN_STATIC})
-    set(LINK_TYPE STATIC)
+  set(LIBRARIES ${LIBRARIES} ${LIBHICN_STATIC})
+  set(LINK_TYPE STATIC)
 else ()
-    set(LINK_TYPE SHARED STATIC)
+  set(LINK_TYPE SHARED STATIC)
 endif ()
 
+
+##############################################################
+# Do not use modules if Android
+##############################################################
 if (${CMAKE_SYSTEM_NAME} MATCHES Android)
-    list(APPEND SOURCE_FILES
-        ${CMAKE_CURRENT_SOURCE_DIR}/modules/hicn_light_api.c
-    )
+  list(APPEND SOURCE_FILES
+    ${CMAKE_CURRENT_SOURCE_DIR}/modules/hicn_light_common.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/modules/hicn_light_ng_api.c
+  )
 else()
-    add_subdirectory(modules)
+  add_subdirectory(modules)
 endif()
 
+
+##############################################################
+# Compiler options
+##############################################################
+set(COMPILER_OPTIONS
+  ${DEFAULT_COMPILER_OPTIONS}
+)
+
+
+##############################################################
+# Build main hicnctrl library
+##############################################################
 build_library(${LIBHICNCTRL}
-    ${LINK_TYPE}
-    SOURCES ${SOURCE_FILES} ${HEADER_FILES}
-    INSTALL_HEADERS ${TO_INSTALL_HEADER_FILES}
+  ${LINK_TYPE}
+  SOURCES ${SOURCE_FILES} ${HEADER_FILES}
+  INSTALL_HEADERS ${TO_INSTALL_HEADER_FILES}
+  LINK_LIBRARIES ${LIBRARIES}
+  DEPENDS ${DEPENDENCIES}
+  COMPONENT ${LIBHICNCTRL_COMPONENT}
+  INCLUDE_DIRS ${INCLUDE_DIRS}
+  DEFINITIONS PUBLIC ${COMPILER_DEFINITIONS}
+  VERSION ${CURRENT_VERSION}
+  EXPORT_NAME "${LIBHICNCTRL_COMPONENT}"
+  COMPILE_OPTIONS ${COMPILER_OPTIONS}
+)
+
+
+##############################################################
+# Cmake config files
+##############################################################
+create_cmake_config (
+  ${LIBHICNCTRL_COMPONENT}
+  INCLUDE_DIRS ${Libhicnctrl_INCLUDE_DIRS}
+  VERSION ${CURRENT_VERSION}
+  COMPONENT ${LIBHICNCTRL_COMPONENT}
+  NAMESPACE hicn
+)
+
+
+##############################################################
+# Build executables
+##############################################################
+if (NOT DISABLE_EXECUTABLES)
+  if (DISABLE_SHARED_LIBRARIES)
+    set(LIBRARIES ${LIBRARIES} ${LIBHICNCTRL_STATIC})
+    set(DEPENDENCIES ${LIBHICNCTRL_STATIC})
+  else ()
+    set(LIBRARIES ${LIBRARIES} ${LIBHICN_SHARED} ${LIBHICNCTRL_SHARED})
+    set(DEPENDENCIES ${LIBHICNCTRL_SHARED})
+  endif ()
+
+  list(APPEND DAEMON_SRC
+    hicnctrl.c
+  )
+
+  build_executable(${HICNCTRL}
+    SOURCES ${DAEMON_SRC}
     LINK_LIBRARIES ${LIBRARIES}
     DEPENDS ${DEPENDENCIES}
     COMPONENT ${LIBHICNCTRL_COMPONENT}
     INCLUDE_DIRS ${INCLUDE_DIRS}
-    HEADER_ROOT_DIR hicn
     DEFINITIONS ${COMPILER_DEFINITIONS}
-)
-
-if (NOT DISABLE_EXECUTABLES)
-    if (DISABLE_SHARED_LIBRARIES)
-        set(LIBRARIES ${LIBRARIES} ${LIBHICNCTRL_STATIC})
-        set(DEPENDENCIES ${LIBHICNCTRL_STATIC})
-    else ()
-        set(LIBRARIES ${LIBRARIES} ${LIBHICN_SHARED} ${LIBHICNCTRL_SHARED})
-        set(DEPENDENCIES ${LIBHICNCTRL_SHARED})
-    endif ()
-
-    list(APPEND DAEMON_SRC
-      cli.c
-    )
-
-    build_executable(${HICNCTRL}
-      SOURCES ${DAEMON_SRC}
-      LINK_LIBRARIES ${LIBRARIES}
-      DEPENDS ${DEPENDENCIES}
-      COMPONENT ${LIBHICNCTRL_COMPONENT}
-      INCLUDE_DIRS ${INCLUDE_DIRS}
-      DEFINITIONS ${COMPILER_DEFINITIONS}
-      LINK_FLAGS ${LINK_FLAGS}
-    )
+    LINK_FLAGS ${LINK_FLAGS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS}
+  )
 endif ()
diff --git a/ctrl/libhicnctrl/src/api.c b/ctrl/libhicnctrl/src/api.c
index 4bb66c784..4156ceff9 100644
--- a/ctrl/libhicnctrl/src/api.c
+++ b/ctrl/libhicnctrl/src/api.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -18,22 +18,26 @@
  * \brief Implementation of hICN control library API
  */
 
+#include <assert.h>
+#include <dlfcn.h>  // dlopen
+#include <hicn/strategy.h>
 #include <hicn/util/log.h>
-#include "api_private.h"
+#include <hicn/ctrl/route.h>
+#include <math.h>  // log2
 
-#include <math.h>   // log2
-#include <dlfcn.h>  // dlopen
+#include "api_private.h"
 
+#if 0
 /* /!\ Please update constants in public header file upon changes */
 const char * connection_state_str[] = {
-#define _(x) [HC_CONNECTION_STATE_ ## x] = STRINGIZE(x),
+#define _(x) [HC_CONNECTION_STATE_##x] = STRINGIZE(x),
 foreach_connection_state
 #undef _
 };
 
 /* /!\ Please update constants in public header file upon changes */
 const char * connection_type_str[] = {
-#define _(x) [CONNECTION_TYPE_ ## x] = STRINGIZE(x),
+#define _(x) [CONNECTION_TYPE_##x] = STRINGIZE(x),
 foreach_connection_type
 #undef _
 };
@@ -48,151 +52,72 @@ connection_type_from_str(const char * str)
     else if (strcasecmp(str, "HICN") == 0)
         return CONNECTION_TYPE_HICN;
     else
-	    return CONNECTION_TYPE_UNDEFINED;
+        return CONNECTION_TYPE_UNDEFINED;
 }
-
-/* Conversions to shield lib user from heterogeneity */
-
-#define IS_VALID_LIST_CONNECTIONS_TYPE(x) ((x >= CONN_GRE) && (x <= CONN_HICN))
-
-const hc_connection_type_t map_from_list_connections_type[] = {
-    [CONN_GRE]       = CONNECTION_TYPE_UNDEFINED,
-    [CONN_TCP]       = CONNECTION_TYPE_TCP,
-    [CONN_UDP]       = CONNECTION_TYPE_UDP,
-    [CONN_MULTICAST] = CONNECTION_TYPE_UNDEFINED,
-    [CONN_L2]        = CONNECTION_TYPE_UNDEFINED,
-    [CONN_HICN]      = CONNECTION_TYPE_HICN,
-};
-
-#define IS_VALID_LIST_LISTENERS_TYPE(x) ((x >= ENCAP_TCP) && (x <= ENCAP_HICN))
-
-const hc_connection_type_t map_from_encap_type[] = {
-    [ENCAP_TCP]     = CONNECTION_TYPE_TCP,
-    [ENCAP_UDP]     = CONNECTION_TYPE_UDP,
-    [ENCAP_ETHER]   = CONNECTION_TYPE_UNDEFINED,
-    [ENCAP_LOCAL]   = CONNECTION_TYPE_UNDEFINED,
-    [ENCAP_HICN]    = CONNECTION_TYPE_HICN,
-};
-
-const connection_type map_to_connection_type[] = {
-    [CONNECTION_TYPE_TCP]   = TCP_CONN,
-    [CONNECTION_TYPE_UDP]   = UDP_CONN,
-    [CONNECTION_TYPE_HICN]  = HICN_CONN,
-};
-
-const listener_mode map_to_listener_mode[] = {
-    [CONNECTION_TYPE_TCP]       = IP_MODE,
-    [CONNECTION_TYPE_UDP]       = IP_MODE,
-    [CONNECTION_TYPE_HICN]      = HICN_MODE,
-};
-
-#define IS_VALID_LIST_CONNECTIONS_STATE(x) ((x >= IFACE_UP) && (x <= IFACE_UNKNOWN))
-
-/*
-#define IS_VALID_CONNECTION_STATE(x) IS_VALID_ENUM_TYPE(CONNECTION_STATE, x)
-
-static const connection_state map_to_connection_state[] = {
-    [HC_CONNECTION_STATE_UP]       = IFACE_UP,
-    [HC_CONNECTION_STATE_DOWN]     = IFACE_DOWN,
-};
-
-*/
-
-const hc_connection_state_t map_from_list_connections_state[] = {
-    [IFACE_UP]                  = HC_CONNECTION_STATE_UP,
-    [IFACE_DOWN]                = HC_CONNECTION_STATE_DOWN,
-    [IFACE_UNKNOWN]             = HC_CONNECTION_STATE_UNDEFINED,
-};
-
-
-const int map_from_addr_type[] = {
-    [ADDR_INET]     = AF_INET,
-    [ADDR_INET6]    = AF_INET6,
-    [ADDR_LINK]     = AF_UNSPEC,
-    [ADDR_IFACE]    = AF_UNSPEC,
-    [ADDR_UNIX]     = AF_UNSPEC,
-};
-
-const address_type map_to_addr_type[] = {
-    [AF_INET]   = ADDR_INET,
-    [AF_INET6]  = ADDR_INET6,
-};
+#endif
 
 /******************************************************************************
  * Control Data
  ******************************************************************************/
 
-hc_data_t *
-hc_data_create(size_t in_element_size, size_t out_element_size, data_callback_t complete_cb)
-{
-    hc_data_t * data = malloc(sizeof(hc_data_t));
-    if (!data)
-        goto ERR_MALLOC;
-
-    /* FIXME Could be NULL thanks to realloc provided size is 0 */
-    data->max_size_log = DEFAULT_SIZE_LOG;
-    data->in_element_size = in_element_size;
-    data->out_element_size = out_element_size;
-    data->size = 0;
-    data->complete = false;
-    data->command_id = 0; // TODO this could also be a busy mark in the socket
-    /* No callback needed in blocking code for instance */
-    data->complete_cb = complete_cb;
-
-    data->buffer = malloc((1 << data->max_size_log) * data->out_element_size);
-    if (!data->buffer)
-        goto ERR_BUFFER;
-    data->ret = 0;
-
-    return data;
+hc_data_t *hc_data_create(size_t in_element_size, size_t out_element_size,
+                          data_callback_t complete_cb) {
+  hc_data_t *data = malloc(sizeof(hc_data_t));
+  if (!data) goto ERR_MALLOC;
+
+  /* FIXME Could be NULL thanks to realloc provided size is 0 */
+  data->max_size_log = DEFAULT_SIZE_LOG;
+  data->in_element_size = in_element_size;
+  data->out_element_size = out_element_size;
+  data->size = 0;
+  data->complete = false;
+  data->command_id = 0;  // TODO this could also be a busy mark in the socket
+  /* No callback needed in blocking code for instance */
+  data->complete_cb = complete_cb;
+
+  data->buffer = malloc((1 << data->max_size_log) * data->out_element_size);
+  if (!data->buffer) goto ERR_BUFFER;
+  data->ret = 0;
+  data->current = 0;
+
+  return data;
 
 ERR_BUFFER:
-    hc_data_free(data);
+  hc_data_free(data);
 ERR_MALLOC:
-    return NULL;
+  return NULL;
 }
 
-void
-hc_data_free(hc_data_t * data)
-{
-    if (data->buffer)
-        free(data->buffer);
-    free(data);
+void hc_data_free(hc_data_t *data) {
+  if (data) free(data->buffer);
+  free(data);
 }
 
-int
-hc_data_ensure_available(hc_data_t * data, size_t count)
-{
-    size_t new_size_log = (data->size + count - 1 > 0)
-        ? log2(data->size + count - 1) + 1
-        : 0;
-    if (new_size_log > data->max_size_log) {
-        data->max_size_log = new_size_log;
-        data->buffer = realloc(data->buffer, (1 << new_size_log) * data->out_element_size);
-        if (!data->buffer)
-             return -1;
-    }
+int hc_data_ensure_available(hc_data_t *data, size_t count) {
+  size_t new_size_log =
+      (data->size + count - 1 > 0) ? log2(data->size + count - 1) + 1 : 0;
+  if (new_size_log > data->max_size_log) {
+    data->max_size_log = new_size_log;
+    data->buffer =
+        realloc(data->buffer, (1 << new_size_log) * data->out_element_size);
+    if (!data->buffer) return -1;
+  }
 
-    return 0;
+  return 0;
 }
 
-int
-hc_data_push_many(hc_data_t * data, const void * elements, size_t count)
-{
-    if (hc_data_ensure_available(data, count) < 0)
-         return -1;
+int hc_data_push_many(hc_data_t *data, const void *elements, size_t count) {
+  if (hc_data_ensure_available(data, count) < 0) return -1;
 
-    memcpy(data->buffer + data->size * data->out_element_size, elements,
-            count * data->out_element_size);
-    data->size += count;
+  memcpy(data->buffer + data->size * data->out_element_size, elements,
+         count * data->out_element_size);
+  data->size += count;
 
-    return 0;
+  return 0;
 }
 
-int
-hc_data_push(hc_data_t * data, const void * element)
-{
-    return hc_data_push_many(data, element, 1);
+int hc_data_push(hc_data_t *data, const void *element) {
+  return hc_data_push_many(data, element, 1);
 }
 
 /**
@@ -200,61 +125,48 @@ hc_data_push(hc_data_t * data, const void * element)
  * NOTE: This function make sure there is enough room available in the data
  * structure.
  */
-u8 *
-hc_data_get_next(hc_data_t * data)
-{
-    if (hc_data_ensure_available(data, 1) < 0)
-        return NULL;
+u8 *hc_data_get_next(hc_data_t *data) {
+  if (hc_data_ensure_available(data, 1) < 0) return NULL;
 
-    return data->buffer + data->size * data->out_element_size;
+  return data->buffer + data->size * data->out_element_size;
 }
 
-int
-hc_data_set_callback(hc_data_t * data, data_callback_t cb, void * cb_data)
-{
-    data->complete_cb = cb;
-    data->complete_cb_data = cb_data;
-    return 0;
+int hc_data_set_callback(hc_data_t *data, data_callback_t cb, void *cb_data) {
+  data->complete_cb = cb;
+  data->complete_cb_data = cb_data;
+  return 0;
 }
 
-int
-hc_data_set_complete(hc_data_t * data)
-{
-    data->complete = true;
-    data->ret = 0;
-    if (data->complete_cb)
-        return data->complete_cb(data, data->complete_cb_data);
-    return 0;
+int hc_data_set_complete(hc_data_t *data) {
+  data->complete = true;
+  data->ret = 0;
+  if (data->complete_cb) return data->complete_cb(data, data->complete_cb_data);
+  return 0;
 }
 
-int
-hc_data_set_error(hc_data_t * data)
-{
-     data->ret = -1;
-     return 0;
+int hc_data_set_error(hc_data_t *data) {
+  data->ret = -1;
+  return 0;
 }
 
-int
-hc_data_reset(hc_data_t * data)
-{
-    data->size = 0;
-    return 0;
+int hc_data_reset(hc_data_t *data) {
+  data->size = 0;
+  return 0;
 }
 
-static hc_sock_t * _open_module(const char *name)
-{
+static hc_sock_t *_open_module(const char *name, const char *url) {
   char complete_name[128];
 #ifdef __APPLE__
-  sprintf(complete_name, "%s.dylib", name);
+  snprintf(complete_name, 128, "%s.dylib", name);
 #elif defined(__linux__)
-  sprintf(complete_name, "%s.so", name);
+  snprintf(complete_name, 128, "%s.so", name);
 #else
-  #error "System not supported for dynamic lynking"
+#error "System not supported for dynamic lynking"
 #endif
 
   void *handle = 0;
   const char *error = 0;
-  hc_sock_t *(*creator)(void) = 0;
+  hc_sock_t *(*creator)(const char *) = 0;
   hc_sock_t *ret = 0;
 
   // open module
@@ -263,307 +175,305 @@ static hc_sock_t * _open_module(const char *name)
     if ((error = dlerror()) != 0) {
       ERROR("%s", error);
     }
-
     return 0;
   }
 
   // get factory method
-  creator = (hc_sock_t * (*)(void)) dlsym(handle, "_hc_sock_create");
+  creator =
+      (hc_sock_t * (*)(const char *)) dlsym(handle, "_hc_sock_create_url");
   if (!creator) {
     if ((error = dlerror()) != 0) {
       ERROR("%s", error);
-      return 0;
     }
+    return 0;
   }
 
-  ret = (*creator)();
+  ret = (*creator)(NULL);
   ret->handle = handle;
 
   return ret;
 }
 
-hc_sock_t *hc_sock_create_forwarder(forwarder_t forwarder)
-{
-    switch (forwarder)
-    {
-        case HICNLIGHT:
-            return _open_module("hicnlightctrl_module");
-        case VPP:
-            return _open_module("vppctrl_module");
-        default:
-            return NULL;
-    }
+hc_sock_t *hc_sock_create_forwarder_url(forwarder_type_t forwarder,
+                                        const char *url) {
+  switch (forwarder) {
+    case HICNLIGHT:
+      return _open_module("hicnlightctrl_module", url);
+    case HICNLIGHT_NG:
+      return _open_module("hicnlightngctrl_module", url);
+    case VPP:
+      return _open_module("vppctrl_module", url);
+    default:
+      return NULL;
+  }
 }
 
 #ifdef ANDROID
 // In android we do not load a module at runtime
 // but we link the hicnlight implmentation directly
 // to the main library
-extern hc_sock_t *_hc_sock_create();
+extern hc_sock_t *_hc_sock_create_url(const char *url);
 #endif
 
-hc_sock_t *hc_sock_create(void)
-{
+hc_sock_t *hc_sock_create_forwarder(forwarder_type_t forwarder) {
 #ifdef ANDROID
-    hc_sock_t *ret = _hc_sock_create();
-    ret->handle = NULL;
-    return ret;
+  assert(forwarder == HICNLIGHT_NG);
+  hc_sock_t *ret = _hc_sock_create_url(NULL);
+  ret->handle = NULL;
+  return ret;
 #else
-    return hc_sock_create_forwarder(HICNLIGHT);
+  return hc_sock_create_forwarder_url(forwarder, NULL);
 #endif
 }
 
-void hc_sock_free(hc_sock_t *s)
-{
-    void *handle = s->handle;
-    s->hc_sock_free(s);
-
-    if (handle) {
-        dlclose(handle);
-    }
+hc_sock_t *hc_sock_create(void) {
+  return hc_sock_create_forwarder(HICNLIGHT_NG);
 }
 
-int hc_sock_get_next_seq(hc_sock_t *s)
-{
-    return s->hc_sock_get_next_seq(s);
-}
+void hc_sock_free(hc_sock_t *s) {
+  void *handle = s->handle;
+  s->hc_sock_free(s);
 
-int hc_sock_set_nonblocking(hc_sock_t *s)
-{
-    return s->hc_sock_get_next_seq(s);
+  if (handle) {
+    dlclose(handle);
+  }
 }
 
-int hc_sock_get_fd(hc_sock_t *s)
-{
-    return s->hc_sock_get_fd(s);
+int hc_sock_get_next_seq(hc_sock_t *s) { return s->hc_sock_get_next_seq(s); }
+
+int hc_sock_set_nonblocking(hc_sock_t *s) { return s->hc_sock_get_next_seq(s); }
+
+int hc_sock_get_fd(hc_sock_t *s) { return s->hc_sock_get_fd(s); }
+
+int hc_sock_connect(hc_sock_t *s) { return s->hc_sock_connect(s); }
+
+int hc_sock_get_available(hc_sock_t *s, u8 **buffer, size_t *size) {
+  return s->hc_sock_get_available(s, buffer, size);
 }
 
-int hc_sock_connect(hc_sock_t *s)
-{
-    return s->hc_sock_connect(s);
+int hc_sock_send(hc_sock_t *s, hc_msg_t *msg, size_t msglen, uint32_t seq) {
+  return s->hc_sock_send(s, msg, msglen, seq);
 }
 
-int hc_sock_get_available(hc_sock_t *s, u8 **buffer, size_t *size)
-{
-    return s->hc_sock_get_available(s, buffer, size);
+int hc_sock_recv(hc_sock_t *s) { return s->hc_sock_recv(s); }
+
+int hc_sock_process(hc_sock_t *s, hc_data_t **data) {
+  return s->hc_sock_process(s, data);
 }
 
-int hc_sock_send(hc_sock_t *s, hc_msg_t *msg, size_t msglen, int seq)
-{
-    return s->hc_sock_send(s, msg, msglen, seq);
+int hc_sock_callback(hc_sock_t *s, hc_data_t **data) {
+  return s->hc_sock_callback(s, data);
 }
 
-int hc_sock_recv(hc_sock_t *s)
-{
-    return s->hc_sock_recv(s);
+int hc_sock_reset(hc_sock_t *s) { return s->hc_sock_reset(s); }
+
+void hc_sock_increment_woff(hc_sock_t *s, size_t bytes) {
+  s->hc_sock_increment_woff(s, bytes);
 }
 
-int hc_sock_process(hc_sock_t *s, hc_data_t **data)
-{
-    return s->hc_sock_process(s, data);
+int hc_sock_prepare_send(hc_sock_t *s, hc_result_t *result,
+                         data_callback_t complete_cb, void *complete_cb_data) {
+  return s->hc_sock_prepare_send(s, result, complete_cb, complete_cb_data);
 }
 
-int hc_sock_callback(hc_sock_t *s, hc_data_t **data)
-{
-    return s->hc_sock_callback(s, data);
+int hc_sock_set_recv_timeout_ms(hc_sock_t *s, long timeout_ms) {
+  return s->hc_sock_set_recv_timeout_ms(s, timeout_ms);
 }
 
-int hc_sock_reset(hc_sock_t *s)
-{
-    return s->hc_sock_reset(s);
+/*----------------------------------------------------------------------------*
+ * LISTENER
+ *----------------------------------------------------------------------------*/
+
+int hc_listener_create(hc_sock_t *s, hc_listener_t *listener) {
+  return s->hc_listener_create(s, listener);
 }
 
-int hc_listener_create(hc_sock_t *s, hc_listener_t *listener)
-{
-    return s->hc_listener_create(s, listener);
+hc_result_t *hc_listener_create_conf(hc_sock_t *s, hc_listener_t *listener) {
+  return s->hc_listener_create_conf(s, listener);
 }
 
 int hc_listener_get(hc_sock_t *s, hc_listener_t *listener,
-                    hc_listener_t **listener_found)
-{
-    return s->hc_listener_get(s, listener, listener_found);
+                    hc_listener_t **listener_found) {
+  return s->hc_listener_get(s, listener, listener_found);
 }
 
-int hc_listener_delete(hc_sock_t *s, hc_listener_t *listener)
-{
-    return s->hc_listener_delete(s, listener);
+int hc_listener_delete(hc_sock_t *s, hc_listener_t *listener) {
+  return s->hc_listener_delete(s, listener);
 }
 
-int hc_listener_list(hc_sock_t *s, hc_data_t **pdata)
-{
-    return s->hc_listener_list(s, pdata);
+int hc_listener_list(hc_sock_t *s, hc_data_t **pdata) {
+  return s->hc_listener_list(s, pdata);
 }
 
 GENERATE_FIND(listener);
 
 /* LISTENER VALIDATE */
 
-int
-hc_listener_validate(const hc_listener_t * listener)
-{
-    if (!IS_VALID_FAMILY(listener->family))
-         return -1;
-
-    if (!IS_VALID_CONNECTION_TYPE(listener->type))
-         return -1;
+int hc_listener_validate(const hc_listener_t *listener) {
+  if (!IS_VALID_NAME(listener->name)) {
+    ERROR("[hc_listener_validate] Invalid name specified");
+    return -1;
+  }
+  if (!IS_VALID_INTERFACE_NAME(listener->interface_name)) {
+    ERROR("[hc_listener_validate] Invalid interface_name specified");
+    return -1;
+  }
+  if (!IS_VALID_TYPE(listener->type)) {
+    ERROR("[hc_listener_validate] Invalid type specified");
+    return -1;
+  }
+  if (!IS_VALID_FAMILY(listener->family)) {
+    ERROR("[hc_listener_validate] Invalid family specified");
+    return -1;
+  }
+  if (!IS_VALID_ADDRESS(&listener->local_addr, listener->family)) {
+    ERROR("[hc_listener_validate] Invalid local_addr specified");
+    return -1;
+  }
+  if (!IS_VALID_PORT(listener->local_port)) {
+    ERROR("[hc_listener_validate] Invalid local_port specified");
+    return -1;
+  }
 
-    return 0;
+  return 0;
 }
 
 /* LISTENER CMP */
 
-int
-hc_listener_cmp(const hc_listener_t * l1, const hc_listener_t * l2)
-{
-    int rc;
-
-    rc = INT_CMP(l1->type, l2->type);
-    if (rc != 0)
-        return rc;
-
-    rc = INT_CMP(l1->family, l2->family);
-    if (rc != 0)
-        return rc;
+int hc_listener_cmp(const hc_listener_t *l1, const hc_listener_t *l2) {
+  int rc;
 
-    rc = strncmp(l1->interface_name, l2->interface_name, INTERFACE_LEN);
-    if (rc != 0)
-        return rc;
+  rc = INT_CMP(l1->type, l2->type);
+  if (rc != 0) return rc;
 
-    rc = ip_address_cmp(&l1->local_addr, &l2->local_addr, l1->family);
-    if (rc != 0)
-        return rc;
+  rc = INT_CMP(l1->family, l2->family);
+  if (rc != 0) return rc;
 
-    rc = INT_CMP(l1->local_port, l2->local_port);
-    if (rc != 0)
-        return rc;
+  rc = strncmp(l1->interface_name, l2->interface_name, INTERFACE_LEN);
+  if (rc != 0) return rc;
 
-    return rc;
-}
+  rc = ip_address_cmp(&l1->local_addr, &l2->local_addr, l1->family);
+  if (rc != 0) return rc;
 
-/* LISTENER PARSE */
+  rc = INT_CMP(l1->local_port, l2->local_port);
+  if (rc != 0) return rc;
 
-int
-hc_listener_parse(void * in, hc_listener_t * listener)
-{
-    int rc;
-
-    list_listeners_command * cmd = (list_listeners_command *)in;
-
-    if (!IS_VALID_LIST_LISTENERS_TYPE(cmd->encapType))
-         return -1;
-
-    hc_connection_type_t type = map_from_encap_type[cmd->encapType];
-    if (type == CONNECTION_TYPE_UNDEFINED)
-         return -1;
-
-    if (!IS_VALID_ADDR_TYPE(cmd->addressType))
-         return -1;
-
-    int family = map_from_addr_type[cmd->addressType];
-    if (!IS_VALID_FAMILY(family))
-         return -1;
-
-    *listener = (hc_listener_t) {
-        .id = cmd->connid,
-        .type = type,
-        .family = family,
-        .local_addr = UNION_CAST(cmd->address, ip_address_t),
-        .local_port = ntohs(cmd->port),
-    };
-    rc = snprintf(listener->name, SYMBOLIC_NAME_LEN, "%s", cmd->listenerName);
-    if (rc >= SYMBOLIC_NAME_LEN)
-        WARN("[hc_listener_parse] Unexpected truncation of symbolic name string");
-    rc = snprintf(listener->interface_name, INTERFACE_LEN, "%s", cmd->interfaceName);
-    if (rc >= INTERFACE_LEN)
-        WARN("[hc_listener_parse] Unexpected truncation of interface name string");
-    return 0;
+  return rc;
 }
 
 /* LISTENER SNPRINTF */
 
 /* /!\ Please update constants in header file upon changes */
-int
-hc_listener_snprintf(char * s, size_t size, hc_listener_t * listener)
-{
-    char local[MAXSZ_URL];
-    int rc;
-    rc = url_snprintf(local, MAXSZ_URL,
-         listener->family, &listener->local_addr, listener->local_port);
-    if (rc >= MAXSZ_URL)
-        WARN("[hc_listener_snprintf] Unexpected truncation of URL string");
-    if (rc < 0)
-        return rc;
+int hc_listener_snprintf(char *s, size_t size, hc_listener_t *listener) {
+  char local[MAXSZ_URL];
+  int rc;
+  rc = url_snprintf(local, MAXSZ_URL, listener->family, &listener->local_addr,
+                    listener->local_port);
+  if (rc >= MAXSZ_URL)
+    WARN("[hc_listener_snprintf] Unexpected truncation of URL string");
+  if (rc < 0) return rc;
 
-    return snprintf(s, size, "%s %s %s", listener->interface_name, local,
-            connection_type_str[listener->type]);
+  return snprintf(s, size, "%s %s %s interface=%s", listener->name, local,
+                  face_type_str(listener->type), listener->interface_name);
 }
 
-int hc_connection_create(hc_sock_t *s, hc_connection_t *connection)
-{
-    return s->hc_connection_create(s, connection);
+/*----------------------------------------------------------------------------*
+ * CONNECTION
+ *----------------------------------------------------------------------------*/
+
+int hc_connection_create(hc_sock_t *s, hc_connection_t *connection) {
+  return s->hc_connection_create(s, connection);
+}
+
+hc_result_t *hc_connection_create_conf(hc_sock_t *s,
+                                       hc_connection_t *connection) {
+  return s->hc_connection_create_conf(s, connection);
 }
 
 int hc_connection_get(hc_sock_t *s, hc_connection_t *connection,
-                      hc_connection_t **connection_found)
-{
-    return s->hc_connection_get(s, connection, connection_found);
+                      hc_connection_t **connection_found) {
+  return s->hc_connection_get(s, connection, connection_found);
 }
 
 int hc_connection_update_by_id(hc_sock_t *s, int hc_connection_id,
-                               hc_connection_t *connection)
-{
-    return s->hc_connection_update_by_id(s, hc_connection_id, connection);
+                               hc_connection_t *connection) {
+  return s->hc_connection_update_by_id(s, hc_connection_id, connection);
 }
 
 int hc_connection_update(hc_sock_t *s, hc_connection_t *connection_current,
-                         hc_connection_t *connection_updated)
-{
-    return s->hc_connection_update(s, connection_current, connection_updated);
+                         hc_connection_t *connection_updated) {
+  return s->hc_connection_update(s, connection_current, connection_updated);
 }
 
-int hc_connection_delete(hc_sock_t *s, hc_connection_t *connection)
-{
-    return s->hc_connection_delete(s, connection);
+int hc_connection_delete(hc_sock_t *s, hc_connection_t *connection) {
+  return s->hc_connection_delete(s, connection);
 }
 
-int hc_connection_list(hc_sock_t *s, hc_data_t **pdata)
-{
-    return s->hc_connection_list(s, pdata);
+hc_result_t *hc_connection_delete_conf(hc_sock_t *s,
+                                       hc_connection_t *connection) {
+  return s->hc_connection_delete_conf(s, connection);
 }
 
-int hc_connection_set_admin_state(hc_sock_t * s, const char * conn_id_or_name, face_state_t state)
-{
-    return s->hc_connection_set_admin_state(s, conn_id_or_name, state);
+int hc_connection_list(hc_sock_t *s, hc_data_t **pdata) {
+  return s->hc_connection_list(s, pdata);
+}
+
+int hc_connection_set_admin_state(hc_sock_t *s, const char *conn_id_or_name,
+                                  face_state_t state) {
+  return s->hc_connection_set_admin_state(s, conn_id_or_name, state);
 }
 
 #ifdef WITH_POLICY
-int hc_connection_set_priority(hc_sock_t * s, const char * conn_id_or_name, uint32_t priority)
-{
-    return s->hc_connection_set_priority(s, conn_id_or_name, priority);
+int hc_connection_set_priority(hc_sock_t *s, const char *conn_id_or_name,
+                               uint32_t priority) {
+  return s->hc_connection_set_priority(s, conn_id_or_name, priority);
 }
 
-int hc_connection_set_tags(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t tags)
-{
-    return s->hc_connection_set_tags(s, conn_id_or_name, tags);
+int hc_connection_set_tags(hc_sock_t *s, const char *conn_id_or_name,
+                           policy_tags_t tags) {
+  return s->hc_connection_set_tags(s, conn_id_or_name, tags);
 }
-#endif // WITH_POLICY
+#endif  // WITH_POLICY
 
 GENERATE_FIND(connection);
 
 /* CONNECTION VALIDATE */
 
-int
-hc_connection_validate(const hc_connection_t * connection)
-{
-    if (!IS_VALID_FAMILY(connection->family))
-         return -1;
-
-    if (!IS_VALID_CONNECTION_TYPE(connection->type))
-         return -1;
-
-    /* TODO assert both local and remote have the right family */
+int hc_connection_validate(const hc_connection_t *connection) {
+  if (!IS_VALID_NAME(connection->name)) {
+    ERROR("[hc_connection_validate] Invalid name specified");
+    return -1;
+  }
+  if (!IS_VALID_INTERFACE_NAME(connection->interface_name)) {
+    ERROR("[hc_connection_validate] Invalid interface_name specified");
+    return -1;
+  }
+  if (!IS_VALID_TYPE(connection->type)) {
+    ERROR("[hc_connection_validate] Invalid type specified");
+    return -1;
+  }
+  if (!IS_VALID_FAMILY(connection->family)) {
+    ERROR("[hc_connection_validate] Invalid family specified");
+    return -1;
+  }
+  if (!IS_VALID_ADDRESS(&connection->local_addr, connection->family)) {
+    ERROR("[hc_connection_validate] Invalid local_addr specified");
+    return -1;
+  }
+  if (!IS_VALID_PORT(connection->local_port)) {
+    ERROR("[hc_connection_validate] Invalid local_port specified");
+    return -1;
+  }
+  if (!IS_VALID_ADDRESS(&connection->remote_addr, connection->family)) {
+    ERROR("[hc_connection_validate] Invalid remote_addr specified");
+    return -1;
+  }
+  if (!IS_VALID_PORT(connection->remote_port)) {
+    ERROR("[hc_connection_validate] Invalid remote_port specified");
+    return -1;
+  }
 
-    return 0;
+  return 0;
 }
 
 /* CONNECTION CMP */
@@ -573,719 +483,692 @@ hc_connection_validate(const hc_connection_t * connection)
  * As connections are specific to hicn-light, we can safely use IP and ports for
  * comparison independently of the face type.
  */
-int hc_connection_cmp(const hc_connection_t * c1, const hc_connection_t * c2)
-{
-    int rc;
+int hc_connection_cmp(const hc_connection_t *c1, const hc_connection_t *c2) {
+  int rc;
 
-    rc = INT_CMP(c1->type, c2->type);
-    if (rc != 0)
-        return rc;
+  rc = INT_CMP(c1->type, c2->type);
+  if (rc != 0) return rc;
 
-    rc = INT_CMP(c1->family, c2->family);
-    if (rc != 0)
-        return rc;
+  rc = INT_CMP(c1->family, c2->family);
+  if (rc != 0) return rc;
 
-    rc = strncmp(c1->interface_name, c2->interface_name, INTERFACE_LEN);
-    if (rc != 0)
-        return rc;
+  rc = strncmp(c1->interface_name, c2->interface_name, INTERFACE_LEN);
+  if (rc != 0) return rc;
 
-    rc = ip_address_cmp(&c1->local_addr, &c2->local_addr, c1->family);
-    if (rc != 0)
-        return rc;
+  rc = ip_address_cmp(&c1->local_addr, &c2->local_addr, c1->family);
+  if (rc != 0) return rc;
 
-    rc = INT_CMP(c1->local_port, c2->local_port);
-    if (rc != 0)
-        return rc;
+  rc = INT_CMP(c1->local_port, c2->local_port);
+  if (rc != 0) return rc;
 
-    rc = ip_address_cmp(&c1->remote_addr, &c2->remote_addr, c1->family);
-    if (rc != 0)
-        return rc;
+  rc = ip_address_cmp(&c1->remote_addr, &c2->remote_addr, c1->family);
+  if (rc != 0) return rc;
 
-    rc = INT_CMP(c1->remote_port, c2->remote_port);
-    if (rc != 0)
-        return rc;
+  rc = INT_CMP(c1->remote_port, c2->remote_port);
+  if (rc != 0) return rc;
 
-    return rc;
-}
-
-/* CONNECTION PARSE */
-
-int
-hc_connection_parse(void * in, hc_connection_t * connection)
-{
-    int rc;
-    list_connections_command * cmd = (list_connections_command *)in;
-
-    if (!IS_VALID_LIST_CONNECTIONS_TYPE(cmd->connectionData.connectionType))
-         return -1;
-
-    hc_connection_type_t type = map_from_list_connections_type[cmd->connectionData.connectionType];
-    if (type == CONNECTION_TYPE_UNDEFINED)
-         return -1;
-
-    if (!IS_VALID_LIST_CONNECTIONS_STATE(cmd->state))
-         return -1;
-
-    hc_connection_state_t state = map_from_list_connections_state[cmd->state];
-    if (state == HC_CONNECTION_STATE_UNDEFINED)
-         return -1;
-
-    if (!IS_VALID_ADDR_TYPE(cmd->connectionData.ipType))
-         return -1;
-
-    int family = map_from_addr_type[cmd->connectionData.ipType];
-    if (!IS_VALID_FAMILY(family))
-         return -1;
-
-    *connection = (hc_connection_t) {
-        .id = cmd->connid,
-        .type = type,
-        .family = family,
-        .local_addr = cmd->connectionData.localIp,
-        //.local_addr = UNION_CAST(cmd->connectionData.localIp, ip_address_t),
-        .local_port = ntohs(cmd->connectionData.localPort),
-        .remote_addr = cmd->connectionData.remoteIp,
-        //.remote_addr = UNION_CAST(cmd->connectionData.remoteIp, ip_address_t),
-        .remote_port = ntohs(cmd->connectionData.remotePort),
-        .admin_state = cmd->connectionData.admin_state,
-#ifdef WITH_POLICY
-        .priority = cmd->connectionData.priority,
-        .tags = cmd->connectionData.tags,
-#endif /* WITH_POLICY */
-        .state = state,
-    };
-    rc = snprintf(connection->name, SYMBOLIC_NAME_LEN, "%s", cmd->connectionData.symbolic);
-    if (rc >= SYMBOLIC_NAME_LEN)
-        WARN("[hc_connection_parse] Unexpected truncation of symbolic name string");
-    rc = snprintf(connection->interface_name, INTERFACE_LEN, "%s", cmd->interfaceName);
-    if (rc >= INTERFACE_LEN)
-        WARN("[hc_connection_parse] Unexpected truncation of interface name string");
-    return 0;
+  return rc;
 }
 
 /* CONNECTION SNPRINTF */
 
 /* /!\ Please update constants in header file upon changes */
-int
-hc_connection_snprintf(char * s, size_t size, const hc_connection_t * connection)
-{
-    char local[MAXSZ_URL];
-    char remote[MAXSZ_URL];
-    int rc;
-
-    // assert(connection->connection_state)
-
-    rc = url_snprintf(local, MAXSZ_URL, connection->family,
-            &connection->local_addr, connection->local_port);
-    if (rc >= MAXSZ_URL)
-        WARN("[hc_connection_snprintf] Unexpected truncation of URL string");
-    if (rc < 0)
-        return rc;
-    rc = url_snprintf(remote, MAXSZ_URL, connection->family,
-            &connection->remote_addr, connection->remote_port);
-    if (rc >= MAXSZ_URL)
-        WARN("[hc_connection_snprintf] Unexpected truncation of URL string");
-    if (rc < 0)
-        return rc;
-
-    return snprintf(s, size, "%s %s %s %s %s",
-            connection_state_str[connection->state],
-            connection->interface_name,
-            local,
-            remote,
-            connection_type_str[connection->type]);
-}
-
-int hc_face_create(hc_sock_t *s, hc_face_t *face)
-{
-    return s->hc_face_create(s, face);
+int hc_connection_snprintf(char *s, size_t size,
+                           const hc_connection_t *connection) {
+  char local[MAXSZ_URL];
+  char remote[MAXSZ_URL];
+  int rc;
+
+  // assert(connection->connection_state)
+  if (strcmp(connection->name, "SELF") == 0) {
+    return snprintf(s, size, "%s", connection->name);
+  }
+
+  rc = url_snprintf(local, MAXSZ_URL, connection->family,
+                    &connection->local_addr, connection->local_port);
+  if (rc >= MAXSZ_URL)
+    WARN("[hc_connection_snprintf] Unexpected truncation of URL string");
+  if (rc < 0) return rc;
+  rc = url_snprintf(remote, MAXSZ_URL, connection->family,
+                    &connection->remote_addr, connection->remote_port);
+  if (rc >= MAXSZ_URL)
+    WARN("[hc_connection_snprintf] Unexpected truncation of URL string");
+  if (rc < 0) return rc;
+
+  return snprintf(s, size, "%s %s %s %s", connection->name, local, remote,
+                  face_type_str(connection->type));
 }
 
-int hc_face_get(hc_sock_t *s, hc_face_t *face, hc_face_t **face_found)
-{
-    return s->hc_face_get(s, face, face_found);
+int hc_face_create(hc_sock_t *s, hc_face_t *face) {
+  return s->hc_face_create(s, face);
 }
 
-int hc_face_delete(hc_sock_t *s, hc_face_t *face)
-{
-    return s->hc_face_delete(s, face);
+int hc_face_get(hc_sock_t *s, hc_face_t *face, hc_face_t **face_found) {
+  return s->hc_face_get(s, face, face_found);
 }
 
-int hc_face_list(hc_sock_t *s, hc_data_t **pdata)
-{
-    return s->hc_face_list(s, pdata);
+int hc_face_delete(hc_sock_t *s, hc_face_t *face, uint8_t delete_listener) {
+  return s->hc_face_delete(s, face, delete_listener);
 }
 
-int hc_face_list_async(hc_sock_t *s)
-{
-    return s->hc_face_list_async(s);
+int hc_face_list(hc_sock_t *s, hc_data_t **pdata) {
+  return s->hc_face_list(s, pdata);
 }
 
-int hc_face_set_admin_state(hc_sock_t * s, const char * conn_id_or_name, face_state_t state)
-{
-    return s->hc_face_set_admin_state(s, conn_id_or_name, state);
+int hc_face_list_async(hc_sock_t *s) { return s->hc_face_list_async(s); }
+
+int hc_face_set_admin_state(hc_sock_t *s, const char *conn_id_or_name,
+                            face_state_t state) {
+  return s->hc_face_set_admin_state(s, conn_id_or_name, state);
 }
 
 #ifdef WITH_POLICY
-int hc_face_set_priority(hc_sock_t * s, const char * conn_id_or_name, uint32_t priority)
-{
-    return s->hc_face_set_priority(s, conn_id_or_name, priority);
+int hc_face_set_priority(hc_sock_t *s, const char *conn_id_or_name,
+                         uint32_t priority) {
+  return s->hc_face_set_priority(s, conn_id_or_name, priority);
 }
 
-int hc_face_set_tags(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t tags)
-{
-    return s->hc_face_set_tags(s, conn_id_or_name, tags);
+int hc_face_set_tags(hc_sock_t *s, const char *conn_id_or_name,
+                     policy_tags_t tags) {
+  return s->hc_face_set_tags(s, conn_id_or_name, tags);
 }
 #endif /* WITH_POLICY */
 
 /* /!\ Please update constants in header file upon changes */
-int
-hc_face_snprintf(char * s, size_t size, hc_face_t * face)
-{
-    /* URLs are also big enough to contain IP addresses in the hICN case */
-    char local[MAXSZ_URL];
-    char remote[MAXSZ_URL];
+int hc_face_snprintf(char *s, size_t size, hc_face_t *face) {
+  /* URLs are also big enough to contain IP addresses in the hICN case */
+  char local[MAXSZ_URL];
+  char remote[MAXSZ_URL];
 #ifdef WITH_POLICY
-    char tags[MAXSZ_POLICY_TAGS];
+  char tags[MAXSZ_POLICY_TAGS];
 #endif /* WITH_POLICY */
-    int rc;
-
-    switch(face->face.type) {
-        case FACE_TYPE_HICN:
-        case FACE_TYPE_HICN_LISTENER:
-            rc = ip_address_snprintf(local, MAXSZ_URL,
-                    &face->face.local_addr,
-                    face->face.family);
-            if (rc >= MAXSZ_URL)
-                WARN("[hc_face_snprintf] Unexpected truncation of URL string");
-            if (rc < 0)
-                return rc;
-            rc = ip_address_snprintf(remote, MAXSZ_URL,
-                    &face->face.remote_addr,
-                    face->face.family);
-            if (rc >= MAXSZ_URL)
-                WARN("[hc_face_snprintf] Unexpected truncation of URL string");
-            if (rc < 0)
-                return rc;
-            break;
-        case FACE_TYPE_TCP:
-        case FACE_TYPE_UDP:
-        case FACE_TYPE_TCP_LISTENER:
-        case FACE_TYPE_UDP_LISTENER:
-            rc = url_snprintf(local, MAXSZ_URL, face->face.family,
-                    &face->face.local_addr,
-                    face->face.local_port);
-            if (rc >= MAXSZ_URL)
-                WARN("[hc_face_snprintf] Unexpected truncation of URL string");
-            if (rc < 0)
-                return rc;
-            rc = url_snprintf(remote, MAXSZ_URL, face->face.family,
-                    &face->face.remote_addr,
-                    face->face.remote_port);
-            if (rc >= MAXSZ_URL)
-                WARN("[hc_face_snprintf] Unexpected truncation of URL string");
-            if (rc < 0)
-                return rc;
-            break;
-        default:
-            return -1;
-    }
+  int rc;
+
+  switch (face->face.type) {
+    case FACE_TYPE_HICN:
+    case FACE_TYPE_HICN_LISTENER:
+      rc = ip_address_snprintf(local, MAXSZ_URL, &face->face.local_addr,
+                               face->face.family);
+      if (rc >= MAXSZ_URL)
+        WARN("[hc_face_snprintf] Unexpected truncation of URL string");
+      if (rc < 0) return rc;
+      rc = ip_address_snprintf(remote, MAXSZ_URL, &face->face.remote_addr,
+                               face->face.family);
+      if (rc >= MAXSZ_URL)
+        WARN("[hc_face_snprintf] Unexpected truncation of URL string");
+      if (rc < 0) return rc;
+      break;
+    case FACE_TYPE_TCP:
+    case FACE_TYPE_UDP:
+    case FACE_TYPE_TCP_LISTENER:
+    case FACE_TYPE_UDP_LISTENER:
+      rc = url_snprintf(local, MAXSZ_URL, face->face.family,
+                        &face->face.local_addr, face->face.local_port);
+      if (rc >= MAXSZ_URL)
+        WARN("[hc_face_snprintf] Unexpected truncation of URL string");
+      if (rc < 0) return rc;
+      rc = url_snprintf(remote, MAXSZ_URL, face->face.family,
+                        &face->face.remote_addr, face->face.remote_port);
+      if (rc >= MAXSZ_URL)
+        WARN("[hc_face_snprintf] Unexpected truncation of URL string");
+      if (rc < 0) return rc;
+      break;
+    default:
+      return -1;
+  }
 
     // [#ID NAME] TYPE LOCAL_URL REMOTE_URL STATE/ADMIN_STATE (TAGS)
 #ifdef WITH_POLICY
-    rc = policy_tags_snprintf(tags, MAXSZ_POLICY_TAGS, face->face.tags);
-    if (rc >= MAXSZ_POLICY_TAGS)
-        WARN("[hc_face_snprintf] Unexpected truncation of policy tags string");
-    if (rc < 0)
-        return rc;
-
-    return snprintf(s, size, "[#%d %s] %s %s %s %s %s/%s [%d] (%s)",
-            face->id,
-            face->name,
-            face->face.netdevice.index != NETDEVICE_UNDEFINED_INDEX ? face->face.netdevice.name : "*",
-            face_type_str[face->face.type],
-            local,
-            remote,
-            face_state_str[face->face.state],
-            face_state_str[face->face.admin_state],
-            face->face.priority,
-            tags);
+  rc = policy_tags_snprintf(tags, MAXSZ_POLICY_TAGS, face->face.tags);
+  if (rc >= MAXSZ_POLICY_TAGS)
+    WARN("[hc_face_snprintf] Unexpected truncation of policy tags string");
+  if (rc < 0) return rc;
+
+  return snprintf(
+      s, size, "[#%d %s] %s %s %s %s %s/%s [%d] (%s)", face->id, face->name,
+      face->face.netdevice.index != NETDEVICE_UNDEFINED_INDEX
+          ? face->face.netdevice.name
+          : "*",
+      face_type_str(face->face.type), local, remote,
+      face_state_str(face->face.state), face_state_str(face->face.admin_state),
+      face->face.priority, tags);
 #else
-    return snprintf(s, size, "[#%d %s] %s %s %s %s %s/%s",
-            face->id,
-            face->name,
-            face->face.netdevice.index != NETDEVICE_UNDEFINED_INDEX ? face->face.netdevice.name : "*",
-            face_type_str[face->face.type],
-            local,
-            remote,
-            face_state_str[face->face.state],
-            face_state_str[face->face.admin_state]);
+  return snprintf(s, size, "[#%d %s] %s %s %s %s %s/%s", face->id, face->name,
+                  face->face.netdevice.index != NETDEVICE_UNDEFINED_INDEX
+                      ? face->face.netdevice.name
+                      : "*",
+                  face_type_str(face->face.type), local, remote,
+                  face_state_str(face->face.state),
+                  face_state_str(face->face.admin_state));
 #endif /* WITH_POLICY */
 }
 
-int
-hc_connection_parse_to_face(void * in, hc_face_t * face)
-{
-    hc_connection_t connection;
-
-    if (hc_connection_parse(in, &connection) < 0) {
-        ERROR("[hc_connection_parse_to_face] Could not parse connection");
-        return -1;
-    }
+/*----------------------------------------------------------------------------*
+ * ROUTE
+ *----------------------------------------------------------------------------*/
 
-    if (hc_connection_to_face(&connection, face) < 0) {
-        ERROR("[hc_connection_parse_to_face] Could not convert connection to face.");
-        return -1;
-    }
-
-    return 0;
+int hc_route_create(hc_sock_t *s, hc_route_t *route) {
+  return s->hc_route_create(s, route);
 }
 
-int hc_route_create(hc_sock_t * s, hc_route_t * route)
-{
-    return s->hc_route_create(s, route);
+hc_result_t *hc_route_create_conf(hc_sock_t *s, hc_route_t *route) {
+  return s->hc_route_create_conf(s, route);
 }
 
-int hc_route_delete(hc_sock_t * s, hc_route_t * route)
-{
-    return s->hc_route_delete(s, route);
+int hc_route_delete(hc_sock_t *s, hc_route_t *route) {
+  return s->hc_route_delete(s, route);
 }
 
-int hc_route_list(hc_sock_t * s, hc_data_t ** pdata)
-{
-    return s->hc_route_list(s, pdata);
+int hc_route_list(hc_sock_t *s, hc_data_t **pdata) {
+  return s->hc_route_list(s, pdata);
 }
 
-int hc_route_list_async(hc_sock_t * s)
-{
-    return s->hc_route_list_async(s);
-}
+int hc_route_list_async(hc_sock_t *s) { return s->hc_route_list_async(s); }
 
-/* ROUTE PARSE */
+/* ROUTE SNPRINTF */
 
-int
-hc_route_parse(void * in, hc_route_t * route)
-{
-    list_routes_command * cmd = (list_routes_command *) in;
+/* /!\ Please update constants in header file upon changes */
+int hc_route_snprintf(char *s, size_t size, hc_route_t *route) {
+  /* interface cost prefix length */
 
-    if (!IS_VALID_ADDR_TYPE(cmd->addressType)) {
-        ERROR("[hc_route_parse] Invalid address type");
-        return -1;
-    }
+  char prefix[MAXSZ_IP_ADDRESS];
+  int rc;
 
-    int family = map_from_addr_type[cmd->addressType];
-    if (!IS_VALID_FAMILY(family)) {
-        ERROR("[hc_route_parse] Invalid address family");
-        return -1;
-    }
+  rc = ip_address_snprintf(prefix, MAXSZ_IP_ADDRESS, &route->remote_addr,
+                           route->family);
+  if (rc >= MAXSZ_IP_ADDRESS)
+    ;
+  if (rc < 0) return rc;
 
-    *route = (hc_route_t) {
-        .face_id = cmd->connid,
-        .family = family,
-        .remote_addr = UNION_CAST(cmd->address, ip_address_t),
-        .len = cmd->len,
-        .cost = cmd->cost,
-    };
-    return 0;
+  return snprintf(s, size, "%s %*d %s %*d conn_id=%d", route->name, MAXSZ_COST,
+                  route->cost, prefix, MAXSZ_LEN, route->len, route->face_id);
 }
 
-/* ROUTE SNPRINTF */
-
-/* /!\ Please update constants in header file upon changes */
-int
-hc_route_snprintf(char * s, size_t size, hc_route_t * route)
-{
-    /* interface cost prefix length */
-
-    char prefix[MAXSZ_IP_ADDRESS];
-    int rc;
-
-    rc = ip_address_snprintf(prefix, MAXSZ_IP_ADDRESS, &route->remote_addr,
-            route->family);
-    if (rc >= MAXSZ_IP_ADDRESS)
-        ;
-    if (rc < 0)
-        return rc;
+int hc_route_validate(const hc_route_t *route) {
+  if (!IS_VALID_ID(route->connection_id)) {
+    ERROR("[hc_route_validate] Invalid connection id");
+    return -1;
+  }
+  if (!IS_VALID_NAME(route->name) && !IS_VALID_STR_ID(route->name)) {
+    ERROR("[hc_route_validate] Invalid name specified");
+    return -1;
+  }
+  if (!IS_VALID_FAMILY(route->family)) {
+    ERROR("[hc_route_validate] Invalid family specified");
+    return -1;
+  }
+  if (!IS_VALID_ADDRESS(&route->remote_addr, route->family)) {
+    ERROR("[hc_route_validate] Invalid remote_addr specified");
+    return -1;
+  }
+  if (!IS_VALID_ROUTE_COST(route->cost)) {
+    ERROR("[hc_route_validate] Invalid cost");
+    return -1;
+  }
+  if (!IS_VALID_PREFIX_LEN(route->len)) {
+    ERROR("[hc_route_validate] Invalid len");
+    return -1;
+  }
 
-    return snprintf(s, size, "%*d %*d %s %*d", MAXSZ_FACE_ID, route->face_id,
-            MAXSZ_COST, route->cost, prefix, MAXSZ_LEN, route->len);
+  return 0;
 }
 
+/*----------------------------------------------------------------------------*
+ * FACE
+ *----------------------------------------------------------------------------*/
+
 /* FACE -> LISTENER */
 
-int
-hc_face_to_listener(const hc_face_t * face, hc_listener_t * listener)
-{
-    const face_t * f = &face->face;
-
-    switch(f->type) {
-        case FACE_TYPE_HICN_LISTENER:
-            break;
-        case FACE_TYPE_TCP_LISTENER:
-            break;
-        case FACE_TYPE_UDP_LISTENER:
-            break;
-        default:
-             return -1;
-    }
-    return -1; /* XXX Not implemented */
+int hc_face_to_listener(const hc_face_t *face, hc_listener_t *listener) {
+  const face_t *f = &face->face;
+
+  switch (f->type) {
+    case FACE_TYPE_HICN_LISTENER:
+      break;
+    case FACE_TYPE_TCP_LISTENER:
+      break;
+    case FACE_TYPE_UDP_LISTENER:
+      break;
+    default:
+      return -1;
+  }
+  return -1; /* XXX Not implemented */
 }
 
 /* LISTENER -> FACE */
 
-int
-hc_listener_to_face(const hc_listener_t * listener, hc_face_t * face)
-{
-    return -1; /* XXX Not implemented */
+int hc_listener_to_face(const hc_listener_t *listener, hc_face_t *face) {
+  return -1; /* XXX Not implemented */
 }
 
 /* FACE -> CONNECTION */
 
-int
-hc_face_to_connection(const hc_face_t * face, hc_connection_t * connection, bool generate_name)
-{
-    int rc;
-    const face_t * f = &face->face;
-
-    switch(f->type) {
-        case FACE_TYPE_HICN:
-            *connection = (hc_connection_t) {
-                .type = CONNECTION_TYPE_HICN,
-                .family = f->family,
-                .local_addr = f->local_addr,
-                .local_port = 0,
-                .remote_addr = f->remote_addr,
-                .remote_port = 0,
-                .admin_state = face_state_to_connection_state(f->admin_state),
-                .state = face_state_to_connection_state(f->state),
+int hc_face_to_connection(const hc_face_t *face, hc_connection_t *connection,
+                          bool generate_name) {
+  int rc;
+
+  const face_t *f = &face->face;
+  switch (f->type) {
+    case FACE_TYPE_HICN:
+      *connection = (hc_connection_t){
+          .type = FACE_TYPE_HICN,
+          .family = f->family,
+          .local_addr = f->local_addr,
+          .local_port = 0,
+          .remote_addr = f->remote_addr,
+          .remote_port = 0,
+          .admin_state = f->admin_state,
+          .state = f->state,
 #ifdef WITH_POLICY
-                .priority = f->priority,
-                .tags = f->tags,
+          .priority = f->priority,
+          .tags = f->tags,
 #endif /* WITH_POLICY */
-            };
-            rc = snprintf(connection->name, SYMBOLIC_NAME_LEN, "%s",
+      };
+      rc = snprintf(connection->name, SYMBOLIC_NAME_LEN, "%s",
                     f->netdevice.name);
-            if (rc >= SYMBOLIC_NAME_LEN)
-                WARN("[hc_face_to_connection] Unexpected truncation of symbolic name string");
-            break;
-        case FACE_TYPE_TCP:
-            *connection = (hc_connection_t) {
-                .type = CONNECTION_TYPE_TCP,
-                .family = f->family,
-                .local_addr = f->local_addr,
-                .local_port = f->local_port,
-                .remote_addr = f->remote_addr,
-                .remote_port = f->remote_port,
-                .admin_state = face_state_to_connection_state(f->admin_state),
-                .state = face_state_to_connection_state(f->state),
+      if (rc >= SYMBOLIC_NAME_LEN)
+        WARN(
+            "[hc_face_to_connection] Unexpected truncation of symbolic "
+            "name string");
+      break;
+    case FACE_TYPE_TCP:
+      *connection = (hc_connection_t){
+          .type = FACE_TYPE_TCP,
+          .family = f->family,
+          .local_addr = f->local_addr,
+          .local_port = f->local_port,
+          .remote_addr = f->remote_addr,
+          .remote_port = f->remote_port,
+          .admin_state = f->admin_state,
+          .state = f->state,
 #ifdef WITH_POLICY
-                .priority = f->priority,
-                .tags = f->tags,
+          .priority = f->priority,
+          .tags = f->tags,
 #endif /* WITH_POLICY */
-            };
-            if (generate_name) {
-                rc = snprintf(connection->name, SYMBOLIC_NAME_LEN, "tcp%u", RANDBYTE());
-                if (rc >= SYMBOLIC_NAME_LEN)
-                    WARN("[hc_face_to_connection] Unexpected truncation of symbolic name string");
-            } else {
-                memset(connection->name, 0, SYMBOLIC_NAME_LEN);
-            }
-            break;
-        case FACE_TYPE_UDP:
-            *connection = (hc_connection_t) {
-                .type = CONNECTION_TYPE_UDP,
-                .family = AF_INET,
-                .local_addr = f->local_addr,
-                .local_port = f->local_port,
-                .remote_addr = f->remote_addr,
-                .remote_port = f->remote_port,
-                .admin_state = face_state_to_connection_state(f->admin_state),
-                .state = face_state_to_connection_state(f->state),
+      };
+      if (generate_name) {
+        rc = snprintf(connection->name, SYMBOLIC_NAME_LEN, "tcp%u", RANDBYTE());
+        if (rc >= SYMBOLIC_NAME_LEN)
+          WARN(
+              "[hc_face_to_connection] Unexpected truncation of "
+              "symbolic name string");
+      } else {
+        memset(connection->name, 0, SYMBOLIC_NAME_LEN);
+      }
+      break;
+    case FACE_TYPE_UDP:
+      *connection = (hc_connection_t){
+          .type = FACE_TYPE_UDP,
+          .family = f->family,
+          .local_addr = f->local_addr,
+          .local_port = f->local_port,
+          .remote_addr = f->remote_addr,
+          .remote_port = f->remote_port,
+          .admin_state = f->admin_state,
+          .state = f->state,
 #ifdef WITH_POLICY
-                .priority = f->priority,
-                .tags = f->tags,
+          .priority = f->priority,
+          .tags = f->tags,
 #endif /* WITH_POLICY */
-            };
-            if (generate_name) {
-                rc = snprintf(connection->name, SYMBOLIC_NAME_LEN, "udp%u", RANDBYTE());
-                if (rc >= SYMBOLIC_NAME_LEN)
-                    WARN("[hc_face_to_connection] Unexpected truncation of symbolic name string");
-            } else {
-                memset(connection->name, 0, SYMBOLIC_NAME_LEN);
-            }
-            snprintf(connection->interface_name, INTERFACE_LEN, "%s",
-                    f->netdevice.name);
-            break;
-        default:
-             return -1;
-    }
+      };
+      if (generate_name) {
+        rc = snprintf(connection->name, SYMBOLIC_NAME_LEN, "udp%u", RANDBYTE());
+        if (rc >= SYMBOLIC_NAME_LEN)
+          WARN(
+              "[hc_face_to_connection] Unexpected truncation of "
+              "symbolic name string");
+      } else {
+        memset(connection->name, 0, SYMBOLIC_NAME_LEN);
+      }
+      snprintf(connection->interface_name, INTERFACE_LEN, "%s",
+               f->netdevice.name);
+      break;
+    default:
+      return -1;
+  }
 
-    rc = snprintf(connection->interface_name, INTERFACE_LEN, "%s",
-            f->netdevice.name);
-    if (rc >= INTERFACE_LEN)
-        WARN("hc_face_to_connection] Unexpected truncation of interface name string");
+  connection->id = face->id;
+  rc = snprintf(connection->interface_name, INTERFACE_LEN, "%s",
+                f->netdevice.name);
+  if (rc >= INTERFACE_LEN)
+    WARN(
+        "hc_face_to_connection] Unexpected truncation of interface name "
+        "string");
 
-    return 0;
+  return 0;
 }
 
 /* CONNECTION -> FACE */
 
-int
-hc_connection_to_face(const hc_connection_t * connection, hc_face_t * face)
-{
-    int rc;
-    switch (connection->type) {
-        case CONNECTION_TYPE_TCP:
-            *face = (hc_face_t) {
-                .id = connection->id,
-                .face = {
-                    .type = FACE_TYPE_TCP,
-                    .family = connection->family,
-                    .local_addr = connection->local_addr,
-                    .local_port = connection->local_port,
-                    .remote_addr = connection->remote_addr,
-                    .remote_port = connection->remote_port,
-                    .admin_state = connection_state_to_face_state(connection->admin_state),
-                    .state = connection_state_to_face_state(connection->state),
+int hc_connection_to_face(const hc_connection_t *connection, hc_face_t *face) {
+  int rc;
+  switch (connection->type) {
+    case FACE_TYPE_TCP:
+      *face = (hc_face_t){
+          .id = connection->id,
+          .face =
+              {
+                  .type = FACE_TYPE_TCP,
+                  .family = connection->family,
+                  .local_addr = connection->local_addr,
+                  .local_port = connection->local_port,
+                  .remote_addr = connection->remote_addr,
+                  .remote_port = connection->remote_port,
+                  .admin_state = connection->admin_state,
+                  .state = connection->state,
 #ifdef WITH_POLICY
-                    .priority = connection->priority,
-                    .tags = connection->tags,
+                  .priority = connection->priority,
+                  .tags = connection->tags,
 #endif /* WITH_POLICY */
-                },
-            };
-            break;
-        case CONNECTION_TYPE_UDP:
-            *face = (hc_face_t) {
-                .id = connection->id,
-                .face = {
-                    .type = FACE_TYPE_UDP,
-                    .family = connection->family,
-                    .local_addr = connection->local_addr,
-                    .local_port = connection->local_port,
-                    .remote_addr = connection->remote_addr,
-                    .remote_port = connection->remote_port,
-                    .admin_state = connection_state_to_face_state(connection->admin_state),
-                    .state = connection_state_to_face_state(connection->state),
+              },
+      };
+      break;
+    case FACE_TYPE_UDP:
+      *face = (hc_face_t){
+          .id = connection->id,
+          .face =
+              {
+                  .type = FACE_TYPE_UDP,
+                  .family = connection->family,
+                  .local_addr = connection->local_addr,
+                  .local_port = connection->local_port,
+                  .remote_addr = connection->remote_addr,
+                  .remote_port = connection->remote_port,
+                  .admin_state = connection->admin_state,
+                  .state = connection->state,
 #ifdef WITH_POLICY
-                    .priority = connection->priority,
-                    .tags = connection->tags,
+                  .priority = connection->priority,
+                  .tags = connection->tags,
 #endif /* WITH_POLICY */
-                },
-            };
-            break;
-        case CONNECTION_TYPE_HICN:
-            *face = (hc_face_t) {
-                .id = connection->id,
-                .face = {
-                    .type = FACE_TYPE_HICN,
-                    .family = connection->family,
-                    .netdevice.index = NETDEVICE_UNDEFINED_INDEX, // XXX
-                    .local_addr = connection->local_addr,
-                    .remote_addr = connection->remote_addr,
-                    .admin_state = connection_state_to_face_state(connection->admin_state),
-                    .state = connection_state_to_face_state(connection->state),
+              },
+      };
+      break;
+    case FACE_TYPE_HICN:
+      *face = (hc_face_t){
+          .id = connection->id,
+          .face =
+              {
+                  .type = FACE_TYPE_HICN,
+                  .family = connection->family,
+                  .netdevice.index = NETDEVICE_UNDEFINED_INDEX,  // XXX
+                  .local_addr = connection->local_addr,
+                  .remote_addr = connection->remote_addr,
+                  .admin_state = connection->admin_state,
+                  .state = connection->state,
 #ifdef WITH_POLICY
-                    .priority = connection->priority,
-                    .tags = connection->tags,
+                  .priority = connection->priority,
+                  .tags = connection->tags,
 #endif /* WITH_POLICY */
-                },
-            };
-            break;
-        default:
-            return -1;
-    }
-    face->face.netdevice.name[0] = '\0';
-    face->face.netdevice.index = 0;
-    rc = snprintf(face->name, SYMBOLIC_NAME_LEN, "%s", connection->name);
-    if (rc >= SYMBOLIC_NAME_LEN)
-        WARN("[hc_connection_to_face] Unexpected truncation of symbolic name string");
-    rc = snprintf(face->face.netdevice.name, INTERFACE_LEN, "%s", connection->interface_name);
-    if (rc >= INTERFACE_LEN)
-        WARN("[hc_connection_to_face] Unexpected truncation of interface name string");
-    netdevice_update_index(&face->face.netdevice);
-    return 0;
+              },
+      };
+      break;
+    default:
+      return -1;
+  }
+  face->face.netdevice.name[0] = '\0';
+  face->face.netdevice.index = 0;
+  rc = snprintf(face->name, SYMBOLIC_NAME_LEN, "%s", connection->name);
+  if (rc >= SYMBOLIC_NAME_LEN)
+    WARN(
+        "[hc_connection_to_face] Unexpected truncation of symbolic name "
+        "string");
+  rc = snprintf(face->face.netdevice.name, INTERFACE_LEN, "%s",
+                connection->interface_name);
+  if (rc >= INTERFACE_LEN)
+    WARN(
+        "[hc_connection_to_face] Unexpected truncation of interface name "
+        "string");
+  netdevice_update_index(&face->face.netdevice);
+  return 0;
 }
 
 /* CONNECTION -> LISTENER */
 
-int
-hc_connection_to_local_listener(const hc_connection_t * connection, hc_listener_t * listener)
-{
-    int rc;
-    *listener = (hc_listener_t) {
-        .id = ~0,
-        .type = connection->type,
-        .family = connection->family,
-        .local_addr = connection->local_addr,
-        .local_port = connection->local_port,
-    };
-    rc = snprintf(listener->name, SYMBOLIC_NAME_LEN, "lst%u", RANDBYTE()); // generate name
-    if (rc >= SYMBOLIC_NAME_LEN)
-        WARN("[hc_connection_to_local_listener] Unexpected truncation of symbolic name string");
-    rc = snprintf(listener->interface_name, INTERFACE_LEN, "%s", connection->interface_name);
-    if (rc >= INTERFACE_LEN)
-        WARN("[hc_connection_to_local_listener] Unexpected truncation of interface name string");
+int hc_connection_to_local_listener(const hc_connection_t *connection,
+                                    hc_listener_t *listener) {
+  int rc;
+
+  face_type_t listener_type;
+  switch (connection->type) {
+    case FACE_TYPE_UDP:
+      listener_type = FACE_TYPE_UDP_LISTENER;
+      break;
+    case FACE_TYPE_TCP:
+      listener_type = FACE_TYPE_TCP_LISTENER;
+      break;
+    default:
+      return -1;
+  }
 
-    return 0;
+  *listener = (hc_listener_t){
+      .id = ~0,
+      .type = listener_type,
+      .family = connection->family,
+      .local_addr = connection->local_addr,
+      .local_port = connection->local_port,
+  };
+  rc = snprintf(listener->name, SYMBOLIC_NAME_LEN, "lst%u",
+                RANDBYTE());  // generate name
+  if (rc >= SYMBOLIC_NAME_LEN)
+    WARN(
+        "[hc_connection_to_local_listener] Unexpected truncation of "
+        "symbolic name string");
+  rc = snprintf(listener->interface_name, INTERFACE_LEN, "%s",
+                connection->interface_name);
+  if (rc >= INTERFACE_LEN)
+    WARN(
+        "[hc_connection_to_local_listener] Unexpected truncation of "
+        "interface name string");
+
+  return 0;
+}
+
+/*----------------------------------------------------------------------------*
+ * Punting
+ *----------------------------------------------------------------------------*/
+
+int hc_punting_create(hc_sock_t *s, hc_punting_t *punting) {
+  return s->hc_punting_create(s, punting);
 }
 
-int hc_punting_create(hc_sock_t *s, hc_punting_t *punting)
-{
-    return s->hc_punting_create(s, punting);
+int hc_punting_get(hc_sock_t *s, hc_punting_t *punting,
+                   hc_punting_t **punting_found) {
+  return s->hc_punting_get(s, punting, punting_found);
 }
 
-int hc_punting_get(hc_sock_t *s, hc_punting_t *punting,
-                   hc_punting_t **punting_found)
-{
-    return s->hc_punting_get(s, punting, punting_found);
+int hc_punting_delete(hc_sock_t *s, hc_punting_t *punting) {
+  return s->hc_punting_delete(s, punting);
 }
 
-int hc_punting_delete(hc_sock_t *s, hc_punting_t *punting)
-{
-    return s->hc_punting_delete(s, punting);
+int hc_punting_list(hc_sock_t *s, hc_data_t **pdata) {
+  return s->hc_punting_list(s, pdata);
 }
 
-int hc_punting_list(hc_sock_t *s, hc_data_t **pdata)
-{
-    return s->hc_punting_list(s, pdata);
+int hc_punting_validate(const hc_punting_t *punting) {
+  if (!IS_VALID_FAMILY(punting->family)) return -1;
+
+  /*
+   * We might use the zero value to add punting on all faces but this is not
+   * (yet) implemented
+   */
+  if (punting->face_id == 0) {
+    ERROR("Punting on all faces is not (yet) implemented.");
+    return -1;
+  }
+
+  return 0;
 }
 
-int hc_punting_validate(const hc_punting_t * punting)
-{
-    if (!IS_VALID_FAMILY(punting->family))
-         return -1;
-
-    /*
-     * We might use the zero value to add punting on all faces but this is not
-     * (yet) implemented
-     */
-    if (punting->face_id == 0) {
-        ERROR("Punting on all faces is not (yet) implemented.");
-        return -1;
-    }
+int hc_punting_cmp(const hc_punting_t *p1, const hc_punting_t *p2) {
+  int rc;
 
-    return 0;
+  rc = INT_CMP(p1->face_id, p2->face_id);
+  if (rc != 0) return rc;
+
+  rc = INT_CMP(p1->family, p2->family);
+  if (rc != 0) return rc;
+
+  rc = ip_address_cmp(&p1->prefix, &p2->prefix, p1->family);
+  if (rc != 0) return rc;
+
+  rc = INT_CMP(p1->prefix_len, p2->prefix_len);
+  if (rc != 0) return rc;
+
+  return rc;
 }
 
-int hc_punting_cmp(const hc_punting_t * p1, const hc_punting_t * p2)
-{
-    int rc;
+int hc_punting_parse(void *in, hc_punting_t *punting) {
+  ERROR("hc_punting_parse not (yet) implemented.");
+  return -1;
+}
 
-    rc = INT_CMP(p1->face_id, p2->face_id);
-    if (rc != 0)
-        return rc;
+int hc_punting_snprintf(char *s, size_t size, hc_punting_t *punting) {
+  ERROR("hc_punting_snprintf not (yet) implemented.");
+  return -1;
+}
 
-    rc = INT_CMP(p1->family, p2->family);
-    if (rc != 0)
-        return rc;
+/*----------------------------------------------------------------------------*
+ * Cache
+ *----------------------------------------------------------------------------*/
 
-    rc = ip_address_cmp(&p1->prefix, &p2->prefix, p1->family);
-    if (rc != 0)
-        return rc;
+int hc_cache_set_store(hc_sock_t *s, hc_cache_t *cache) {
+  return s->hc_cache_set_store(s, cache);
+}
 
-    rc = INT_CMP(p1->prefix_len, p2->prefix_len);
-    if (rc != 0)
-        return rc;
+int hc_cache_set_serve(hc_sock_t *s, hc_cache_t *cache) {
+  return s->hc_cache_set_serve(s, cache);
+}
 
-    return rc;
+int hc_cache_clear(hc_sock_t *s, hc_cache_t *cache) {
+  return s->hc_cache_clear(s, cache);
 }
 
-int hc_punting_parse(void * in, hc_punting_t * punting)
-{
-    ERROR("hc_punting_parse not (yet) implemented.");
-    return -1;
+int hc_cache_list(hc_sock_t *s, hc_data_t **pdata) {
+  return s->hc_cache_list(s, pdata);
 }
 
-int hc_punting_snprintf(char * s, size_t size, hc_punting_t * punting)
-{
-    ERROR("hc_punting_snprintf not (yet) implemented.");
-    return -1;
+int hc_cache_snprintf(char *s, size_t size, const hc_cache_info_t *cache_info) {
+  return snprintf(
+      s, size, "Cache set_store=%s set_serve=%s size=%lu stale_entries=%lu",
+      cache_info->store ? "true" : "false",
+      cache_info->serve ? "true" : "false", (unsigned long)cache_info->cs_size,
+      (unsigned long)cache_info->num_stale_entries);
 }
 
-int hc_cache_set_store(hc_sock_t *s, int enabled)
-{
-    return s->hc_cache_set_store(s, enabled);
+/*----------------------------------------------------------------------------*
+ * Strategy
+ *----------------------------------------------------------------------------*/
+
+int hc_strategy_list(hc_sock_t *s, hc_data_t **data) {
+  return s->hc_strategy_list(s, data);
 }
 
-int hc_cache_set_serve(hc_sock_t *s, int enabled)
-{
-    return s->hc_cache_set_serve(s, enabled);
+int hc_strategy_set(hc_sock_t *s, hc_strategy_t *strategy) {
+  return s->hc_strategy_set(s, strategy);
 }
 
-int hc_strategy_list(hc_sock_t *s, hc_data_t **data)
-{
-    return s->hc_strategy_list(s, data);
+int hc_strategy_add_local_prefix(hc_sock_t *s, hc_strategy_t *strategy) {
+  return s->hc_strategy_add_local_prefix(s, strategy);
 }
 
-int hc_strategy_set(hc_sock_t *s /* XXX */)
-{
-    return s->hc_strategy_set(s);
+hc_result_t *hc_strategy_set_conf(hc_sock_t *s, hc_strategy_t *strategy) {
+  return s->hc_strategy_set_conf(s, strategy);
+}
+
+hc_result_t *hc_strategy_add_local_prefix_conf(hc_sock_t *s,
+                                               hc_strategy_t *strategy) {
+  return s->hc_strategy_add_local_prefix_conf(s, strategy);
 }
 
 /* /!\ Please update constants in header file upon changes */
-int
-hc_strategy_snprintf(char * s, size_t size, hc_strategy_t * strategy)
-{
-    return snprintf(s, size, "%s", strategy->name);
+int hc_strategy_snprintf(char *s, size_t size, hc_strategy_t *strategy) {
+  return snprintf(s, size, "%s", strategy->name);
 }
 
-int hc_wldr_set(hc_sock_t *s /* XXX */)
-{
-    return s->hc_wldr_set(s);
+/*----------------------------------------------------------------------------*
+ * WLDR
+ *----------------------------------------------------------------------------*/
+
+int hc_wldr_set(hc_sock_t *s /* XXX */) { return s->hc_wldr_set(s); }
+
+/*----------------------------------------------------------------------------*
+ * MAP-Me
+ *----------------------------------------------------------------------------*/
+
+int hc_mapme_set(hc_sock_t *s, hc_mapme_t *mapme) {
+  return s->hc_mapme_set(s, mapme->enabled);
 }
 
-int hc_mapme_set(hc_sock_t *s, int enabled)
-{
-    return s->hc_mapme_set(s, enabled);
+int hc_mapme_set_discovery(hc_sock_t *s, hc_mapme_t *mapme) {
+  return s->hc_mapme_set_discovery(s, mapme->enabled);
 }
 
-int hc_mapme_set_discovery(hc_sock_t *s, int enabled)
-{
-    return s->hc_mapme_set_discovery(s, enabled);
+int hc_mapme_set_timescale(hc_sock_t *s, hc_mapme_t *mapme) {
+  return s->hc_mapme_set_timescale(s, mapme->timescale);
 }
 
-int hc_mapme_set_timescale(hc_sock_t *s, double timescale)
-{
-    return s->hc_mapme_set_timescale(s, timescale);
+int hc_mapme_set_retx(hc_sock_t *s, hc_mapme_t *mapme) {
+  return s->hc_mapme_set_retx(s, mapme->timescale);
 }
 
-int hc_mapme_set_retx(hc_sock_t *s, double timescale)
-{
-    return s->hc_mapme_set_retx(s, timescale);
+int hc_mapme_send_update(hc_sock_t *s, hc_mapme_t *mapme) {
+  return s->hc_mapme_send_update(s, mapme);
 }
 
+/*----------------------------------------------------------------------------*
+ * Policy
+ *----------------------------------------------------------------------------*/
+
 #ifdef WITH_POLICY
 
-/* POLICY PARSE */
+/* POLICY SNPRINTF */
 
-int
-hc_policy_parse(void * in, hc_policy_t * policy)
-{
-    list_policies_command * cmd = (list_policies_command *) in;
+/* /!\ Please update constants in header file upon changes */
+int hc_policy_snprintf(char *s, size_t size, hc_policy_t *policy) { return 0; }
 
-    if (!IS_VALID_ADDR_TYPE(cmd->addressType))
-         return -1;
+int hc_policy_validate(const hc_policy_t *policy) {
+  if (!IS_VALID_FAMILY(policy->family)) return -1;
 
-    int family = map_from_addr_type[cmd->addressType];
-    if (!IS_VALID_FAMILY(family))
-         return -1;
+  return 0;
+}
 
-    *policy = (hc_policy_t) {
-        .family = family,
-        .remote_addr = UNION_CAST(cmd->address, ip_address_t),
-        .len = cmd->len,
-        .policy = cmd->policy,
-    };
-    return 0;
+#endif /* WITH_POLICY */
+
+/*----------------------------------------------------------------------------*
+ * SUBSCRIPTION
+ *----------------------------------------------------------------------------*/
+int hc_subscription_create(hc_sock_t *s, hc_subscription_t *subscription) {
+  return s->hc_subscription_create(s, subscription);
 }
 
-/* POLICY SNPRINTF */
+int hc_subscription_delete(hc_sock_t *s, hc_subscription_t *subscription) {
+  return s->hc_subscription_delete(s, subscription);
+}
 
-/* /!\ Please update constants in header file upon changes */
-int
-hc_policy_snprintf(char * s, size_t size, hc_policy_t * policy)
-{
-     return 0;
+hc_result_t *hc_subscription_create_conf(hc_sock_t *s,
+                                         hc_subscription_t *subscription) {
+  return s->hc_subscription_create_conf(s, subscription);
+}
+
+hc_result_t *hc_subscription_delete_conf(hc_sock_t *s,
+                                         hc_subscription_t *subscription) {
+  return s->hc_subscription_delete_conf(s, subscription);
+}
+
+/*----------------------------------------------------------------------------*
+ * Result
+ *----------------------------------------------------------------------------*/
+
+hc_msg_t *hc_result_get_msg(hc_sock_t *s, hc_result_t *result) {
+  return s->hc_result_get_msg(result);
+}
+
+int hc_result_get_cmd_id(hc_sock_t *s, hc_result_t *result) {
+  return s->hc_result_get_cmd_id(result);
+}
+
+bool hc_result_get_success(hc_sock_t *s, hc_result_t *result) {
+  return s->hc_result_get_success(result);
 }
 
-#endif /* WITH_POLICY */
\ No newline at end of file
+void hc_result_free(hc_result_t *result) { free(result); }
diff --git a/ctrl/libhicnctrl/src/api_private.h b/ctrl/libhicnctrl/src/api_private.h
index 3922e1f3c..11cb2e00e 100644
--- a/ctrl/libhicnctrl/src/api_private.h
+++ b/ctrl/libhicnctrl/src/api_private.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -17,10 +17,12 @@
 #define HICN_API_PRIVATE_H
 
 #include <hicn/ctrl/api.h>
-#include <hicn/ctrl/commands.h>
 #include <hicn/util/token.h>
 #include <hicn/util/log.h>
 #include <hicn/util/map.h>
+#include <hicn/util/sstrncpy.h>
+#include <hicn/validation.h>
+#include <ctype.h>
 
 #define INT_CMP(x, y) ((x > y) ? 1 : (x < y) ? -1 : 0)
 #define ARRAY_SIZE(array) (sizeof(array) / sizeof(*array))
@@ -34,57 +36,64 @@
 #endif
 #define RANDBYTE() (u8)(rand() & 0xFF)
 
-hc_connection_type_t
-connection_type_from_str(const char * str);
-
-extern const hc_connection_type_t map_from_list_connections_type[];
-extern const hc_connection_type_t map_from_encap_type[];
-extern const connection_type map_to_connection_type[];
-extern const listener_mode map_to_listener_mode[];
-extern const hc_connection_state_t map_from_list_connections_state[];
-extern const int map_from_addr_type[];
-extern const address_type map_to_addr_type[];
-extern const char * connection_state_str[];
-extern const char * connection_type_str[];
-
-typedef enum {
-    ENCAP_TCP,
-    ENCAP_UDP,
-    ENCAP_ETHER,
-    ENCAP_LOCAL,
-    ENCAP_HICN
-} EncapType;
-
-#define connection_state_to_face_state(x) ((face_state_t)(x))
-#define face_state_to_connection_state(x) ((hc_connection_state_t)(x))
+/*
+ * Input validation
+ */
+
+static inline bool IS_VALID_ADDRESS(const ip_address_t *addr, int family) {
+  char addr_str[INET6_ADDRSTRLEN];
+  return !ip_address_empty(addr) &&
+         ip_address_ntop(addr, addr_str, INET6_ADDRSTRLEN, family) >= 0;
+}
+
+static inline bool IS_VALID_PREFIX_LEN(u8 len) {
+  return len <= MAX_IPV6_PREFIX_LEN;
+}
+
+// https://github.com/shemminger/iproute2/blob/50b668bdbf0ebc270495eb4b352d0c3982159d0a/lib/utils.c#L825
+static inline bool IS_VALID_INTERFACE_NAME(const char *name) {
+  size_t len = strnlen_s(name, INTERFACE_LEN);
+  if (len == 0 || len >= IFNAMSIZ) return true;
+
+  while (*name) {
+    if (*name == '/' || isspace(*name)) return false;
+    ++name;
+  }
 
+  return true;
+}
+
+static inline bool IS_VALID_NAME(const char *name) {
+  return is_symbolic_name(name, SYMBOLIC_NAME_LEN);
+}
+
+static inline bool IS_VALID_STR_ID(const char *name) {
+  return is_number(name, SYMBOLIC_NAME_LEN);
+}
+
+#define IS_VALID_TYPE(x) IS_VALID_ENUM_TYPE(FACE_TYPE, x)
 #define IS_VALID_ADDR_TYPE(x) ((x >= ADDR_INET) && (x <= ADDR_UNIX))
 
-#define IS_VALID_CONNECTION_TYPE(x) IS_VALID_ENUM_TYPE(CONNECTION_TYPE, x)
+#define IS_VALID_ID(x) (1)
+#define IS_VALID_POLICY(x) (1)
 
 typedef struct hc_sock_impl_s hc_sock_impl_t;
 
-int hc_data_ensure_available(hc_data_t * data, size_t count);
-u8 *hc_data_get_next(hc_data_t * data);
-int hc_data_set_error(hc_data_t * data);
+int hc_data_ensure_available(hc_data_t *data, size_t count);
+u8 *hc_data_get_next(hc_data_t *data);
+int hc_data_set_error(hc_data_t *data);
 
-int
-hc_connection_parse_to_face(void * in, hc_face_t * face);
+int hc_listener_to_face(const hc_listener_t *listener, hc_face_t *face);
 
-int
-hc_listener_to_face(const hc_listener_t * listener, hc_face_t * face);
+int hc_connection_to_face(const hc_connection_t *connection, hc_face_t *face);
 
-int
-hc_connection_to_face(const hc_connection_t * connection, hc_face_t * face);
+int hc_face_to_listener(const hc_face_t *face, hc_listener_t *listener);
 
-int
-hc_face_to_listener(const hc_face_t * face, hc_listener_t * listener);
+int hc_connection_to_local_listener(const hc_connection_t *connection,
+                                    hc_listener_t *listener);
 
-int
-hc_connection_to_local_listener(const hc_connection_t * connection, hc_listener_t * listener);
-
-int
-hc_face_to_connection(const hc_face_t * face, hc_connection_t * connection, bool generate_name);
+int hc_face_to_connection(const hc_face_t *face, hc_connection_t *connection,
+                          bool generate_name);
 
 struct hc_sock_s {
   int (*hc_sock_get_next_seq)(hc_sock_t *s);
@@ -92,17 +101,21 @@ struct hc_sock_s {
   int (*hc_sock_get_fd)(hc_sock_t *s);
   int (*hc_sock_connect)(hc_sock_t *s);
   int (*hc_sock_get_available)(hc_sock_t *s, u8 **buffer, size_t *size);
-  int (*hc_sock_send)(hc_sock_t *s, hc_msg_t *msg, size_t msglen, int seq);
+  int (*hc_sock_send)(hc_sock_t *s, hc_msg_t *msg, size_t msglen, uint32_t seq);
   int (*hc_sock_recv)(hc_sock_t *s);
   int (*hc_sock_process)(hc_sock_t *s, hc_data_t **data);
   int (*hc_sock_callback)(hc_sock_t *s, hc_data_t **data);
   int (*hc_sock_reset)(hc_sock_t *s);
   void (*hc_sock_free)(hc_sock_t *s);
-
+  void (*hc_sock_increment_woff)(hc_sock_t *s, size_t bytes);
+  int (*hc_sock_prepare_send)(hc_sock_t *s, hc_result_t *result,
+                              data_callback_t complete_cb,
+                              void *complete_cb_data);
+  int (*hc_sock_set_recv_timeout_ms)(hc_sock_t *s, long timeout_ms);
   int (*hc_listener_create)(hc_sock_t *s, hc_listener_t *listener);
   int (*hc_listener_create_async)(hc_sock_t *s, hc_listener_t *listener);
   int (*hc_listener_get)(hc_sock_t *s, hc_listener_t *listener,
-                    hc_listener_t **listener_found);
+                         hc_listener_t **listener_found);
   int (*hc_listener_delete)(hc_sock_t *s, hc_listener_t *listener);
   int (*hc_listener_delete_async)(hc_sock_t *s, hc_listener_t *listener);
   int (*hc_listener_list)(hc_sock_t *s, hc_data_t **pdata);
@@ -114,81 +127,105 @@ struct hc_sock_s {
   int (*hc_connection_create)(hc_sock_t *s, hc_connection_t *connection);
   int (*hc_connection_create_async)(hc_sock_t *s, hc_connection_t *connection);
   int (*hc_connection_get)(hc_sock_t *s, hc_connection_t *connection,
-                      hc_connection_t **connection_found);
+                           hc_connection_t **connection_found);
   int (*hc_connection_update_by_id)(hc_sock_t *s, int hc_connection_id,
-                               hc_connection_t *connection);
+                                    hc_connection_t *connection);
   int (*hc_connection_update)(hc_sock_t *s, hc_connection_t *connection_current,
-                         hc_connection_t *connection_updated);
+                              hc_connection_t *connection_updated);
   int (*hc_connection_delete)(hc_sock_t *s, hc_connection_t *connection);
   int (*hc_connection_delete_async)(hc_sock_t *s, hc_connection_t *connection);
   int (*hc_connection_list)(hc_sock_t *s, hc_data_t **pdata);
   int (*hc_connection_list_async)(hc_sock_t *s, hc_data_t **pdata);
   int (*hc_connection_validate)(const hc_connection_t *connection);
-  int (*hc_connection_cmp)(const hc_connection_t *c1, const hc_connection_t *c2);
+  int (*hc_connection_cmp)(const hc_connection_t *c1,
+                           const hc_connection_t *c2);
   int (*hc_connection_parse)(void *in, hc_connection_t *connection);
-  int (*hc_connection_set_admin_state)(hc_sock_t * s, const char * conn_id_or_name, face_state_t state);
-  int (*hc_connection_set_admin_state_async)(hc_sock_t * s, const char * conn_id_or_name, face_state_t state);
+  int (*hc_connection_set_admin_state)(hc_sock_t *s,
+                                       const char *conn_id_or_name,
+                                       face_state_t state);
+  int (*hc_connection_set_admin_state_async)(hc_sock_t *s,
+                                             const char *conn_id_or_name,
+                                             face_state_t state);
 
 #ifdef WITH_POLICY
-  int (*hc_connection_set_priority)(hc_sock_t * s, const char * conn_id_or_name, uint32_t priority);
-  int (*hc_connection_set_priority_async)(hc_sock_t * s, const char * conn_id_or_name, uint32_t priority);
-  int (*hc_connection_set_tags)(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t tags);
-  int (*hc_connection_set_tags_async)(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t tags);
-#endif // WITH_POLICY
+  int (*hc_connection_set_priority)(hc_sock_t *s, const char *conn_id_or_name,
+                                    uint32_t priority);
+  int (*hc_connection_set_priority_async)(hc_sock_t *s,
+                                          const char *conn_id_or_name,
+                                          uint32_t priority);
+  int (*hc_connection_set_tags)(hc_sock_t *s, const char *conn_id_or_name,
+                                policy_tags_t tags);
+  int (*hc_connection_set_tags_async)(hc_sock_t *s, const char *conn_id_or_name,
+                                      policy_tags_t tags);
+#endif  // WITH_POLICY
 
   int (*hc_connection_snprintf)(char *s, size_t size,
-                             const hc_connection_t *connection);
+                                const hc_connection_t *connection);
 
   int (*hc_face_create)(hc_sock_t *s, hc_face_t *face);
   int (*hc_face_get)(hc_sock_t *s, hc_face_t *face, hc_face_t **face_found);
-  int (*hc_face_delete)(hc_sock_t *s, hc_face_t *face);
+  int (*hc_face_delete)(hc_sock_t *s, hc_face_t *face, uint8_t delete_listener);
   int (*hc_face_list)(hc_sock_t *s, hc_data_t **pdata);
   int (*hc_face_list_async)(hc_sock_t *s);
-  int (*hc_face_set_admin_state)(hc_sock_t * s, const char * conn_id_or_name, face_state_t state);
-  int (*hc_face_set_admin_state_async)(hc_sock_t * s, const char * conn_id_or_name, face_state_t state);
+  int (*hc_face_set_admin_state)(hc_sock_t *s, const char *conn_id_or_name,
+                                 face_state_t state);
+  int (*hc_face_set_admin_state_async)(hc_sock_t *s,
+                                       const char *conn_id_or_name,
+                                       face_state_t state);
 
 #ifdef WITH_POLICY
-  int (*hc_face_set_priority)(hc_sock_t * s, const char * conn_id_or_name, uint32_t priority);
-  int (*hc_face_set_priority_async)(hc_sock_t * s, const char * conn_id_or_name, uint32_t priority);
-  int (*hc_face_set_tags)(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t tags);
-  int (*hc_face_set_tags_async)(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t tags);
-#endif // WITH_POLICY
+  int (*hc_face_set_priority)(hc_sock_t *s, const char *conn_id_or_name,
+                              uint32_t priority);
+  int (*hc_face_set_priority_async)(hc_sock_t *s, const char *conn_id_or_name,
+                                    uint32_t priority);
+  int (*hc_face_set_tags)(hc_sock_t *s, const char *conn_id_or_name,
+                          policy_tags_t tags);
+  int (*hc_face_set_tags_async)(hc_sock_t *s, const char *conn_id_or_name,
+                                policy_tags_t tags);
+#endif  // WITH_POLICY
 
   int (*hc_face_snprintf)(char *s, size_t size, hc_face_t *face);
 
   int (*hc_route_parse)(void *in, hc_route_t *route);
-  int (*hc_route_create)(hc_sock_t * s, hc_route_t * route);
-  int (*hc_route_create_async)(hc_sock_t * s, hc_route_t * route);
-  int (*hc_route_delete)(hc_sock_t * s, hc_route_t * route);
-  int (*hc_route_delete_async)(hc_sock_t * s, hc_route_t * route);
-  int (*hc_route_list)(hc_sock_t * s, hc_data_t ** pdata);
-  int (*hc_route_list_async)(hc_sock_t * s);
+  int (*hc_route_create)(hc_sock_t *s, hc_route_t *route);
+  int (*hc_route_create_async)(hc_sock_t *s, hc_route_t *route);
+  int (*hc_route_delete)(hc_sock_t *s, hc_route_t *route);
+  int (*hc_route_delete_async)(hc_sock_t *s, hc_route_t *route);
+  int (*hc_route_list)(hc_sock_t *s, hc_data_t **pdata);
+  int (*hc_route_list_async)(hc_sock_t *s);
 
   int (*hc_punting_create)(hc_sock_t *s, hc_punting_t *punting);
   int (*hc_punting_create_async)(hc_sock_t *s, hc_punting_t *punting);
   int (*hc_punting_get)(hc_sock_t *s, hc_punting_t *punting,
-                   hc_punting_t **punting_found);
+                        hc_punting_t **punting_found);
   int (*hc_punting_delete)(hc_sock_t *s, hc_punting_t *punting);
   int (*hc_punting_list)(hc_sock_t *s, hc_data_t **pdata);
   int (*hc_punting_validate)(const hc_punting_t *punting);
   int (*hc_punting_cmp)(const hc_punting_t *c1, const hc_punting_t *c2);
   int (*hc_punting_parse)(void *in, hc_punting_t *punting);
 
-  int (*hc_cache_set_store)(hc_sock_t *s, int enabled);
-  int (*hc_cache_set_serve)(hc_sock_t *s, int enabled);
-  int (*hc_cache_set_store_async)(hc_sock_t *s, int enabled);
-  int (*hc_cache_set_serve_async)(hc_sock_t *s, int enabled);
+  int (*hc_cache_parse)(void *in, hc_cache_info_t *cache_info);
+  int (*hc_cache_set_store)(hc_sock_t *s, hc_cache_t *cache);
+  int (*hc_cache_set_serve)(hc_sock_t *s, hc_cache_t *cache);
+  int (*hc_cache_clear)(hc_sock_t *s, hc_cache_t *cache);
+  int (*hc_cache_list)(hc_sock_t *s, hc_data_t **pdata);
+  int (*hc_cache_set_store_async)(hc_sock_t *s, hc_cache_t *cache);
+  int (*hc_cache_set_serve_async)(hc_sock_t *s, hc_cache_t *cache);
+  int (*hc_cache_snprintf)(char *s, size_t size,
+                           const hc_cache_info_t *cache_info);
 
   int (*hc_strategy_list)(hc_sock_t *s, hc_data_t **data);
   int (*hc_strategy_snprintf)(char *s, size_t size, hc_strategy_t *strategy);
-  int (*hc_strategy_set)(hc_sock_t *s /* XXX */);
+  int (*hc_strategy_set)(hc_sock_t *s, hc_strategy_t *strategy);
+  int (*hc_strategy_add_local_prefix)(hc_sock_t *s, hc_strategy_t *strategy);
 
   int (*hc_wldr_set)(hc_sock_t *s /* XXX */);
 
   int (*hc_mapme_set)(hc_sock_t *s, int enabled);
   int (*hc_mapme_set_discovery)(hc_sock_t *s, int enabled);
-  int (*hc_mapme_set_timescale)(hc_sock_t *s, double timescale);
-  int (*hc_mapme_set_retx)(hc_sock_t *s, double timescale);
+  int (*hc_mapme_set_timescale)(hc_sock_t *s, uint32_t timescale);
+  int (*hc_mapme_set_retx)(hc_sock_t *s, uint32_t timescale);
+  int (*hc_mapme_send_update)(hc_sock_t *s, hc_mapme_t *mapme);
 
 #ifdef WITH_POLICY
   int (*hc_policy_parse)(void *in, hc_policy_t *policy);
@@ -199,10 +236,34 @@ struct hc_sock_s {
   int (*hc_policy_list)(hc_sock_t *s, hc_data_t **pdata);
   int (*hc_policy_list_async)(hc_sock_t *s, hc_data_t **pdata);
   int (*hc_policy_snprintf)(char *s, size_t size, hc_policy_t *policy);
-#endif // WITH_POLICY
+#endif  // WITH_POLICY
+
+  int (*hc_subscription_create)(hc_sock_t *s, hc_subscription_t *subscription);
+  int (*hc_subscription_delete)(hc_sock_t *s, hc_subscription_t *subscription);
+
+  hc_result_t *(*hc_listener_create_conf)(hc_sock_t *s,
+                                          hc_listener_t *listener);
+  hc_result_t *(*hc_listener_list_conf)(hc_sock_t *s, hc_data_t **pdata);
+  hc_result_t *(*hc_connection_create_conf)(hc_sock_t *s,
+                                            hc_connection_t *connection);
+  hc_result_t *(*hc_connection_delete_conf)(hc_sock_t *s,
+                                            hc_connection_t *connection);
+  hc_result_t *(*hc_route_create_conf)(hc_sock_t *s, hc_route_t *route);
+  hc_result_t *(*hc_strategy_set_conf)(hc_sock_t *s, hc_strategy_t *strategy);
+  hc_result_t *(*hc_strategy_add_local_prefix_conf)(hc_sock_t *s,
+                                                    hc_strategy_t *strategy);
+  hc_result_t *(*hc_subscription_create_conf)(hc_sock_t *s,
+                                              hc_subscription_t *subscription);
+  hc_result_t *(*hc_subscription_delete_conf)(hc_sock_t *s,
+                                              hc_subscription_t *subscription);
+
+  hc_msg_t *(*hc_result_get_msg)(hc_result_t *result);
+  bool (*hc_result_get_success)(hc_result_t *result);
+  int (*hc_result_get_cmd_id)(hc_result_t *result);
+  void (*hc_result_free)(hc_result_t *result);
 
   // Reference to module containing the implementation
   void *handle;
 };
 
-#endif // HICN_API_PRIVATE_H
\ No newline at end of file
+#endif  // HICN_API_PRIVATE_H
diff --git a/ctrl/libhicnctrl/src/cli.c b/ctrl/libhicnctrl/src/cli.c
deleted file mode 100644
index 064eb77e3..000000000
--- a/ctrl/libhicnctrl/src/cli.c
+++ /dev/null
@@ -1,883 +0,0 @@
-/*
- * 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 cli.c
- * \brief Command line interface
- */
-#include <ctype.h> // isalpha isalnum
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h> // getopt
-
-#include <hicn/ctrl.h>
-#include <hicn/util/ip_address.h>
-#include <hicn/util/token.h>
-
-
-#define die(LABEL, MESSAGE) do {    \
-        printf(MESSAGE "\n");       \
-        rc = -1;                    \
-        goto ERR_ ## LABEL;         \
-} while(0)
-
-#define foreach_object  \
-    _(UNDEFINED)        \
-    _(FACE)             \
-    _(ROUTE)            \
-    _(STRATEGY)         \
-    _(LISTENER)         \
-    _(CONNECTION)       \
-    _(N)
-
-typedef enum {
-#define _(x) OBJECT_ ## x,
-foreach_object
-#undef _
-} hc_object_t;
-
-#define HICNLIGHT_PARAM "hicnlight"
-#define VPP_PARAM "vpp"
-
-void
-usage_header()
-{
-    fprintf(stderr, "Usage:\n");
-}
-
-void
-usage_face_create(const char * prog, bool header, bool verbose)
-{
-
-    if (header)
-        usage_header();
-    fprintf(stderr, "%s -f TYPE LOCAL_ADDRESS LOCAL_PORT REMOTE_ADDRESS REMOTE_PORT [INTERFACE_NAME]\n", prog);
-    if (verbose)
-        fprintf(stderr, "    Create a face on specified address and port.\n");
-}
-
-void
-usage_face_delete(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-    fprintf(stderr, "%s -df ID\n", prog);
-    //fprintf(stderr, "%s -df NAME\n", prog);
-    fprintf(stderr, "%s -df TYPE LOCAL_ADDRESS LOCAL_PORT REMOTE_ADDRESS REMOTE_PORT [INTERFACE_NAME]\n", prog);
-    if (verbose)
-        fprintf(stderr, "    Delete a face...\n");
-}
-
-void
-usage_face_list(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-    fprintf(stderr, "%s -F\n", prog);
-    if (verbose)
-        fprintf(stderr, "    List all faces.\n");
-}
-
-void
-usage_face(const char * prog, bool header, bool verbose)
-{
-    usage_face_create(prog, header, verbose);
-    usage_face_delete(prog, header, verbose);
-    usage_face_list(prog, header, verbose);
-}
-
-void
-usage_route_create(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-    fprintf(stderr, "%s -r FACE_ID PREFIX [COST]\n", prog);
-    //fprintf(stderr, "%s -r [FACE_ID|NAME] PREFIX [COST]\n", prog);
-    if (verbose)
-        fprintf(stderr, "    Create a route...\n");
-}
-
-void
-usage_route_delete(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-    fprintf(stderr, "%s -dr FACE_ID PREFIX\n", prog);
-    //fprintf(stderr, "%s -dr [FACE_ID|NAME] PREFIX\n", prog);
-    if (verbose)
-        fprintf(stderr, "    Delete a route...\n");
-}
-
-void
-usage_route_list(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-    fprintf(stderr, "%s -R\n", prog);
-    if (verbose)
-        fprintf(stderr, "    List all routes.\n");
-}
-
-void
-usage_route(const char * prog, bool header, bool verbose)
-{
-    usage_route_create(prog, header, verbose);
-    usage_route_delete(prog, header, verbose);
-    usage_route_list(prog, header, verbose);
-}
-
-void
-usage_forwarding_strategy_create(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-}
-void
-usage_forwarding_strategy_delete(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-}
-
-void
-usage_forwarding_strategy_list(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-    fprintf(stderr, "%s -S\n", prog);
-    if (verbose)
-        fprintf(stderr, "    List all availble forwarding strategies.\n");
-}
-
-void
-usage_forwarding_strategy(const char * prog, bool header, bool verbose)
-{
-    usage_forwarding_strategy_create(prog, header, verbose);
-    usage_forwarding_strategy_delete(prog, header, verbose);
-    usage_forwarding_strategy_list(prog, header, verbose);
-}
-
-void
-usage_listener_create(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-    fprintf(stderr, "%s -l NAME TYPE LOCAL_ADDRESS LOCAL_PORT [INTERFACE_NAME]\n", prog);
-    if (verbose)
-        fprintf(stderr, "    Create a listener on specified address and port.\n");
-}
-
-void
-usage_listener_delete(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-    fprintf(stderr, "%s -dl ID\n", prog);
-    fprintf(stderr, "%s -dl NAME\n", prog);
-    fprintf(stderr, "%s -dl TYPE LOCAL_ADDRESS LOCAL_PORT [INTERFACE_NAME]\n", prog);
-    if (verbose)
-        fprintf(stderr, "    Delete a listener...\n");
-}
-
-void
-usage_listener_list(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-    fprintf(stderr, "%s -L\n", prog);
-    if (verbose)
-        fprintf(stderr, "    List all listeners.\n");
-}
-
-void
-usage_listener(const char * prog, bool header, bool verbose)
-{
-    usage_listener_create(prog, header, verbose);
-    usage_listener_delete(prog, header, verbose);
-    usage_listener_list(prog, header, verbose);
-}
-void
-usage_connection_create(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-    fprintf(stderr, "%s -c NAME TYPE LOCAL_ADDRESS LOCAL_PORT REMOTE_ADDRESS REMOTE_PORT [INTERFACE_NAME]\n", prog);
-    if (verbose)
-        fprintf(stderr, "    Create a connection on specified address and port.\n");
-}
-
-void
-usage_connection_delete(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-    fprintf(stderr, "%s -dc ID\n", prog);
-    fprintf(stderr, "%s -dc NAME\n", prog);
-    fprintf(stderr, "%s -dc TYPE LOCAL_ADDRESS LOCAL_PORT REMOTE_ADDRESS REMOTE_PORT [INTERFACE_NAME]\n", prog);
-    if (verbose)
-        fprintf(stderr, "    Delete a connection...\n");
-}
-
-void
-usage_connection_list(const char * prog, bool header, bool verbose)
-{
-    if (header)
-        usage_header();
-    fprintf(stderr, "%s -C\n", prog);
-    if (verbose)
-        fprintf(stderr, "    List all connections.\n");
-}
-
-void
-usage_connection(const char * prog, bool header, bool verbose)
-{
-    usage_connection_create(prog, header, verbose);
-    usage_connection_delete(prog, header, verbose);
-    usage_connection_list(prog, header, verbose);
-}
-
-void usage(const char * prog)
-{
-    fprintf(stderr, "Usage: %s [ -z forwarder (hicnlight | vpp) ] [ [-d] [-f|-l|-c|-r] PARAMETERS | [-F|-L|-C|-R] ]\n", prog);
-    fprintf(stderr, "\n");
-    fprintf(stderr, "High-level commands\n");
-    fprintf(stderr, "\n");
-    usage_face(prog, false, true);
-    usage_route(prog, false, true);
-    usage_forwarding_strategy(prog, false, true);
-    fprintf(stderr, "\n");
-    fprintf(stderr, "Low level commands (hicn-light specific)\n");
-    fprintf(stderr, "\n");
-    usage_listener(prog, false, true);
-    usage_connection(prog, false, true);
-}
-
-typedef struct {
-    hc_action_t action;
-    hc_object_t object;
-    union {
-        hc_face_t face;
-        hc_route_t route;
-        hc_connection_t connection;
-        hc_listener_t listener;
-    };
-} hc_command_t;
-
-/**
- * Return true if string is purely an integer
- */
-static inline
-bool
-is_number(const char *string) {
-  size_t len = strlen(string);
-  for (size_t i = 0; i < len; i++)
-    if (!isdigit(string[i]))
-      return false;
-  return true;
-}
-
-/**
- * A symbolic name must be at least 1 character and must begin with an alpha.
- * The remainder must be an alphanum.
- */
-static inline
-bool
-is_symbolic_name(const char *name)
-{
-    size_t len = strlen(name);
-    if (len <= 0)
-        return false;
-    if (!isalpha(name[0]))
-        return false;
-    for (size_t i = 1; i < len; i++) {
-        if (!isalnum(name[i]))
-            return false;
-    }
-    return true;
-}
-
-face_type_t
-face_type_from_str(const char * str)
-{
-#define _(x)                                    \
-    if (strcasecmp(str, STRINGIZE(x)) == 0)     \
-        return FACE_TYPE_ ## x;                 \
-    else
-foreach_face_type
-#undef _
-        return FACE_TYPE_UNDEFINED;
-}
-
-
-int
-parse_options(int argc, char *argv[], hc_command_t * command, forwarder_t *forwarder)
-{
-    command->object = OBJECT_UNDEFINED;
-    command->action = ACTION_CREATE;
-    int opt;
-    int family;
-
-    while ((opt = getopt(argc, argv, "dflcrFLCRShz:")) != -1) {
-        switch (opt) {
-            case 'z' :
-                if (strncmp(optarg, VPP_PARAM, strlen(VPP_PARAM)) == 0) {
-                    *forwarder = VPP;
-                } else if (strncmp(optarg, HICNLIGHT_PARAM, strlen(HICNLIGHT_PARAM))) {
-                    *forwarder = HICNLIGHT;
-                } else {
-                    usage(argv[0]);
-                    exit(EXIT_FAILURE);
-                }
-                break;
-            case 'd':
-                command->action = ACTION_DELETE;
-                break;
-            case 'f':
-                command->object = OBJECT_FACE;
-                break;
-            case 'l':
-                command->object = OBJECT_LISTENER;
-                break;
-            case 'c':
-                command->object = OBJECT_CONNECTION;
-                break;
-            case 'r':
-                command->object = OBJECT_ROUTE;
-                break;
-            case 'F':
-                command->action = ACTION_LIST;
-                command->object = OBJECT_FACE;
-                break;
-            case 'L':
-                command->action = ACTION_LIST;
-                command->object = OBJECT_LISTENER;
-                break;
-            case 'C':
-                command->action = ACTION_LIST;
-                command->object = OBJECT_CONNECTION;
-                break;
-            case 'R':
-                command->action = ACTION_LIST;
-                command->object = OBJECT_ROUTE;
-                break;
-            case 'S':
-                command->action = ACTION_LIST;
-                command->object = OBJECT_STRATEGY;
-                break;
-            default: /* "h" */
-                usage(argv[0]);
-                exit(EXIT_SUCCESS);
-        }
-    }
-
-    if (command->object == OBJECT_UNDEFINED) {
-        fprintf(stderr, "Missing object specification: connection | listener | route\n");
-        return -1;
-    }
-
-    /* Parse and validate parameters for add/delete */
-    switch(command->object) {
-        case OBJECT_FACE:
-            switch(command->action) {
-                case ACTION_CREATE:
-                    if ((argc - optind != 5) && (argc - optind != 6)) {
-                        usage_face_create(argv[0], true, false);
-                        goto ERR_PARAM;
-                    }
-                    /* NAME will be autogenerated (and currently not used) */
-                    //snprintf(command->face.name, SYMBOLIC_NAME_LEN, "%s", argv[optind++]);
-                    command->face.face.type = face_type_from_str(argv[optind++]);
-                    if (command->face.face.type == FACE_TYPE_UNDEFINED)
-                        goto ERR_PARAM;
-                    command->face.face.family = ip_address_get_family(argv[optind]);
-                    if (!IS_VALID_FAMILY(command->face.face.family))
-                        goto ERR_PARAM;
-                    if (ip_address_pton(argv[optind++], &command->face.face.local_addr) < 0)
-                        goto ERR_PARAM;
-                    command->face.face.local_port = atoi(argv[optind++]);
-                    family = ip_address_get_family(argv[optind]);
-                    if (!IS_VALID_FAMILY(family) || (command->face.face.family != family))
-                        goto ERR_PARAM;
-                    if (ip_address_pton(argv[optind++], &command->face.face.remote_addr) < 0)
-                        goto ERR_PARAM;
-                    command->face.face.remote_port = atoi(argv[optind++]);
-                    if (argc != optind) {
-                        //netdevice_set_name(&command->face.face.netdevice, argv[optind++]);
-                        command->face.face.netdevice.index = atoi(argv[optind++]);
-                    }
-
-                    break;
-                case ACTION_DELETE:
-                    if ((argc - optind != 1) && (argc - optind != 5) && (argc - optind != 6)) {
-                        usage_face_delete(argv[0], true, false);
-                        goto ERR_PARAM;
-                    }
-
-                    if (argc - optind == 1) {
-                        /* Id or name */
-                        if (is_number(argv[optind])) {
-                            command->face.id = atoi(argv[optind++]);
-                            snprintf(command->face.name, SYMBOLIC_NAME_LEN, "%s", argv[optind++]);
-                        //} else if (is_symbolic_name(argv[optind])) {
-                        //    snprintf(command->face.name, SYMBOLIC_NAME_LEN, "%s", argv[optind++]);
-                        } else {
-                            fprintf(stderr, "Invalid argument\n");
-                            goto ERR_PARAM;
-                        }
-                    } else {
-                        command->face.face.type = face_type_from_str(argv[optind++]);
-                        if (command->face.face.type == FACE_TYPE_UNDEFINED)
-                            goto ERR_PARAM;
-                        command->face.face.family = ip_address_get_family(argv[optind]);
-                        if (!IS_VALID_FAMILY(command->face.face.family))
-                            goto ERR_PARAM;
-                        if (ip_address_pton(argv[optind++], &command->face.face.local_addr) < 0)
-                            goto ERR_PARAM;
-                        command->face.face.local_port = atoi(argv[optind++]);
-                        family = ip_address_get_family(argv[optind]);
-                        if (!IS_VALID_FAMILY(family) || (command->face.face.family != family))
-                            goto ERR_PARAM;
-                        if (ip_address_pton(argv[optind++], &command->face.face.remote_addr) < 0)
-                            goto ERR_PARAM;
-                        command->face.face.remote_port = atoi(argv[optind++]);
-                        if (argc != optind) {
-                            command->face.face.netdevice.index = atoi(argv[optind++]);
-                            //netdevice_set_name(&command->face.face.netdevice, argv[optind++]);
-                        }
-                    }
-                    break;
-
-                case ACTION_LIST:
-                    if (argc - optind != 0) {
-                        usage_face_list(argv[0], true, false);
-                        goto ERR_PARAM;
-                    }
-                    break;
-
-                default:
-                    goto ERR_COMMAND;
-                    break;
-            }
-            break;
-
-        case OBJECT_ROUTE:
-            switch(command->action) {
-                case ACTION_CREATE:
-                    if ((argc - optind != 2) && (argc - optind != 3)) {
-                        usage_route_create(argv[0], true, false);
-                        goto ERR_PARAM;
-                    }
-
-                    command->route.face_id = atoi(argv[optind++]);
-
-                    {
-                    ip_prefix_t prefix;
-                    ip_prefix_pton(argv[optind++], &prefix);
-                    command->route.family = prefix.family;
-                    command->route.remote_addr = prefix.address;
-                    command->route.len = prefix.len;
-                    }
-
-                    if (argc != optind) {
-                        printf("parse cost\n");
-                        command->route.cost = atoi(argv[optind++]);
-                    }
-                    break;
-
-                case ACTION_DELETE:
-                    if (argc - optind != 2) {
-                        usage_route_delete(argv[0], true, false);
-                        goto ERR_PARAM;
-                    }
-
-                    command->route.face_id = atoi(argv[optind++]);
-
-                    {
-                    ip_prefix_t prefix;
-                    ip_prefix_pton(argv[optind++], &prefix);
-                    command->route.family = prefix.family;
-                    command->route.remote_addr = prefix.address;
-                    command->route.len = prefix.len;
-                    }
-                    break;
-
-                case ACTION_LIST:
-                    if (argc - optind != 0) {
-                        usage_route_list(argv[0], true, false);
-                        goto ERR_PARAM;
-                    }
-                    break;
-
-                default:
-                    goto ERR_COMMAND;
-                    break;
-            }
-            break;
-
-        case OBJECT_STRATEGY:
-            switch(command->action) {
-                case ACTION_LIST:
-                    if (argc - optind != 0) {
-                        usage_forwarding_strategy_list(argv[0], true, false);
-                        goto ERR_PARAM;
-                    }
-                    break;
-                default:
-                    goto ERR_COMMAND;
-                    break;
-            }
-            break;
-
-        case OBJECT_LISTENER:
-            switch(command->action) {
-                case ACTION_CREATE:
-                    if ((argc - optind != 4) && (argc - optind != 5)) {
-                        usage_listener_create(argv[0], true, false);
-                        goto ERR_PARAM;
-                    }
-                    snprintf(command->listener.name, SYMBOLIC_NAME_LEN, "%s", argv[optind++]);
-                    command->listener.type = connection_type_from_str(argv[optind++]);
-                    if (command->listener.type == CONNECTION_TYPE_UNDEFINED)
-                        goto ERR_PARAM;
-                    command->listener.family = ip_address_get_family(argv[optind]);
-                    if (!IS_VALID_FAMILY(command->listener.family))
-                        goto ERR_PARAM;
-                    if (ip_address_pton(argv[optind++], &command->listener.local_addr) < 0)
-                        goto ERR_PARAM;
-                    command->listener.local_port = atoi(argv[optind++]);
-                    if (argc != optind) {
-                        snprintf(command->listener.interface_name, INTERFACE_LEN, "%s", argv[optind++]);
-                    }
-                    break;
-
-                case ACTION_DELETE:
-                    if ((argc - optind != 1) && (argc - optind != 3) && (argc - optind != 4)) {
-                        usage_listener_delete(argv[0], true, false);
-                        goto ERR_PARAM;
-                    }
-
-                    if (argc - optind == 1) {
-                        /* Id or name */
-                        if (is_number(argv[optind])) {
-                            command->listener.id = atoi(argv[optind++]);
-                            snprintf(command->listener.name, SYMBOLIC_NAME_LEN, "%s", argv[optind++]);
-                        } else if (is_symbolic_name(argv[optind])) {
-                            snprintf(command->listener.name, SYMBOLIC_NAME_LEN, "%s", argv[optind++]);
-                        } else {
-                            fprintf(stderr, "Invalid argument\n");
-                            goto ERR_PARAM;
-                        }
-                    } else {
-                        command->listener.type = connection_type_from_str(argv[optind++]);
-                        if (command->listener.type == CONNECTION_TYPE_UNDEFINED)
-                            goto ERR_PARAM;
-                        command->listener.family = ip_address_get_family(argv[optind]);
-                        if (!IS_VALID_FAMILY(command->listener.family))
-                            goto ERR_PARAM;
-                        if (ip_address_pton(argv[optind++], &command->listener.local_addr) < 0)
-                            goto ERR_PARAM;
-                        command->listener.local_port = atoi(argv[optind++]);
-                        if (argc != optind) {
-                            snprintf(command->listener.interface_name, INTERFACE_LEN, "%s", argv[optind++]);
-                        }
-                    }
-                    break;
-
-                case ACTION_LIST:
-                    if (argc - optind != 0) {
-                        usage_listener_list(argv[0], true, false);
-                        goto ERR_PARAM;
-                    }
-                    break;
-
-                default:
-                        goto ERR_COMMAND;
-                    break;
-            }
-            break;
-
-        case OBJECT_CONNECTION:
-            switch(command->action) {
-                case ACTION_CREATE:
-                    /* NAME TYPE LOCAL_ADDRESS LOCAL_PORT REMOTE_ADDRESS REMOTE_PORT */
-                    if ((argc - optind != 6) && (argc - optind != 7)) {
-                        usage_connection_create(argv[0], true, false);
-                        goto ERR_PARAM;
-                    }
-                    snprintf(command->connection.name, SYMBOLIC_NAME_LEN, "%s", argv[optind++]);
-                    command->connection.type = connection_type_from_str(argv[optind++]);
-                    if (command->connection.type == CONNECTION_TYPE_UNDEFINED)
-                        goto ERR_PARAM;
-                    command->connection.family = ip_address_get_family(argv[optind]);
-                    if (!IS_VALID_FAMILY(command->connection.family))
-                        goto ERR_PARAM;
-                    if (ip_address_pton(argv[optind++], &command->connection.local_addr) < 0)
-                        goto ERR_PARAM;
-                    command->connection.local_port = atoi(argv[optind++]);
-                    family = ip_address_get_family(argv[optind]);
-                    if (!IS_VALID_FAMILY(family) || (command->connection.family != family))
-                        goto ERR_PARAM;
-                    if (ip_address_pton(argv[optind++], &command->connection.remote_addr) < 0)
-                        goto ERR_PARAM;
-                    command->connection.remote_port = atoi(argv[optind++]);
-
-                    break;
-
-                case ACTION_DELETE:
-                    if ((argc - optind != 1) && (argc - optind != 5) && (argc - optind != 6)) {
-                        usage_connection_delete(argv[0], true, false);
-                        goto ERR_PARAM;
-                    }
-
-                    if (argc - optind == 1) {
-                        /* Id or name */
-                        if (is_number(argv[optind])) {
-                            command->connection.id = atoi(argv[optind++]);
-                            snprintf(command->connection.name, SYMBOLIC_NAME_LEN, "%s", argv[optind++]);
-                        } else if (is_symbolic_name(argv[optind])) {
-                            snprintf(command->connection.name, SYMBOLIC_NAME_LEN, "%s", argv[optind++]);
-                        } else {
-                            fprintf(stderr, "Invalid argument\n");
-                            goto ERR_PARAM;
-                        }
-                    } else {
-                        command->connection.type = connection_type_from_str(argv[optind++]);
-                        if (command->connection.type == CONNECTION_TYPE_UNDEFINED)
-                            goto ERR_PARAM;
-                        command->connection.family = ip_address_get_family(argv[optind]);
-                        if (!IS_VALID_FAMILY(command->connection.family))
-                            goto ERR_PARAM;
-                        if (ip_address_pton(argv[optind++], &command->connection.local_addr) < 0)
-                            goto ERR_PARAM;
-                        command->connection.local_port = atoi(argv[optind++]);
-                        family = ip_address_get_family(argv[optind]);
-                        if (!IS_VALID_FAMILY(family) || (command->connection.family != family))
-                            goto ERR_PARAM;
-                        if (ip_address_pton(argv[optind++], &command->connection.remote_addr) < 0)
-                            goto ERR_PARAM;
-                        command->connection.remote_port = atoi(argv[optind++]);
-                    }
-                    break;
-
-                case ACTION_LIST:
-                    if (argc - optind != 0) {
-                        usage_connection_list(argv[0], true, false);
-                        goto ERR_PARAM;
-                    }
-                    break;
-
-                default:
-                    goto ERR_COMMAND;
-                    break;
-            }
-            break;
-
-        default:
-            goto ERR_COMMAND;
-            break;
-    }
-
-    return 0;
-
-ERR_PARAM:
-ERR_COMMAND:
-    return -1;
-}
-
-int main(int argc, char *argv[])
-{
-    hc_data_t * data;
-    int rc = 1;
-    hc_command_t command = {0};
-    char buf_listener[MAXSZ_HC_LISTENER];
-    char buf_connection[MAXSZ_HC_CONNECTION];
-    char buf_route[MAXSZ_HC_ROUTE];
-    char buf_strategy[MAXSZ_HC_STRATEGY];
-
-    forwarder_t forwarder = HICNLIGHT;
-
-    if (parse_options(argc, argv, &command, &forwarder) < 0)
-        die(OPTIONS, "Bad arguments");
-
-    hc_sock_t * s = hc_sock_create_forwarder(forwarder);
-    if (!s)
-        die(SOCKET, "Error creating socket.");
-
-    if (hc_sock_connect(s) < 0)
-        die(CONNECT, "Error connecting to the forwarder.");
-
-    switch(command.object) {
-        case OBJECT_FACE:
-            switch(command.action) {
-                case ACTION_CREATE:
-                    if (hc_face_create(s, &command.face) < 0)
-                        die(COMMAND, "Error creating face");
-                    printf("OK\n");
-                    break;
-
-                case ACTION_DELETE:
-                    if (hc_face_delete(s, &command.face) < 0)
-                        die(COMMAND, "Error creating face");
-                    printf("OK\n");
-                    break;
-
-                case ACTION_LIST:
-                    if (hc_face_list(s, &data) < 0)
-                        die(COMMAND, "Error getting connections.");
-
-                    printf("Faces:\n");
-                    foreach_face(f, data) {
-                        if (hc_face_snprintf(buf_connection, MAXSZ_HC_FACE, f) >= MAXSZ_HC_FACE)
-                            die(COMMAND, "Display error");
-                        printf("[%s] %s\n", f->name, buf_connection);
-                    }
-
-                    hc_data_free(data);
-                    break;
-                default:
-                    die(COMMAND, "Unsupported command for connection");
-                    break;
-            }
-            break;
-
-        case OBJECT_ROUTE:
-            switch(command.action) {
-                case ACTION_CREATE:
-                    if (hc_route_create(s, &command.route) < 0)
-                        die(COMMAND, "Error creating route");
-                    printf("OK\n");
-                    break;
-
-                case ACTION_DELETE:
-                    if (hc_route_delete(s, &command.route) < 0)
-                        die(COMMAND, "Error creating route");
-                    printf("OK\n");
-                    break;
-
-                case ACTION_LIST:
-                    if (hc_route_list(s, &data) < 0)
-                        die(COMMAND, "Error getting routes.");
-
-                    printf("Routes:\n");
-                    foreach_route(r, data) {
-                        if (hc_route_snprintf(buf_route, MAXSZ_HC_ROUTE, r) >= MAXSZ_HC_ROUTE)
-                            die(COMMAND, "Display error");
-                        printf("%s\n", buf_route);
-                    }
-
-                    hc_data_free(data);
-                    break;
-                default:
-                    die(COMMAND, "Unsupported command for route");
-                    break;
-            }
-            break;
-
-        case OBJECT_STRATEGY:
-            switch(command.action) {
-                case ACTION_LIST:
-                    if (hc_strategy_list(s, &data) < 0)
-                        die(COMMAND, "Error getting routes.");
-
-                    printf("Forwarding strategies:\n");
-                    foreach_strategy(st, data) {
-                        if (hc_strategy_snprintf(buf_strategy, MAXSZ_HC_STRATEGY, st) >= MAXSZ_HC_STRATEGY)
-                            die(COMMAND, "Display error");
-                        printf("%s\n", buf_strategy);
-                    }
-
-                    hc_data_free(data);
-                    break;
-                default:
-                    die(COMMAND, "Unsupported command for strategy");
-                    break;
-            }
-            break;
-
-        case OBJECT_LISTENER:
-            switch(command.action) {
-                case ACTION_CREATE:
-                    if (hc_listener_create(s, &command.listener) < 0)
-                        die(COMMAND, "Error creating listener");
-                    printf("OK\n");
-                    break;
-                case ACTION_DELETE:
-                    if (hc_listener_delete(s, &command.listener) < 0)
-                        die(COMMAND, "Error deleting listener");
-                    printf("OK\n");
-                    break;
-                    break;
-                case ACTION_LIST:
-                    if (hc_listener_list(s, &data) < 0)
-                        die(COMMAND, "Error getting listeners.");
-
-                    printf("Listeners:\n");
-                    foreach_listener(l, data) {
-                        if (hc_listener_snprintf(buf_listener, MAXSZ_HC_LISTENER+17, l) >= MAXSZ_HC_LISTENER)
-                            die(COMMAND, "Display error");
-                        printf("[%d] %s\n", l->id, buf_listener);
-                    }
-
-                    hc_data_free(data);
-                    break;
-                default:
-                    die(COMMAND, "Unsupported command for listener");
-                    break;
-            }
-            break;
-
-        case OBJECT_CONNECTION:
-            switch(command.action) {
-                case ACTION_CREATE:
-                    if (hc_connection_create(s, &command.connection) < 0)
-                        die(COMMAND, "Error creating connection");
-                    printf("OK\n");
-                    break;
-                case ACTION_DELETE:
-                    if (hc_connection_delete(s, &command.connection) < 0)
-                        die(COMMAND, "Error creating connection");
-                    printf("OK\n");
-                    break;
-                case ACTION_LIST:
-                    if (hc_connection_list(s, &data) < 0)
-                        die(COMMAND, "Error getting connections.");
-
-                    printf("Connections:\n");
-                    foreach_connection(c, data) {
-                        if (hc_connection_snprintf(buf_connection, MAXSZ_HC_CONNECTION, c) >= MAXSZ_HC_CONNECTION)
-                            die(COMMAND, "Display error");
-                        printf("[%s] %s\n", c->name, buf_connection);
-                    }
-
-                    hc_data_free(data);
-                    break;
-                default:
-                    die(COMMAND, "Unsupported command for connection");
-                    break;
-            }
-            break;
-
-        default:
-           die(COMMAND, "Unsupported object");
-           break;
-    }
-
-ERR_COMMAND:
-ERR_CONNECT:
-    hc_sock_free(s);
-ERR_SOCKET:
-ERR_OPTIONS:
-    return (rc < 0) ? EXIT_FAILURE : EXIT_SUCCESS;
-}
diff --git a/ctrl/libhicnctrl/src/face.c b/ctrl/libhicnctrl/src/face.c
deleted file mode 100644
index e617ff8a4..000000000
--- a/ctrl/libhicnctrl/src/face.c
+++ /dev/null
@@ -1,430 +0,0 @@
-/*
- * 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 <hicn/util/token.h>
-
-#include <hicn/ctrl/face.h>
-#include "util/hash.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 _
-};
-
-netdevice_t *
-netdevice_create_from_index(u32 index)
-{
-    netdevice_t * netdevice = malloc(sizeof(netdevice_t));
-    if (!netdevice)
-        goto ERR_MALLOC;
-
-    int rc = netdevice_set_index(netdevice, index);
-    if (rc < 0)
-        goto ERR_INIT;
-
-    return netdevice;
-
-ERR_INIT:
-    free(netdevice);
-ERR_MALLOC:
-    return NULL;
-}
-
-netdevice_t *
-netdevice_create_from_name(const char * name)
-{
-    netdevice_t * netdevice = malloc(sizeof(netdevice_t));
-    if (!netdevice)
-        goto ERR_MALLOC;
-
-    int rc = netdevice_set_name(netdevice, name);
-    if (rc < 0)
-        goto ERR_INIT;
-
-    return netdevice;
-
-ERR_INIT:
-    free(netdevice);
-ERR_MALLOC:
-    return NULL;
-}
-
-/**
- * \brief Update the index of the netdevice based on the name
- */
-int
-netdevice_update_index(netdevice_t * netdevice)
-{
-    netdevice->index = if_nametoindex(netdevice->name);
-    if (netdevice->index == 0)
-        return -1;
-    return 0;
-}
-
-int
-netdevice_update_name(netdevice_t * netdevice)
-{
-    if (!if_indextoname(netdevice->index, netdevice->name))
-        return -1;
-    return 0;
-}
-
-void
-netdevice_free(netdevice_t * netdevice)
-{
-    free(netdevice);
-}
-
-int
-netdevice_get_index(const netdevice_t * netdevice, u32 * index)
-{
-    if (netdevice->index == 0)
-        return -1;
-    *index = netdevice->index;
-    return 0;
-}
-
-int
-netdevice_set_index(netdevice_t * netdevice, u32 index)
-{
-    netdevice->index = index;
-    return netdevice_update_name(netdevice);
-}
-
-int
-netdevice_get_name(const netdevice_t * netdevice, const char ** name)
-{
-    if (netdevice->name[0] == '\0')
-        return -1;
-    *name = netdevice->name;
-    return 0;
-}
-
-int
-netdevice_set_name(netdevice_t * netdevice, const char * name)
-{
-    memset(netdevice->name, 0, sizeof(netdevice->name));
-    int rc = snprintf(netdevice->name, IFNAMSIZ, "%s", name);
-    if (rc < 0)
-        return -1;
-    if (rc >= IFNAMSIZ)
-        return -2; /* truncated */
-    return netdevice_update_index(netdevice);
-}
-
-int
-netdevice_cmp(const netdevice_t * nd1, const netdevice_t * nd2)
-{
-    return (nd1->index - nd2->index);
-}
-
-
-/* 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)
-{
-    memset(face, 0, sizeof(face_t)); /* 0'ed for hash */
-    return 1;
-}
-
-int
-face_initialize_udp(face_t * face, const char * interface_name, 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,
-        .family = family,
-        .local_addr = *local_addr,
-        .local_port = local_port,
-        .remote_addr = remote_addr ? *remote_addr : IP_ADDRESS_EMPTY,
-        .remote_port = remote_port,
-    };
-
-    snprintf(face->netdevice.name, IFNAMSIZ, "%s", interface_name);
-
-    return 1;
-}
-
-int
-face_initialize_udp_sa(face_t * face, const char * interface_name,
-        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,
-                .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->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,
-                .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->remote_addr.v6.as_in6addr = rsai->sin6_addr;
-            }
-            break;
-        default:
-            return -1;
-    }
-
-    snprintf(face->netdevice.name, IFNAMSIZ, "%s", interface_name);
-
-    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 char * interface_name,
-        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, interface_name, 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 char * interface_name,
-        const struct sockaddr * local_addr,
-        const struct sockaddr * remote_addr)
-{
-    face_t * face = face_create();
-    if (face_initialize_udp_sa(face, interface_name, local_addr, remote_addr) < 0)
-        goto ERR_INIT;
-    return face;
-
-ERR_INIT:
-    free(face);
-    return NULL;
-}
-
-void face_free(face_t * face)
-{
-    free(face);
-}
-
-/**
- * \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)
-{
-
-    int ret = f1->type - f2->type;
-    if (ret != 0)
-        return ret;
-
-    ret = f1->family - f2->family;
-    if (ret != 0)
-        return ret;
-
-    /*
-     * FIXME As hicn-light API might not return the netdevice, we can discard the
-     * comparison when one of the two is not set for now...
-     */
-    if ((f1->netdevice.index != 0) && (f2->netdevice.index != 0)) {
-        ret = netdevice_cmp(&f1->netdevice, &f2->netdevice);
-        if (ret != 0)
-            return ret;
-    }
-
-    switch(f1->type) {
-        case FACE_TYPE_HICN:
-            ret = ip_address_cmp(&f1->local_addr, &f2->local_addr, f1->family);
-            if (ret != 0)
-                return ret;
-
-            ret = ip_address_cmp(&f1->remote_addr, &f2->remote_addr, f1->family);
-            if (ret != 0)
-                return ret;
-
-            break;
-
-        case FACE_TYPE_TCP:
-        case FACE_TYPE_UDP:
-            ret = ip_address_cmp(&f1->local_addr, &f2->local_addr, f1->family);
-            if (ret != 0)
-                return ret;
-
-            ret = f1->local_port - f2->local_port;
-            if (ret != 0)
-                return ret;
-
-            ret = ip_address_cmp(&f1->remote_addr, &f2->remote_addr, f1->family);
-            if (ret != 0)
-                return ret;
-
-            ret = f1->remote_port - f2->remote_port;
-            if (ret != 0)
-                return ret;
-
-            break;
-        default:
-            break;
-    }
-
-    return 0;
-}
-
-unsigned int
-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:
-        {
-            char local[MAXSZ_IP_ADDRESS];
-            char remote[MAXSZ_IP_ADDRESS];
-            char tags[MAXSZ_POLICY_TAGS];
-
-            ip_address_snprintf(local, MAXSZ_IP_ADDRESS,
-                    &face->local_addr,
-                    face->family);
-            ip_address_snprintf(remote, MAXSZ_IP_ADDRESS,
-                    &face->remote_addr,
-                    face->family);
-            policy_tags_snprintf(tags, MAXSZ_POLICY_TAGS, face->tags);
-            return snprintf(s, size, "%s [%s -> %s] [%s]",
-                    face_type_str[face->type],
-                    local,
-                    remote,
-                    tags);
-        }
-        case FACE_TYPE_UNDEFINED:
-        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->local_addr,
-                    face->family);
-            ip_address_snprintf(remote, MAXSZ_IP_ADDRESS,
-                    &face->remote_addr,
-                    face->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->local_port,
-                    remote,
-                    face->remote_port,
-                    tags);
-        }
-        default:
-            return -1;
-    }
-
-}
-
-policy_tags_t face_get_tags(const face_t * face)
-{
-    return face->tags;
-}
-
-int
-face_set_tags(face_t * face, policy_tags_t tags)
-{
-    face->tags = tags;
-    return 1;
-}
diff --git a/ctrl/libhicnctrl/src/hicnctrl.c b/ctrl/libhicnctrl/src/hicnctrl.c
new file mode 100644
index 000000000..99d67b19f
--- /dev/null
+++ b/ctrl/libhicnctrl/src/hicnctrl.c
@@ -0,0 +1,805 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file cli.c
+ * \brief Command line interface
+ */
+#include <ctype.h>  // isalpha isalnum
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>  // getopt
+
+#include <hicn/ctrl.h>
+#include <hicn/util/ip_address.h>
+#include <hicn/util/token.h>
+#include <hicn/validation.h>
+
+#define die(LABEL, MESSAGE) \
+  do {                      \
+    printf(MESSAGE "\n");   \
+    rc = -1;                \
+    goto ERR_##LABEL;       \
+  } while (0)
+
+const char HICNLIGHT_PARAM[] = "hicnlight";
+const char HICNLIGHT_NG_PARAM[] = "hicnlightng";
+const char VPP_PARAM[] = "vpp";
+
+void usage_header() { fprintf(stderr, "Usage:\n"); }
+
+void usage_face_create(const char *prog, bool header, bool verbose) {
+  if (header) usage_header();
+  fprintf(stderr,
+          "%s -f TYPE LOCAL_ADDRESS LOCAL_PORT REMOTE_ADDRESS REMOTE_PORT "
+          "[INTERFACE_NAME]\n",
+          prog);
+  if (verbose)
+    fprintf(stderr, "    Create a face on specified address and port.\n");
+}
+
+void usage_face_delete(const char *prog, bool header, bool verbose) {
+  if (header) usage_header();
+  fprintf(stderr, "%s -df ID\n", prog);
+  // fprintf(stderr, "%s -df NAME\n", prog);
+  fprintf(stderr,
+          "%s -df TYPE LOCAL_ADDRESS LOCAL_PORT REMOTE_ADDRESS REMOTE_PORT "
+          "[INTERFACE_NAME]\n",
+          prog);
+  if (verbose) fprintf(stderr, "    Delete a face...\n");
+}
+
+void usage_face_list(const char *prog, bool header, bool verbose) {
+  if (header) usage_header();
+  fprintf(stderr, "%s -F\n", prog);
+  if (verbose) fprintf(stderr, "    List all faces.\n");
+}
+
+void usage_face(const char *prog, bool header, bool verbose) {
+  usage_face_create(prog, header, verbose);
+  usage_face_delete(prog, header, verbose);
+  usage_face_list(prog, header, verbose);
+}
+
+void usage_route_create(const char *prog, bool header, bool verbose) {
+  if (header) usage_header();
+  fprintf(stderr, "%s -r FACE_ID PREFIX [COST]\n", prog);
+  // fprintf(stderr, "%s -r [FACE_ID|NAME] PREFIX [COST]\n", prog);
+  if (verbose) fprintf(stderr, "    Create a route...\n");
+}
+
+void usage_route_delete(const char *prog, bool header, bool verbose) {
+  if (header) usage_header();
+  fprintf(stderr, "%s -dr FACE_ID PREFIX\n", prog);
+  // fprintf(stderr, "%s -dr [FACE_ID|NAME] PREFIX\n", prog);
+  if (verbose) fprintf(stderr, "    Delete a route...\n");
+}
+
+void usage_route_list(const char *prog, bool header, bool verbose) {
+  if (header) usage_header();
+  fprintf(stderr, "%s -R\n", prog);
+  if (verbose) fprintf(stderr, "    List all routes.\n");
+}
+
+void usage_route(const char *prog, bool header, bool verbose) {
+  usage_route_create(prog, header, verbose);
+  usage_route_delete(prog, header, verbose);
+  usage_route_list(prog, header, verbose);
+}
+
+void usage_forwarding_strategy_create(const char *prog, bool header,
+                                      bool verbose) {
+  if (header) usage_header();
+}
+void usage_forwarding_strategy_delete(const char *prog, bool header,
+                                      bool verbose) {
+  if (header) usage_header();
+}
+
+void usage_forwarding_strategy_list(const char *prog, bool header,
+                                    bool verbose) {
+  if (header) usage_header();
+  fprintf(stderr, "%s -S\n", prog);
+  if (verbose)
+    fprintf(stderr, "    List all availble forwarding strategies.\n");
+}
+
+void usage_forwarding_strategy(const char *prog, bool header, bool verbose) {
+  usage_forwarding_strategy_create(prog, header, verbose);
+  usage_forwarding_strategy_delete(prog, header, verbose);
+  usage_forwarding_strategy_list(prog, header, verbose);
+}
+
+void usage_listener_create(const char *prog, bool header, bool verbose) {
+  if (header) usage_header();
+  fprintf(stderr, "%s -l NAME TYPE LOCAL_ADDRESS LOCAL_PORT [INTERFACE_NAME]\n",
+          prog);
+  if (verbose)
+    fprintf(stderr, "    Create a listener on specified address and port.\n");
+}
+
+void usage_listener_delete(const char *prog, bool header, bool verbose) {
+  if (header) usage_header();
+  fprintf(stderr, "%s -dl ID\n", prog);
+  fprintf(stderr, "%s -dl NAME\n", prog);
+  fprintf(stderr, "%s -dl TYPE LOCAL_ADDRESS LOCAL_PORT [INTERFACE_NAME]\n",
+          prog);
+  if (verbose) fprintf(stderr, "    Delete a listener...\n");
+}
+
+void usage_listener_list(const char *prog, bool header, bool verbose) {
+  if (header) usage_header();
+  fprintf(stderr, "%s -L\n", prog);
+  if (verbose) fprintf(stderr, "    List all listeners.\n");
+}
+
+void usage_listener(const char *prog, bool header, bool verbose) {
+  usage_listener_create(prog, header, verbose);
+  usage_listener_delete(prog, header, verbose);
+  usage_listener_list(prog, header, verbose);
+}
+void usage_connection_create(const char *prog, bool header, bool verbose) {
+  if (header) usage_header();
+  fprintf(stderr,
+          "%s -c NAME TYPE LOCAL_ADDRESS LOCAL_PORT REMOTE_ADDRESS REMOTE_PORT "
+          "[INTERFACE_NAME]\n",
+          prog);
+  if (verbose)
+    fprintf(stderr, "    Create a connection on specified address and port.\n");
+}
+
+void usage_connection_delete(const char *prog, bool header, bool verbose) {
+  if (header) usage_header();
+  fprintf(stderr, "%s -dc ID\n", prog);
+  fprintf(stderr, "%s -dc NAME\n", prog);
+  fprintf(stderr,
+          "%s -dc TYPE LOCAL_ADDRESS LOCAL_PORT REMOTE_ADDRESS REMOTE_PORT "
+          "[INTERFACE_NAME]\n",
+          prog);
+  if (verbose) fprintf(stderr, "    Delete a connection...\n");
+}
+
+void usage_connection_list(const char *prog, bool header, bool verbose) {
+  if (header) usage_header();
+  fprintf(stderr, "%s -C\n", prog);
+  if (verbose) fprintf(stderr, "    List all connections.\n");
+}
+
+void usage_connection(const char *prog, bool header, bool verbose) {
+  usage_connection_create(prog, header, verbose);
+  usage_connection_delete(prog, header, verbose);
+  usage_connection_list(prog, header, verbose);
+}
+
+void usage(const char *prog) {
+  fprintf(stderr,
+          "Usage: %s [ -z forwarder (hicnlight | vpp) ] [ [-d] [-f|-l|-c|-r] "
+          "PARAMETERS | [-F|-L|-C|-R] ]\n",
+          prog);
+  fprintf(stderr, "\n");
+  fprintf(stderr, "High-level commands\n");
+  fprintf(stderr, "\n");
+  usage_face(prog, false, true);
+  usage_route(prog, false, true);
+  usage_forwarding_strategy(prog, false, true);
+  fprintf(stderr, "\n");
+  fprintf(stderr, "Low level commands (hicn-light specific)\n");
+  fprintf(stderr, "\n");
+  usage_listener(prog, false, true);
+  usage_connection(prog, false, true);
+}
+
+#if 0
+typedef struct {
+    hc_action_t action;
+    hc_object_t object;
+    union {
+        hc_face_t face;
+        hc_route_t route;
+        hc_connection_t connection;
+        hc_listener_t listener;
+    };
+} hc_command_t;
+#endif
+
+int parse_options(int argc, char *argv[], hc_command_t *command,
+                  forwarder_type_t *forwarder) {
+  command->object.type = OBJECT_UNDEFINED;
+  command->action = ACTION_CREATE;
+  int opt;
+  int family;
+
+  while ((opt = getopt(argc, argv, "dflcrFLCRShz:")) != -1) {
+    switch (opt) {
+      case 'z':
+        if (strncmp(optarg, VPP_PARAM, strlen(VPP_PARAM)) == 0) {
+          *forwarder = VPP;
+        } else if (strncmp(optarg, HICNLIGHT_PARAM, strlen(HICNLIGHT_PARAM))) {
+          *forwarder = HICNLIGHT;
+        } else if (strncmp(optarg, HICNLIGHT_NG_PARAM,
+                           strlen(HICNLIGHT_NG_PARAM))) {
+          *forwarder = HICNLIGHT_NG;
+        } else {
+          usage(argv[0]);
+          exit(EXIT_FAILURE);
+        }
+        break;
+      case 'd':
+        command->action = ACTION_DELETE;
+        break;
+      case 'f':
+        command->object.type = OBJECT_FACE;
+        break;
+      case 'c':
+        command->object.type = OBJECT_CONNECTION;
+        break;
+      case 'F':
+        command->action = ACTION_LIST;
+        command->object.type = OBJECT_FACE;
+        break;
+      case 'L':
+        command->action = ACTION_LIST;
+        command->object.type = OBJECT_LISTENER;
+        break;
+      case 'C':
+        command->action = ACTION_LIST;
+        command->object.type = OBJECT_CONNECTION;
+        break;
+      case 'R':
+        command->action = ACTION_LIST;
+        command->object.type = OBJECT_ROUTE;
+        break;
+      case 'S':
+        command->action = ACTION_LIST;
+        command->object.type = OBJECT_STRATEGY;
+        break;
+      default: /* "h" */
+        usage(argv[0]);
+        exit(EXIT_SUCCESS);
+    }
+  }
+
+  if (command->object.type == OBJECT_UNDEFINED) {
+    fprintf(stderr,
+            "Missing object specification: connection | listener | route\n");
+    return -1;
+  }
+
+  /* Parse and validate parameters for add/delete */
+  switch (command->object.type) {
+    case OBJECT_FACE:
+      switch (command->action) {
+        case ACTION_CREATE:
+          if ((argc - optind != 5) && (argc - optind != 6)) {
+            usage_face_create(argv[0], true, false);
+            goto ERR_PARAM;
+          }
+          /* NAME will be autogenerated (and currently not used) */
+          // snprintf(command->face.name, SYMBOLIC_NAME_LEN, "%s",
+          // argv[optind++]);
+          command->object.face.face.type = face_type_from_str(argv[optind++]);
+          if (command->object.face.face.type == FACE_TYPE_UNDEFINED)
+            goto ERR_PARAM;
+          command->object.face.face.family =
+              ip_address_get_family(argv[optind]);
+          if (!IS_VALID_FAMILY(command->object.face.face.family))
+            goto ERR_PARAM;
+          if (ip_address_pton(argv[optind++],
+                              &command->object.face.face.local_addr) < 0)
+            goto ERR_PARAM;
+          command->object.face.face.local_port = atoi(argv[optind++]);
+          family = ip_address_get_family(argv[optind]);
+          if (!IS_VALID_FAMILY(family) ||
+              (command->object.face.face.family != family))
+            goto ERR_PARAM;
+          if (ip_address_pton(argv[optind++],
+                              &command->object.face.face.remote_addr) < 0)
+            goto ERR_PARAM;
+          command->object.face.face.remote_port = atoi(argv[optind++]);
+          if (argc != optind) {
+            // netdevice_set_name(&command->object.face.face.netdevice,
+            // argv[optind++]);
+            command->object.face.face.netdevice.index = atoi(argv[optind++]);
+          }
+
+          break;
+        case ACTION_DELETE:
+          if ((argc - optind != 1) && (argc - optind != 5) &&
+              (argc - optind != 6)) {
+            usage_face_delete(argv[0], true, false);
+            goto ERR_PARAM;
+          }
+
+          if (argc - optind == 1) {
+            /* Id or name */
+            if (is_number(argv[optind], SYMBOLIC_NAME_LEN)) {
+              command->object.face.id = atoi(argv[optind++]);
+              snprintf(command->object.face.name, SYMBOLIC_NAME_LEN, "%s",
+                       argv[optind++]);
+              //} else if (is_symbolic_name(argv[optind])) {
+              //    snprintf(command->object.face.name, SYMBOLIC_NAME_LEN, "%s",
+              //    argv[optind++]);
+            } else {
+              fprintf(stderr, "Invalid argument\n");
+              goto ERR_PARAM;
+            }
+          } else {
+            command->object.face.face.type = face_type_from_str(argv[optind++]);
+            if (command->object.face.face.type == FACE_TYPE_UNDEFINED)
+              goto ERR_PARAM;
+            command->object.face.face.family =
+                ip_address_get_family(argv[optind]);
+            if (!IS_VALID_FAMILY(command->object.face.face.family))
+              goto ERR_PARAM;
+            if (ip_address_pton(argv[optind++],
+                                &command->object.face.face.local_addr) < 0)
+              goto ERR_PARAM;
+            command->object.face.face.local_port = atoi(argv[optind++]);
+            family = ip_address_get_family(argv[optind]);
+            if (!IS_VALID_FAMILY(family) ||
+                (command->object.face.face.family != family))
+              goto ERR_PARAM;
+            if (ip_address_pton(argv[optind++],
+                                &command->object.face.face.remote_addr) < 0)
+              goto ERR_PARAM;
+            command->object.face.face.remote_port = atoi(argv[optind++]);
+            if (argc != optind) {
+              command->object.face.face.netdevice.index = atoi(argv[optind++]);
+              // netdevice_set_name(&command->object.face.face.netdevice,
+              // argv[optind++]);
+            }
+          }
+          break;
+
+        case ACTION_LIST:
+          if (argc - optind != 0) {
+            usage_face_list(argv[0], true, false);
+            goto ERR_PARAM;
+          }
+          break;
+
+        default:
+          goto ERR_COMMAND;
+      }
+      break;
+
+    case OBJECT_ROUTE:
+      switch (command->action) {
+        case ACTION_CREATE:
+          if ((argc - optind != 2) && (argc - optind != 3)) {
+            usage_route_create(argv[0], true, false);
+            goto ERR_PARAM;
+          }
+
+          command->object.route.face_id = atoi(argv[optind++]);
+
+          {
+            ip_prefix_t prefix;
+            ip_prefix_pton(argv[optind++], &prefix);
+            command->object.route.family = prefix.family;
+            command->object.route.remote_addr = prefix.address;
+            command->object.route.len = prefix.len;
+          }
+
+          if (argc != optind) {
+            printf("parse cost\n");
+            command->object.route.cost = atoi(argv[optind++]);
+          }
+          break;
+
+        case ACTION_DELETE:
+          if (argc - optind != 2) {
+            usage_route_delete(argv[0], true, false);
+            goto ERR_PARAM;
+          }
+
+          command->object.route.face_id = atoi(argv[optind++]);
+
+          {
+            ip_prefix_t prefix;
+            ip_prefix_pton(argv[optind++], &prefix);
+            command->object.route.family = prefix.family;
+            command->object.route.remote_addr = prefix.address;
+            command->object.route.len = prefix.len;
+          }
+          break;
+
+        case ACTION_LIST:
+          if (argc - optind != 0) {
+            usage_route_list(argv[0], true, false);
+            goto ERR_PARAM;
+          }
+          break;
+
+        default:
+          goto ERR_COMMAND;
+      }
+      break;
+
+    case OBJECT_STRATEGY:
+      switch (command->action) {
+        case ACTION_LIST:
+          if (argc - optind != 0) {
+            usage_forwarding_strategy_list(argv[0], true, false);
+            goto ERR_PARAM;
+          }
+          break;
+        default:
+          goto ERR_COMMAND;
+      }
+      break;
+
+    case OBJECT_LISTENER:
+      switch (command->action) {
+        case ACTION_CREATE:
+          if ((argc - optind != 4) && (argc - optind != 5)) {
+            usage_listener_create(argv[0], true, false);
+            goto ERR_PARAM;
+          }
+
+          snprintf(command->object.listener.name, SYMBOLIC_NAME_LEN, "%s",
+                   argv[optind++]);
+          command->object.listener.type = face_type_from_str(argv[optind++]);
+          if (command->object.listener.type == FACE_TYPE_UNDEFINED)
+            goto ERR_PARAM;
+          command->object.listener.family = ip_address_get_family(argv[optind]);
+          if (!IS_VALID_FAMILY(command->object.listener.family)) goto ERR_PARAM;
+          if (ip_address_pton(argv[optind++],
+                              &command->object.listener.local_addr) < 0)
+            goto ERR_PARAM;
+          command->object.listener.local_port = atoi(argv[optind++]);
+          if (argc != optind) {
+            snprintf(command->object.listener.interface_name, INTERFACE_LEN,
+                     "%s", argv[optind++]);
+          }
+          break;
+
+        case ACTION_DELETE:
+          if ((argc - optind != 1) && (argc - optind != 3) &&
+              (argc - optind != 4)) {
+            usage_listener_delete(argv[0], true, false);
+            goto ERR_PARAM;
+          }
+
+          if (argc - optind == 1) {
+            /* Id or name */
+            if (is_number(argv[optind], SYMBOLIC_NAME_LEN)) {
+              command->object.listener.id = atoi(argv[optind++]);
+              snprintf(command->object.listener.name, SYMBOLIC_NAME_LEN, "%s",
+                       argv[optind++]);
+            } else if (is_symbolic_name(argv[optind], SYMBOLIC_NAME_LEN)) {
+              snprintf(command->object.listener.name, SYMBOLIC_NAME_LEN, "%s",
+                       argv[optind++]);
+            } else {
+              fprintf(stderr, "Invalid argument\n");
+              goto ERR_PARAM;
+            }
+          } else {
+            command->object.listener.type = face_type_from_str(argv[optind++]);
+            if (command->object.listener.type == FACE_TYPE_UNDEFINED)
+              goto ERR_PARAM;
+            command->object.listener.family =
+                ip_address_get_family(argv[optind]);
+            if (!IS_VALID_FAMILY(command->object.listener.family))
+              goto ERR_PARAM;
+            if (ip_address_pton(argv[optind++],
+                                &command->object.listener.local_addr) < 0)
+              goto ERR_PARAM;
+            command->object.listener.local_port = atoi(argv[optind++]);
+            if (argc != optind) {
+              snprintf(command->object.listener.interface_name, INTERFACE_LEN,
+                       "%s", argv[optind++]);
+            }
+          }
+          break;
+
+        case ACTION_LIST:
+          if (argc - optind != 0) {
+            usage_listener_list(argv[0], true, false);
+            goto ERR_PARAM;
+          }
+          break;
+
+        default:
+          goto ERR_COMMAND;
+      }
+      break;
+
+    case OBJECT_CONNECTION:
+      switch (command->action) {
+        case ACTION_CREATE:
+          /* NAME TYPE LOCAL_ADDRESS LOCAL_PORT REMOTE_ADDRESS REMOTE_PORT */
+          if ((argc - optind != 6) && (argc - optind != 7)) {
+            usage_connection_create(argv[0], true, false);
+            goto ERR_PARAM;
+          }
+          snprintf(command->object.connection.name, SYMBOLIC_NAME_LEN, "%s",
+                   argv[optind++]);
+          command->object.connection.type = face_type_from_str(argv[optind++]);
+          if (command->object.connection.type == FACE_TYPE_UNDEFINED)
+            goto ERR_PARAM;
+          command->object.connection.family =
+              ip_address_get_family(argv[optind]);
+          if (!IS_VALID_FAMILY(command->object.connection.family))
+            goto ERR_PARAM;
+          if (ip_address_pton(argv[optind++],
+                              &command->object.connection.local_addr) < 0)
+            goto ERR_PARAM;
+          command->object.connection.local_port = atoi(argv[optind++]);
+          family = ip_address_get_family(argv[optind]);
+          if (!IS_VALID_FAMILY(family) ||
+              (command->object.connection.family != family))
+            goto ERR_PARAM;
+          if (ip_address_pton(argv[optind++],
+                              &command->object.connection.remote_addr) < 0)
+            goto ERR_PARAM;
+          command->object.connection.remote_port = atoi(argv[optind++]);
+
+          break;
+
+        case ACTION_DELETE:
+          if ((argc - optind != 1) && (argc - optind != 5) &&
+              (argc - optind != 6)) {
+            usage_connection_delete(argv[0], true, false);
+            goto ERR_PARAM;
+          }
+
+          if (argc - optind == 1) {
+            /* Id or name */
+            if (is_number(argv[optind], SYMBOLIC_NAME_LEN)) {
+              command->object.connection.id = atoi(argv[optind++]);
+              snprintf(command->object.connection.name, SYMBOLIC_NAME_LEN, "%s",
+                       argv[optind++]);
+            } else if (is_symbolic_name(argv[optind], SYMBOLIC_NAME_LEN)) {
+              snprintf(command->object.connection.name, SYMBOLIC_NAME_LEN, "%s",
+                       argv[optind++]);
+            } else {
+              fprintf(stderr, "Invalid argument\n");
+              goto ERR_PARAM;
+            }
+          } else {
+            command->object.connection.type =
+                face_type_from_str(argv[optind++]);
+            if (command->object.connection.type == FACE_TYPE_UNDEFINED)
+              goto ERR_PARAM;
+            command->object.connection.family =
+                ip_address_get_family(argv[optind]);
+            if (!IS_VALID_FAMILY(command->object.connection.family))
+              goto ERR_PARAM;
+            if (ip_address_pton(argv[optind++],
+                                &command->object.connection.local_addr) < 0)
+              goto ERR_PARAM;
+            command->object.connection.local_port = atoi(argv[optind++]);
+            family = ip_address_get_family(argv[optind]);
+            if (!IS_VALID_FAMILY(family) ||
+                (command->object.connection.family != family))
+              goto ERR_PARAM;
+            if (ip_address_pton(argv[optind++],
+                                &command->object.connection.remote_addr) < 0)
+              goto ERR_PARAM;
+            command->object.connection.remote_port = atoi(argv[optind++]);
+          }
+          break;
+
+        case ACTION_LIST:
+          if (argc - optind != 0) {
+            usage_connection_list(argv[0], true, false);
+            goto ERR_PARAM;
+          }
+          break;
+
+        default:
+          goto ERR_COMMAND;
+      }
+      break;
+
+    default:
+      goto ERR_COMMAND;
+  }
+
+  return 0;
+
+ERR_PARAM:
+ERR_COMMAND:
+  return -1;
+}
+
+int main(int argc, char *argv[]) {
+  hc_data_t *data;
+  int rc = 1;
+  hc_command_t command = {0};
+  char buf_listener[MAXSZ_HC_LISTENER];
+  char buf_connection[MAXSZ_HC_CONNECTION];
+  char buf_route[MAXSZ_HC_ROUTE];
+  char buf_strategy[MAXSZ_HC_STRATEGY];
+
+  forwarder_type_t forwarder = HICNLIGHT;
+
+  if (parse_options(argc, argv, &command, &forwarder) < 0)
+    die(OPTIONS, "Bad arguments");
+
+  hc_sock_t *s = hc_sock_create_forwarder(forwarder);
+  if (!s) die(SOCKET, "Error creating socket.");
+
+  if (hc_sock_connect(s) < 0)
+    die(CONNECT, "Error connecting to the forwarder.");
+
+  switch (command.object.type) {
+    case OBJECT_FACE:
+      switch (command.action) {
+        case ACTION_CREATE:
+          if (hc_face_create(s, &command.object.face) < 0)
+            die(COMMAND, "Error creating face");
+          printf("OK\n");
+          break;
+
+        case ACTION_DELETE:
+          if (hc_face_delete(s, &command.object.face, 1) < 0)
+            die(COMMAND, "Error creating face");
+          printf("OK\n");
+          break;
+
+        case ACTION_LIST:
+          if (hc_face_list(s, &data) < 0)
+            die(COMMAND, "Error getting connections.");
+
+          printf("Faces:\n");
+          foreach_face(f, data) {
+            if (hc_face_snprintf(buf_connection, MAXSZ_HC_FACE, f) >=
+                MAXSZ_HC_FACE)
+              die(COMMAND, "Display error");
+            printf("[%s] %s\n", f->name, buf_connection);
+          }
+
+          hc_data_free(data);
+          break;
+        default:
+          die(COMMAND, "Unsupported command for connection");
+          break;
+      }
+      break;
+
+    case OBJECT_ROUTE:
+      switch (command.action) {
+        case ACTION_CREATE:
+          if (hc_route_create(s, &command.object.route) < 0)
+            die(COMMAND, "Error creating route");
+          printf("OK\n");
+          break;
+
+        case ACTION_DELETE:
+          if (hc_route_delete(s, &command.object.route) < 0)
+            die(COMMAND, "Error creating route");
+          printf("OK\n");
+          break;
+
+        case ACTION_LIST:
+          if (hc_route_list(s, &data) < 0)
+            die(COMMAND, "Error getting routes.");
+
+          printf("Routes:\n");
+          foreach_route(r, data) {
+            if (hc_route_snprintf(buf_route, MAXSZ_HC_ROUTE, r) >=
+                MAXSZ_HC_ROUTE)
+              die(COMMAND, "Display error");
+            printf("%s\n", buf_route);
+          }
+
+          hc_data_free(data);
+          break;
+        default:
+          die(COMMAND, "Unsupported command for route");
+          break;
+      }
+      break;
+
+    case OBJECT_STRATEGY:
+      switch (command.action) {
+        case ACTION_LIST:
+          if (hc_strategy_list(s, &data) < 0)
+            die(COMMAND, "Error getting routes.");
+
+          printf("Forwarding strategies:\n");
+          foreach_strategy(st, data) {
+            if (hc_strategy_snprintf(buf_strategy, MAXSZ_HC_STRATEGY, st) >=
+                MAXSZ_HC_STRATEGY)
+              die(COMMAND, "Display error");
+            printf("%s\n", buf_strategy);
+          }
+
+          hc_data_free(data);
+          break;
+        default:
+          die(COMMAND, "Unsupported command for strategy");
+          break;
+      }
+      break;
+
+    case OBJECT_LISTENER:
+      switch (command.action) {
+        case ACTION_CREATE:
+          if (hc_listener_create(s, &command.object.listener) < 0)
+            die(COMMAND, "Error creating listener");
+          printf("OK\n");
+          break;
+        case ACTION_DELETE:
+          if (hc_listener_delete(s, &command.object.listener) < 0)
+            die(COMMAND, "Error deleting listener");
+          printf("OK\n");
+          break;
+        case ACTION_LIST:
+          if (hc_listener_list(s, &data) < 0)
+            die(COMMAND, "Error getting listeners.");
+
+          printf("Listeners:\n");
+          foreach_listener(l, data) {
+            if (hc_listener_snprintf(buf_listener, MAXSZ_HC_LISTENER + 17, l) >=
+                MAXSZ_HC_LISTENER)
+              die(COMMAND, "Display error");
+            printf("[%d] %s\n", l->id, buf_listener);
+          }
+
+          hc_data_free(data);
+          break;
+        default:
+          die(COMMAND, "Unsupported command for listener");
+          break;
+      }
+      break;
+
+    case OBJECT_CONNECTION:
+      switch (command.action) {
+        case ACTION_CREATE:
+          if (hc_connection_create(s, &command.object.connection) < 0)
+            die(COMMAND, "Error creating connection");
+          printf("OK\n");
+          break;
+        case ACTION_DELETE:
+          if (hc_connection_delete(s, &command.object.connection) < 0)
+            die(COMMAND, "Error creating connection");
+          printf("OK\n");
+          break;
+        case ACTION_LIST:
+          if (hc_connection_list(s, &data) < 0)
+            die(COMMAND, "Error getting connections.");
+
+          printf("Connections:\n");
+          foreach_connection(c, data) {
+            if (hc_connection_snprintf(buf_connection, MAXSZ_HC_CONNECTION,
+                                       c) >= MAXSZ_HC_CONNECTION)
+              die(COMMAND, "Display error");
+            printf("[%s] %s\n", c->name, buf_connection);
+          }
+
+          hc_data_free(data);
+          break;
+        default:
+          die(COMMAND, "Unsupported command for connection");
+          break;
+      }
+      break;
+
+    default:
+      die(COMMAND, "Unsupported object");
+      break;
+  }
+
+ERR_COMMAND:
+ERR_CONNECT:
+  hc_sock_free(s);
+ERR_SOCKET:
+ERR_OPTIONS:
+  return (rc < 0) ? EXIT_FAILURE : EXIT_SUCCESS;
+}
diff --git a/ctrl/libhicnctrl/src/libhicnctrl-config.cmake.in b/ctrl/libhicnctrl/src/libhicnctrl-config.cmake.in
new file mode 100644
index 000000000..a27d85cde
--- /dev/null
+++ b/ctrl/libhicnctrl/src/libhicnctrl-config.cmake.in
@@ -0,0 +1,8 @@
+@PACKAGE_INIT@
+
+set(Libhicnctrl_VERSION_MAJOR "@VERSION_MAJOR@")
+set(Libhicnctrl_VERSION_MINOR "@VERSION_MINOR@")
+set(Libhicnctrl_VERSION_PATCH "@VERSION_PATCH@")
+
+set_and_check(Libhicnctrl_INCLUDE_DIRS  "@PACKAGE_Libhicnctrl_INCLUDE_DIRS@")
+include("${CMAKE_CURRENT_LIST_DIR}/libhicnctrl-targets.cmake")
diff --git a/ctrl/libhicnctrl/src/modules/CMakeLists.txt b/ctrl/libhicnctrl/src/modules/CMakeLists.txt
index e07ab8c99..8f7916d14 100644
--- a/ctrl/libhicnctrl/src/modules/CMakeLists.txt
+++ b/ctrl/libhicnctrl/src/modules/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,38 +11,53 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
-
-
-list(APPEND HICNLIGHT_MODULE_SOURCE_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_light_api.c
+##############################################################
+# Hicn Light NG Module
+##############################################################
+list(APPEND HICNLIGHTNG_MODULE_SOURCE_FILES
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_light_common.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_light_ng_api.c
 )
 
-build_module(hicnlightctrl_module
-    SHARED
-    SOURCES ${HICNLIGHT_MODULE_SOURCE_FILES}
-    DEPENDS ${DEPENDENCIES}
-    COMPONENT ${LIBHICNCTRL_COMPONENT}
-    INCLUDE_DIRS ${INCLUDE_DIRS}
-    DEFINITIONS ${COMPILER_DEFINITIONS}
-    COMPILE_OPTIONS ${COMPILE_FLAGS}
+build_module(hicnlightngctrl_module
+  SOURCES ${HICNLIGHTNG_MODULE_SOURCE_FILES}
+  DEPENDS ${DEPENDENCIES}
+  COMPONENT ${LIBHICNCTRL_COMPONENT}
+  LINK_LIBRARIES PRIVATE ${HICN_LIBRARIES}
+  INCLUDE_DIRS PRIVATE ${INCLUDE_DIRS}
+  DEFINITIONS PRIVATE ${COMPILER_DEFINITIONS}
+  COMPILE_OPTIONS PRIVATE ${COMPILE_FLAGS}
+  COMPILE_OPTIONS ${COMPILER_OPTIONS}
 )
 
+
+##############################################################
+# VPP Module
+##############################################################
 if(BUILD_HICNPLUGIN AND ${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-  list(APPEND HICNLIGHT_PLUGIN_SOURCE_FILES
-      ${CMAKE_CURRENT_SOURCE_DIR}/hicn_plugin_api.c
+  if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+    find_package(HicnPlugin ${CURRENT_VERSION} REQUIRED)
+    find_package(Safevapi ${CURRENT_VERSION} REQUIRED)
+  else()
+    list(APPEND DEPENDENCIES
+      ${SAFE_VAPI_SHARED}
+    )
+  endif()
+
+  list(APPEND HICN_PLUGIN_SOURCE_FILES
+    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_plugin_api.c
   )
 
   build_module(vppctrl_module
-      SHARED
-      SOURCES ${HICNLIGHT_PLUGIN_SOURCE_FILES}
-      DEPENDS ${DEPENDENCIES}
-      LINK_LIBRARIES ${HICNPLUGIN_LIBRARIES} ${SAFE_VAPI_LIBRARIES}
-      COMPONENT ${LIBHICNCTRL_COMPONENT_MODULES}
-      INCLUDE_DIRS ${INCLUDE_DIRS}
-      DEFINITIONS ${COMPILER_DEFINITIONS}
-      COMPILE_OPTIONS ${COMPILE_FLAGS}
-      LINK_FLAGS "-Wl,-unresolved-symbols=ignore-in-shared-libs"
+    SOURCES ${HICN_PLUGIN_SOURCE_FILES}
+    DEPENDS ${DEPENDENCIES}
+    LINK_LIBRARIES
+      PRIVATE ${HICN_LIBRARIES}
+      PRIVATE ${HICNPLUGIN_LIBRARIES}
+      PRIVATE ${SAFE_VAPI_LIBRARIES}
+    COMPONENT ${LIBHICNCTRL_COMPONENT_MODULES}
+    INCLUDE_DIRS PRIVATE ${INCLUDE_DIRS}
+    DEFINITIONS PRIVATE ${COMPILER_DEFINITIONS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS} ${MARCH_COMPILER_OPTIONS}
   )
-
-endif()
\ No newline at end of file
+endif()
diff --git a/ctrl/libhicnctrl/src/modules/hicn_light_api.c b/ctrl/libhicnctrl/src/modules/hicn_light_api.c
deleted file mode 100644
index d1a055777..000000000
--- a/ctrl/libhicnctrl/src/modules/hicn_light_api.c
+++ /dev/null
@@ -1,2278 +0,0 @@
-/*
- * 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 api.c
- * \brief Implementation of hICN control library API
- */
-
-#include "api_private.h"
-
-#include <assert.h> // assert
-#include <stdbool.h>
-#include <stdio.h> // snprintf
-#include <string.h> // memmove, strcasecmp
-#include <sys/socket.h> // socket
-#include <unistd.h> // close, fcntl
-#include <fcntl.h> // fcntl
-#include <sys/types.h> // getpid
-#include <unistd.h>    // getpid
-#ifdef __linux__
-#include <sys/syscall.h>
-#define gettid() syscall(SYS_gettid)
-#endif /* __linux__ */
-#include <strings.h>
-
-#define PORT 9695
-
-#define BOOLSTR(x) ((x) ? "true" : "false")
-
-/*
- * Internal state associated to a pending request
- */
-typedef struct {
-    int seq;
-    hc_data_t * data;
-    /* Information used to process results */
-    int size_in;
-    int (*parse)(const u8 * src, u8 * dst);
-} hc_sock_request_t;
-
-/**
- * Messages to the forwarder might be multiplexed thanks to the seqNum fields in
- * the header_control_message structure. The forwarder simply answers back the
- * original sequence number. We maintain a map of such sequence number to
- * outgoing queries so that replied can be demultiplexed and treated
- * appropriately.
- */
-TYPEDEF_MAP_H(hc_sock_map, int, hc_sock_request_t *);
-TYPEDEF_MAP(hc_sock_map, int, hc_sock_request_t *, int_cmp, int_snprintf, generic_snprintf);
-
-struct hc_sock_light_s {
-    /* This must be the first element of the struct */
-    hc_sock_t vft;
-
-    char * url;
-    int fd;
-
-    /* Partial receive buffer */
-    u8 buf[RECV_BUFLEN];
-    size_t roff; /**< Read offset */
-    size_t woff; /**< Write offset */
-
-    /*
-     * Because received messages are potentially unbounded in size, we might not
-     * guarantee that we can store a full packet before processing it. We must
-     * implement a very simple state machine remembering the current parsing
-     * status in order to partially process the packet.
-     */
-    size_t remaining;
-    u32 send_id;
-
-    /* Next sequence number to be used for requests */
-    int seq;
-
-    /* Request being parsed (NULL if none) */
-    hc_sock_request_t * cur_request;
-
-    bool async;
-    hc_sock_map_t * map;
-};
-
-typedef struct hc_sock_light_s hc_sock_light_t;
-
-#define TO_HC_SOCK_LIGHT(s) (hc_sock_light_t*)(s)
-
-hc_sock_request_t *
-hc_sock_request_create(int seq, hc_data_t * data, HC_PARSE parse)
-{
-    assert(data);
-
-    hc_sock_request_t * request = malloc(sizeof(hc_sock_request_t));
-    if (!request)
-        return NULL;
-    request->seq = seq;
-    request->data = data;
-    request->parse = parse;
-    return request;
-}
-
-void
-hc_sock_light_request_free(hc_sock_request_t * request)
-{
-    free(request);
-}
-
-/*
- * list was working with all seq set to 0, but it seems hicnLightControl uses
- * 1, and replies with the same seqno
- */
-#define HICN_CTRL_SEND_SEQ_INIT 1
-#define HICN_CTRL_RECV_SEQ_INIT 1
-
-#define MAX(x, y) ((x > y) ? x : y)
-
-/**
- * In practise, we want to preserve enough room to store a full packet of
- * average expected size (say a header + N payload elements).
- */
-#define AVG_ELEMENTS (1 << DEFAULT_SIZE_LOG)
-#define AVG_BUFLEN (sizeof(hc_msg_header_t) + AVG_ELEMENTS * sizeof(hc_msg_payload_t))
-
-/*
- * We should at least have buffer space allowing to store one processable unit
- * of data, either the header of the maximum possible payload
- */
-#define MIN_BUFLEN MAX(sizeof(hc_msg_header_t), sizeof(hc_msg_payload_t))
-
-static const struct in6_addr loopback_addr = IN6ADDR_LOOPBACK_INIT;
-
-/******************************************************************************
- * Message helper types and aliases
- ******************************************************************************/
-
-#define foreach_hc_command      \
-    _(add_connection)           \
-    _(remove_connection)        \
-    _(list_connections)         \
-    _(add_listener)             \
-    _(remove_listener)          \
-    _(list_listeners)           \
-    _(add_route)                \
-    _(remove_route)             \
-    _(list_routes)              \
-    _(cache_store)              \
-    _(cache_serve)              \
-    /*_(cache_clear) */         \
-    _(set_strategy)             \
-    _(set_wldr)                 \
-    _(add_punting)              \
-    _(mapme_activator)          \
-    _(mapme_timing)
-
-typedef header_control_message hc_msg_header_t;
-
-typedef union {
-#define _(x) x ## _command x;
-        foreach_hc_command
-#undef _
-} hc_msg_payload_t;
-
-
-typedef struct hc_msg_s {
-    hc_msg_header_t hdr;
-    hc_msg_payload_t payload;
-} hc_msg_t;
-
-/******************************************************************************
- * Control socket
- ******************************************************************************/
-
-/**
- * \brief Parse a connection URL into a sockaddr
- * \param [in] url - URL
- * \param [out] sa - Resulting struct sockaddr, expected zero'ed.
- * \return 0 if parsing succeeded, a negative error value otherwise.
- */
-static int
-_hc_sock_light_parse_url(const char * url, struct sockaddr * sa)
-{
-    /* FIXME URL parsing is currently not implemented */
-    assert(!url);
-
-#ifdef __linux__
-    srand(time(NULL) ^ getpid() ^ gettid());
-#else
-    srand((unsigned int )(time(NULL) ^ getpid()));
-#endif /* __linux__ */
-
-    /*
-     * A temporary solution is to inspect the sa_family fields of the passed in
-     * sockaddr, which defaults to AF_UNSPEC (0) and thus creates an IPv4/TCP
-     * connection to localhost.
-     */
-    switch (sa->sa_family) {
-        case AF_UNSPEC:
-        case AF_INET:
-        {
-            struct sockaddr_in * sai = (struct sockaddr_in *)sa;
-            sai->sin_family = AF_INET;
-            sai->sin_port = htons(PORT);
-            sai->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-            break;
-        }
-        case AF_INET6:
-        {
-            struct sockaddr_in6 * sai6 = (struct sockaddr_in6 *)sa;
-            sai6->sin6_family = AF_INET6;
-            sai6->sin6_port = htons(PORT);
-            sai6->sin6_addr = loopback_addr;
-            break;
-        }
-        default:
-             return -1;
-    }
-
-     return 0;
-}
-
-static int
-_hc_sock_light_reset(hc_sock_t * socket)
-{
-    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
-    s->roff = s->woff = 0;
-    s->remaining = 0;
-    return 0;
-}
-
-void
-_hc_sock_light_free(hc_sock_t * socket)
-{
-    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
-    hc_sock_request_t ** request_array = NULL;
-    int n = hc_sock_map_get_value_array(s->map, &request_array);
-    if (n < 0) {
-       ERROR("Could not retrieve pending request array for freeing up resources");
-    } else {
-        for (unsigned i = 0; i < n; i++) {
-            hc_sock_request_t * request = request_array[i];
-            if (hc_sock_map_remove(s->map, request->seq, NULL) < 0)
-                ERROR("[hc_sock_light_process] Error removing request from map");
-            hc_sock_light_request_free(request);
-        }
-        free(request_array);
-    }
-
-    hc_sock_map_free(s->map);
-    if (s->url)
-        free(s->url);
-    close(s->fd);
-    free(s);
-}
-
-static int
-_hc_sock_light_get_next_seq(hc_sock_t * socket)
-{
-    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
-    return s->seq++;
-}
-
-static int
-_hc_sock_light_set_nonblocking(hc_sock_t * socket)
-{
-    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
-    return (fcntl(s->fd, F_SETFL, fcntl(s->fd, F_GETFL) | O_NONBLOCK) < 0);
-}
-
-static int
-_hc_sock_light_get_fd(hc_sock_t * socket)
-{
-    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
-    return s->fd;
-}
-
-static int
-_hc_sock_light_connect(hc_sock_t * socket)
-{
-    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
-    struct sockaddr_storage ss;
-    memset(&ss, 0, sizeof(struct sockaddr_storage));
-
-    if (_hc_sock_light_parse_url(s->url, (struct sockaddr *)&ss) < 0)
-        goto ERR_PARSE;
-
-    size_t size = ss.ss_family == AF_INET
-        ? sizeof(struct sockaddr_in)
-        : sizeof(struct sockaddr_in6);
-    if (connect(s->fd, (struct sockaddr *)&ss, (socklen_t)size) < 0) //sizeof(struct sockaddr)) < 0)
-        goto ERR_CONNECT;
-
-     return 0;
-
-ERR_CONNECT:
-ERR_PARSE:
-     return -1;
-}
-
-static int
-_hc_sock_light_send(hc_sock_t * socket, hc_msg_t * msg, size_t msglen, int seq)
-{
-    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
-    int rc;
-    msg->hdr.seqNum = seq;
-    rc = (int)send(s->fd, msg, msglen, 0);
-    if (rc < 0) {
-        perror("hc_sock_light_send");
-        return -1;
-    }
-    return 0;
-}
-
-static int
-_hc_sock_light_get_available(hc_sock_t * socket, u8 ** buffer, size_t * size)
-{
-    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
-    *buffer = s->buf + s->woff;
-    *size = RECV_BUFLEN - s->woff;
-
-     return 0;
-}
-
-static int
-_hc_sock_light_recv(hc_sock_t * socket)
-{
-    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
-    int rc;
-
-    /*
-     * This condition should be ensured to guarantee correct processing of
-     * messages
-     */
-    assert(RECV_BUFLEN - s->woff > MIN_BUFLEN);
-
-    rc = (int)recv(s->fd, s->buf + s->woff, RECV_BUFLEN - s->woff, 0);
-    if (rc == 0) {
-        /* Connection has been closed */
-         return 0;
-    }
-    if (rc < 0) {
-        /*
-         * Let's not return 0 which currently means the socket has been closed
-         */
-        if (errno == EWOULDBLOCK)
-            return -1;
-        perror("hc_sock_light_recv");
-        return -1;
-    }
-    s->woff += rc;
-    return rc;
-}
-
-/*
- * Returns -99 in case of internal error, -1 in case of API command failure
- */
-static int
-_hc_sock_light_process(hc_sock_t * socket, hc_data_t ** data)
-{
-    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
-    int err = 0;
-
-    /* We must have received at least one byte */
-    size_t available = s->woff - s->roff;
-
-    while(available > 0) {
-
-        if (!s->cur_request) { // No message being parsed, alternatively (remaining == 0)
-            hc_msg_t * msg = (hc_msg_t*)(s->buf + s->roff);
-
-            /* We expect a message header */
-            if (available < sizeof(hc_msg_header_t)) {
-                break;
-            }
-
-            hc_sock_request_t * request = NULL;
-            if (hc_sock_map_get(s->map, msg->hdr.seqNum, &request) < 0) {
-                ERROR("[hc_sock_light_process] Error searching for matching request");
-                return -99;
-            }
-            if (!request) {
-                ERROR("[hc_sock_light_process] No request matching received sequence number");
-                return -99;
-            }
-
-            s->remaining = msg->hdr.length;
-            switch(msg->hdr.messageType) {
-                case ACK_LIGHT:
-                    assert(s->remaining == 1);
-                    assert(!data);
-                    s->cur_request = request;
-                    break;
-                case NACK_LIGHT:
-                    assert(s->remaining == 1);
-                    assert(!data);
-                    hc_data_set_error(request->data);
-                    s->cur_request = request;
-                    err = -1;
-                    break;
-                case RESPONSE_LIGHT:
-                    assert(data);
-                    if (s->remaining == 0) {
-                        hc_data_set_complete(request->data);
-                        *data = request->data;
-                        if (hc_sock_map_remove(s->map, request->seq, NULL) < 0)
-                            ERROR("[hc_sock_light_process] Error removing request from map");
-                        hc_sock_light_request_free(request);
-                    } else {
-                        /* We only remember it if there is still data to parse */
-                        s->cur_request = request;
-                    }
-                    break;
-                default:
-                    ERROR("[hc_sock_light_process] Invalid response received");
-                    return -99;
-            }
-
-            available -= sizeof(hc_msg_header_t);
-            s->roff += sizeof(hc_msg_header_t);
-        } else {
-            /* We expect the complete payload, or at least a chunk of it */
-            size_t num_chunks = available / s->cur_request->data->in_element_size;
-            if (num_chunks == 0)
-                break;
-            if (num_chunks > s->remaining)
-                num_chunks = s->remaining;
-
-            if (!s->cur_request->parse) {
-                /* If we don't need to parse results, then we can directly push
-                 * all of them into the result data structure */
-                hc_data_push_many(s->cur_request->data, s->buf + s->roff, num_chunks);
-            } else {
-                int rc;
-                rc = hc_data_ensure_available(s->cur_request->data, num_chunks);
-                if (rc < 0) {
-                    ERROR("[hc_sock_light_process] Error in hc_data_ensure_available");
-                    return -99;
-                }
-                for (int i = 0; i < num_chunks; i++) {
-                    u8 * dst = hc_data_get_next(s->cur_request->data);
-                    if (!dst) {
-                        ERROR("[hc_sock_light_process] Error in hc_data_get_next");
-                        return -99;
-                    }
-
-                    rc = s->cur_request->parse(s->buf + s->roff + i * s->cur_request->data->in_element_size, dst);
-                    if (rc < 0) {
-                        ERROR("[hc_sock_light_process] Error in parse");
-                        err = -99; /* FIXME we let the loop complete (?) */
-                    }
-                    s->cur_request->data->size++;
-                }
-            }
-
-            s->remaining -= num_chunks;
-            available -= num_chunks * s->cur_request->data->in_element_size;
-            s->roff += num_chunks * s->cur_request->data->in_element_size;
-            if (s->remaining == 0) {
-                if (hc_sock_map_remove(s->map, s->cur_request->seq, NULL) < 0) {
-                    ERROR("[hc_sock_light_process] Error removing request from map");
-                    return -99;
-                }
-                hc_data_set_complete(s->cur_request->data);
-                if (data)
-                    *data = s->cur_request->data;
-                hc_sock_light_request_free(s->cur_request);
-                s->cur_request = NULL;
-            }
-
-        }
-    }
-
-    /* Make sure there is enough remaining space in the buffer */
-    if (RECV_BUFLEN - s->woff < AVG_BUFLEN) {
-        /*
-         * There should be no overlap provided a sufficiently large BUFLEN, but
-         * who knows.
-         */
-        memmove(s->buf, s->buf + s->roff, s->woff - s->roff);
-        s->woff -= s->roff;
-        s->roff = 0;
-    }
-
-    return err;
-}
-
-static int
-_hc_sock_light_callback(hc_sock_t * socket, hc_data_t ** pdata)
-{
-    hc_data_t * data;
-
-    for (;;) {
-        int n = _hc_sock_light_recv(socket);
-        if (n == 0)
-            goto ERR_EOF;
-        if (n < 0) {
-            switch(errno) {
-                case ECONNRESET:
-                case ENODEV:
-                    /* Forwarder restarted */
-                    WARN("Forwarder likely restarted: not (yet) implemented");
-                    goto ERR;
-                case EWOULDBLOCK:
-                    //DEBUG("Would block... stop reading from socket");
-                    goto END;
-                default:
-                    perror("hc_sock_light_recv");
-                    goto ERR;
-            }
-        }
-        if (_hc_sock_light_process(socket, &data) < 0) {
-            goto ERR;
-        }
-    }
-END:
-    if (pdata)
-        *pdata = data;
-    else
-        hc_data_free(data);
-    return 0;
-
-ERR:
-    hc_data_free(data);
-ERR_EOF:
-    return -1;
-}
-
-/******************************************************************************
- * Command-specific structures and functions
- ******************************************************************************/
-
-typedef int (*HC_PARSE)(const u8 *, u8 *);
-
-typedef struct {
-    hc_action_t cmd;
-    command_id cmd_id;
-    size_t size_in;
-    size_t size_out;
-    HC_PARSE parse;
-} hc_command_params_t;
-
-static int
-_hc_execute_command(hc_sock_t * socket, hc_msg_t * msg, size_t msg_len,
-        hc_command_params_t * params, hc_data_t ** pdata, bool async)
-{
-    hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
-    int ret;
-    if (async)
-        assert(!pdata);
-
-    /* Sanity check */
-    switch(params->cmd) {
-        case ACTION_CREATE:
-            assert(params->size_in != 0); /* payload repeated */
-            assert(params->size_out == 0);
-            assert(params->parse == NULL);
-            break;
-        case ACTION_DELETE:
-            assert(params->size_in != 0); /* payload repeated */
-            assert(params->size_out == 0);
-            assert(params->parse == NULL);
-            break;
-        case ACTION_LIST:
-            assert(params->size_in != 0);
-            assert(params->size_out != 0);
-            assert(params->parse != NULL);
-            break;
-        case ACTION_SET:
-            assert(params->size_in != 0);
-            assert(params->size_out == 0);
-            assert(params->parse == NULL);
-            break;
-        default:
-             return -1;
-    }
-
-    //hc_sock_light_reset(s);
-
-    /* XXX data will at least store the result (complete) */
-    hc_data_t * data = hc_data_create(params->size_in, params->size_out, NULL);
-    if (!data) {
-        ERROR("[_hc_execute_command] Could not create data storage");
-        goto ERR_DATA;
-    }
-
-    int seq = _hc_sock_light_get_next_seq(socket);
-
-    /* Create state used to process the request */
-    hc_sock_request_t * request = NULL;
-    request = hc_sock_request_create(seq, data, params->parse);
-    if (!request) {
-        ERROR("[_hc_execute_command] Could not create request state");
-        goto ERR_REQUEST;
-    }
-
-    /* Add state to map */
-    if (hc_sock_map_add(s->map, seq, request) < 0) {
-        ERROR("[_hc_execute_command] Error adding request state to map");
-        goto ERR_MAP;
-    }
-
-    if (_hc_sock_light_send(socket, msg, msg_len, seq) < 0) {
-        ERROR("[_hc_execute_command] Error sending message");
-        goto ERR_PROCESS;
-    }
-
-    if (async)
-        return 0;
-
-    while(!data->complete) {
-        /*
-         * As the socket is non blocking it might happen that we need to read
-         * several times before success... shall we alternate between blocking
-         * and non-blocking mode ?
-         */
-        int n = _hc_sock_light_recv(socket);
-        if (n == 0)
-            goto ERR_EOF;
-        if (n < 0)
-            continue; //break;
-        int rc = _hc_sock_light_process(socket, pdata);
-        switch(rc) {
-            case 0:
-                break;
-            case -1:
-                ret = rc;
-                break;
-            case -99:
-                ERROR("[_hc_execute_command] Error processing socket results");
-                goto ERR;
-                break;
-            default:
-                ERROR("[_hc_execute_command] Unexpected return value");
-                goto ERR;
-        }
-    }
-
-ERR_EOF:
-    ret = data->ret;
-    if (!data->complete)
-        return -1;
-    if (!pdata)
-        hc_data_free(data);
-
-    return ret;
-
-ERR_PROCESS:
-ERR_MAP:
-    hc_sock_light_request_free(request);
-ERR:
-ERR_REQUEST:
-    hc_data_free(data);
-ERR_DATA:
-     return -99;
-}
-
-/*----------------------------------------------------------------------------*
- * Listeners
- *----------------------------------------------------------------------------*/
-
-/* LISTENER CREATE */
-
-static int
-_hc_listener_create_internal(hc_sock_t * socket, hc_listener_t * listener, bool async)
-{
-    char listener_s[MAXSZ_HC_LISTENER];
-    int rc = hc_listener_snprintf(listener_s, MAXSZ_HC_LISTENER, listener);
-    if (rc >= MAXSZ_HC_LISTENER)
-        WARN("[_hc_listener_create] Unexpected truncation of listener string");
-    DEBUG("[_hc_listener_create] listener=%s async=%s", listener_s,
-            BOOLSTR(async));
-
-    if (!IS_VALID_FAMILY(listener->family))
-         return -1;
-
-    if (!IS_VALID_CONNECTION_TYPE(listener->type))
-         return -1;
-
-    struct {
-        header_control_message hdr;
-        add_listener_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = ADD_LISTENER,
-            .length = 1,
-            .seqNum = 0,
-        },
-        .payload = {
-            .address = listener->local_addr,
-            .port = htons(listener->local_port),
-            .addressType = (u8)map_to_addr_type[listener->family],
-            .listenerMode = (u8)map_to_listener_mode[listener->type],
-            .connectionType = (u8)map_to_connection_type[listener->type],
-        }
-    };
-
-    rc = snprintf(msg.payload.symbolic, SYMBOLIC_NAME_LEN, "%s", listener->name);
-    if (rc >= SYMBOLIC_NAME_LEN)
-        WARN("[_hc_listener_create] Unexpected truncation of symbolic name string");
-
-    rc = snprintf(msg.payload.interfaceName, INTERFACE_LEN, "%s", listener->interface_name);
-    if (rc >= INTERFACE_LEN)
-        WARN("[_hc_listener_create] Unexpected truncation of interface name string");
-
-    hc_command_params_t params = {
-        .cmd = ACTION_CREATE,
-        .cmd_id = ADD_LISTENER,
-        .size_in = sizeof(add_listener_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_listener_create(hc_sock_t * s, hc_listener_t * listener)
-{
-    return _hc_listener_create_internal(s, listener, false);
-}
-
-static int
-_hc_listener_create_async(hc_sock_t * s, hc_listener_t * listener)
-{
-    return _hc_listener_create_internal(s, listener, true);
-}
-
-/* LISTENER LIST */
-
-static int
-_hc_listener_list_internal(hc_sock_t * socket, hc_data_t ** pdata, bool async)
-{
-    DEBUG("[hc_listener_list] async=%s", BOOLSTR(async));
-
-    struct {
-        header_control_message hdr;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = LIST_LISTENERS,
-            .length = 0,
-            .seqNum = 0,
-        },
-    };
-
-    hc_command_params_t params = {
-        .cmd = ACTION_LIST,
-        .cmd_id = LIST_LISTENERS,
-        .size_in = sizeof(list_listeners_command),
-        .size_out = sizeof(hc_listener_t),
-        .parse = (HC_PARSE)hc_listener_parse,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, pdata, async);
-}
-
-static int
-_hc_listener_list(hc_sock_t * s, hc_data_t ** pdata)
-{
-    return _hc_listener_list_internal(s, pdata, false);
-}
-
-static int
-_hc_listener_list_async(hc_sock_t * s, hc_data_t ** pdata)
-{
-    return _hc_listener_list_internal(s, pdata, true);
-}
-
-/* LISTENER GET */
-
-static int
-_hc_listener_get(hc_sock_t * socket, hc_listener_t * listener,
-        hc_listener_t ** listener_found)
-{
-    hc_data_t * listeners;
-    hc_listener_t * found;
-
-    char listener_s[MAXSZ_HC_LISTENER];
-    int rc = hc_listener_snprintf(listener_s, MAXSZ_HC_LISTENER, listener);
-    if (rc >= MAXSZ_HC_LISTENER)
-        WARN("[hc_listener_get] Unexpected truncation of listener string");
-    DEBUG("[hc_listener_get] listener=%s", listener_s);
-
-    if (_hc_listener_list(socket, &listeners) < 0)
-        return -1;
-
-    /* Test */
-    if (hc_listener_find(listeners, listener, &found) < 0) {
-        hc_data_free(listeners);
-        return -1;
-    }
-
-    if (found) {
-        *listener_found = malloc(sizeof(hc_listener_t));
-        if (!*listener_found)
-            return -1;
-        **listener_found = *found;
-    } else {
-        *listener_found = NULL;
-    }
-
-    hc_data_free(listeners);
-
-    return 0;
-}
-
-
-/* LISTENER DELETE */
-
-static int
-_hc_listener_delete_internal(hc_sock_t * socket, hc_listener_t * listener, bool async)
-{
-    char listener_s[MAXSZ_HC_LISTENER];
-    int rc = hc_listener_snprintf(listener_s, MAXSZ_HC_LISTENER, listener);
-    if (rc >= MAXSZ_HC_LISTENER)
-        WARN("[_hc_listener_delete] Unexpected truncation of listener string");
-    DEBUG("[_hc_listener_delete] listener=%s async=%s", listener_s,
-            BOOLSTR(async));
-
-    struct {
-        header_control_message hdr;
-        remove_listener_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = REMOVE_LISTENER,
-            .length = 1,
-            .seqNum = 0,
-        },
-    };
-
-    if (listener->id) {
-        rc = snprintf(msg.payload.symbolicOrListenerid, SYMBOLIC_NAME_LEN, "%d", listener->id);
-        if (rc >= SYMBOLIC_NAME_LEN)
-            WARN("[_hc_listener_delete] Unexpected truncation of symbolic name string");
-    } else if (*listener->name) {
-        rc = snprintf(msg.payload.symbolicOrListenerid, SYMBOLIC_NAME_LEN, "%s", listener->name);
-        if (rc >= SYMBOLIC_NAME_LEN)
-            WARN("[_hc_listener_delete] Unexpected truncation of symbolic name string");
-    } else {
-        hc_listener_t * listener_found;
-        if (_hc_listener_get(socket, listener, &listener_found) < 0)
-            return -1;
-        if (!listener_found)
-            return -1;
-        rc = snprintf(msg.payload.symbolicOrListenerid, SYMBOLIC_NAME_LEN, "%d", listener_found->id);
-        if (rc >= SYMBOLIC_NAME_LEN)
-            WARN("[_hc_listener_delete] Unexpected truncation of symbolic name string");
-        free(listener_found);
-    }
-
-    hc_command_params_t params = {
-        .cmd = ACTION_DELETE,
-        .cmd_id = REMOVE_LISTENER,
-        .size_in = sizeof(remove_listener_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_listener_delete(hc_sock_t * s, hc_listener_t * listener)
-{
-    return _hc_listener_delete_internal(s, listener, false);
-}
-
-static int
-_hc_listener_delete_async(hc_sock_t * s, hc_listener_t * listener)
-{
-    return _hc_listener_delete_internal(s, listener, true);
-}
-
-/*----------------------------------------------------------------------------*
- * CONNECTION
- *----------------------------------------------------------------------------*/
-
-/* CONNECTION CREATE */
-
-static int
-_hc_connection_create_internal(hc_sock_t * socket, hc_connection_t * connection, bool async)
-{
-    char connection_s[MAXSZ_HC_CONNECTION];
-    int rc = hc_connection_snprintf(connection_s, MAXSZ_HC_CONNECTION, connection);
-    if (rc >= MAXSZ_HC_CONNECTION)
-        WARN("[_hc_connection_create] Unexpected truncation of connection string");
-    DEBUG("[_hc_connection_create] connection=%s async=%s", connection_s, BOOLSTR(async));
-
-    if (hc_connection_validate(connection) < 0)
-        return -1;
-
-    struct {
-        header_control_message hdr;
-        add_connection_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = ADD_CONNECTION,
-            .length = 1,
-            .seqNum = 0,
-        },
-        .payload = {
-            .remoteIp = connection->remote_addr,
-            .localIp = connection->local_addr,
-            .remotePort = htons(connection->remote_port),
-            .localPort = htons(connection->local_port),
-            .ipType = (u8)map_to_addr_type[connection->family],
-            .connectionType = (u8)map_to_connection_type[connection->type],
-            .admin_state = connection->admin_state,
-#ifdef WITH_POLICY
-            .priority = connection->priority,
-            .tags = connection->tags,
-#endif /* WITH_POLICY */
-        }
-    };
-    rc = snprintf(msg.payload.symbolic, SYMBOLIC_NAME_LEN, "%s", connection->name);
-    if (rc >= SYMBOLIC_NAME_LEN)
-        WARN("[_hc_connection_create] Unexpected truncation of symbolic name string");
-    //snprintf(msg.payload.interfaceName, INTERFACE_NAME_LEN, "%s", connection->interface_name);
-
-    hc_command_params_t params = {
-        .cmd = ACTION_CREATE,
-        .cmd_id = ADD_CONNECTION,
-        .size_in = sizeof(add_connection_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_connection_create(hc_sock_t * s, hc_connection_t * connection)
-{
-    return _hc_connection_create_internal(s, connection, false);
-}
-
-static int
-_hc_connection_create_async(hc_sock_t * s, hc_connection_t * connection)
-{
-    return _hc_connection_create_internal(s, connection, true);
-}
-
-/* CONNECTION LIST */
-
-static int
-_hc_connection_list_internal(hc_sock_t * socket, hc_data_t ** pdata, bool async)
-{
-    DEBUG("[hc_connection_list] async=%s", BOOLSTR(async));
-
-    struct {
-        header_control_message hdr;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = LIST_CONNECTIONS,
-            .length = 0,
-            .seqNum = 0,
-        },
-    };
-
-    hc_command_params_t params = {
-        .cmd = ACTION_LIST,
-        .cmd_id = LIST_CONNECTIONS,
-        .size_in = sizeof(list_connections_command),
-        .size_out = sizeof(hc_connection_t),
-        .parse = (HC_PARSE)hc_connection_parse,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, pdata, async);
-}
-
-static int
-_hc_connection_list(hc_sock_t * s, hc_data_t ** pdata)
-{
-    return _hc_connection_list_internal(s, pdata, false);
-}
-
-static int
-_hc_connection_list_async(hc_sock_t * s, hc_data_t ** pdata)
-{
-    return _hc_connection_list_internal(s, pdata, true);
-}
-
-/* CONNECTION GET */
-
-static int
-_hc_connection_get(hc_sock_t * socket, hc_connection_t * connection,
-        hc_connection_t ** connection_found)
-{
-    hc_data_t * connections;
-    hc_connection_t * found;
-
-    char connection_s[MAXSZ_HC_CONNECTION];
-    int rc = hc_connection_snprintf(connection_s, MAXSZ_HC_CONNECTION, connection);
-    if (rc >= MAXSZ_HC_CONNECTION)
-        WARN("[hc_connection_get] Unexpected truncation of connection string");
-    DEBUG("[hc_connection_get] connection=%s", connection_s);
-
-    if (_hc_connection_list(socket, &connections) < 0)
-        return -1;
-
-    /* Test */
-    if (hc_connection_find(connections, connection, &found) < 0) {
-        hc_data_free(connections);
-        return -1;
-    }
-
-    if (found) {
-        *connection_found = malloc(sizeof(hc_connection_t));
-        if (!*connection_found)
-            return -1;
-        **connection_found = *found;
-    } else {
-        *connection_found = NULL;
-    }
-
-    hc_data_free(connections);
-
-    return 0;
-}
-
-
-/* CONNECTION DELETE */
-
-static int
-_hc_connection_delete_internal(hc_sock_t * socket, hc_connection_t * connection, bool async)
-{
-    char connection_s[MAXSZ_HC_CONNECTION];
-    int rc = hc_connection_snprintf(connection_s, MAXSZ_HC_CONNECTION, connection);
-    if (rc >= MAXSZ_HC_CONNECTION)
-        WARN("[_hc_connection_delete] Unexpected truncation of connection string");
-    DEBUG("[_hc_connection_delete] connection=%s async=%s", connection_s, BOOLSTR(async));
-
-    struct {
-        header_control_message hdr;
-        remove_connection_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = REMOVE_CONNECTION,
-            .length = 1,
-            .seqNum = 0,
-        },
-    };
-
-    if (connection->id) {
-        rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%d", connection->id);
-        if (rc >= SYMBOLIC_NAME_LEN)
-            WARN("[_hc_connection_delete] Unexpected truncation of symbolic name string");
-    } else if (*connection->name) {
-        rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%s", connection->name);
-        if (rc >= SYMBOLIC_NAME_LEN)
-            WARN("[_hc_connection_delete] Unexpected truncation of symbolic name string");
-    } else {
-        hc_connection_t * connection_found;
-        if (_hc_connection_get(socket, connection, &connection_found) < 0)
-            return -1;
-        if (!connection_found)
-            return -1;
-        rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%d", connection_found->id);
-        if (rc >= SYMBOLIC_NAME_LEN)
-            WARN("[_hc_connection_delete] Unexpected truncation of symbolic name string");
-        free(connection_found);
-    }
-
-    hc_command_params_t params = {
-        .cmd = ACTION_DELETE,
-        .cmd_id = REMOVE_CONNECTION,
-        .size_in = sizeof(remove_connection_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_connection_delete(hc_sock_t * s, hc_connection_t * connection)
-{
-    return _hc_connection_delete_internal(s, connection, false);
-}
-
-static int
-_hc_connection_delete_async(hc_sock_t * s, hc_connection_t * connection)
-{
-    return _hc_connection_delete_internal(s, connection, true);
-}
-
-static int
-_hc_connection_update_by_id(hc_sock_t *s, int hc_connection_id,
-                            hc_connection_t *connection)
-{
-    // Not implemented
-    return -1;
-}
-
-static int
-_hc_connection_update(hc_sock_t *s, hc_connection_t *connection_current,
-                      hc_connection_t *connection_updated)
-{
-    // Not implemented
-    return -1;
-}
-
-/* CONNECTION SET ADMIN STATE */
-
-static int
-_hc_connection_set_admin_state_internal(hc_sock_t * socket, const char * conn_id_or_name,
-        face_state_t state, bool async)
-{
-    int rc;
-    DEBUG("[hc_connection_set_admin_state] connection_id/name=%s admin_state=%s async=%s",
-            conn_id_or_name, face_state_str[state], BOOLSTR(async));
-    struct {
-        header_control_message hdr;
-        connection_set_admin_state_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = CONNECTION_SET_ADMIN_STATE,
-            .length = 1,
-            .seqNum = 0,
-        },
-        .payload = {
-            .admin_state = state,
-        },
-    };
-    rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%s", conn_id_or_name);
-    if (rc >= SYMBOLIC_NAME_LEN)
-        WARN("[_hc_connection_set_admin_state] Unexpected truncation of symbolic name string");
-
-    hc_command_params_t params = {
-        .cmd = ACTION_SET,
-        .cmd_id = CONNECTION_SET_ADMIN_STATE,
-        .size_in = sizeof(connection_set_admin_state_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_connection_set_admin_state(hc_sock_t * s, const char * conn_id_or_name,
-        face_state_t state)
-{
-    return _hc_connection_set_admin_state_internal(s, conn_id_or_name, state, false);
-}
-
-static int
-_hc_connection_set_admin_state_async(hc_sock_t * s, const char * conn_id_or_name,
-        face_state_t state)
-{
-    return _hc_connection_set_admin_state_internal(s, conn_id_or_name, state, true);
-}
-
-#ifdef WITH_POLICY
-
-static int
-_hc_connection_set_priority_internal(hc_sock_t * socket, const char * conn_id_or_name,
-        uint32_t priority, bool async)
-{
-    int rc;
-    DEBUG("[hc_connection_set_priority] connection_id/name=%s priority=%d async=%s",
-            conn_id_or_name, priority, BOOLSTR(async));
-    struct {
-        header_control_message hdr;
-        connection_set_priority_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = CONNECTION_SET_PRIORITY,
-            .length = 1,
-            .seqNum = 0,
-        },
-        .payload = {
-            .priority = priority,
-        },
-    };
-    rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%s", conn_id_or_name);
-    if (rc >= SYMBOLIC_NAME_LEN)
-        WARN("[_hc_connection_set_priority] Unexpected truncation of symbolic name string");
-
-    hc_command_params_t params = {
-        .cmd = ACTION_SET,
-        .cmd_id = CONNECTION_SET_PRIORITY,
-        .size_in = sizeof(connection_set_priority_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_connection_set_priority(hc_sock_t * s, const char * conn_id_or_name,
-        uint32_t priority)
-{
-    return _hc_connection_set_priority_internal(s, conn_id_or_name, priority, false);
-}
-
-static int
-_hc_connection_set_priority_async(hc_sock_t * s, const char * conn_id_or_name,
-        uint32_t priority)
-{
-    return _hc_connection_set_priority_internal(s, conn_id_or_name, priority, true);
-}
-
-#endif // WITH_POLICY
-
-static int
-_hc_connection_set_tags_internal(hc_sock_t * s, const char * conn_id_or_name,
-        policy_tags_t tags, bool async)
-{
-    int rc;
-    DEBUG("[hc_connection_set_tags] connection_id/name=%s tags=%d async=%s",
-            conn_id_or_name, tags, BOOLSTR(async));
-    struct {
-        header_control_message hdr;
-        connection_set_tags_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = CONNECTION_SET_TAGS,
-            .length = 1,
-            .seqNum = 0,
-        },
-        .payload = {
-            .tags = tags,
-        },
-    };
-    rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%s", conn_id_or_name);
-    if (rc >= SYMBOLIC_NAME_LEN)
-        WARN("[_hc_connection_set_tags] Unexpected truncation of symbolic name string");
-
-    hc_command_params_t params = {
-        .cmd = ACTION_SET,
-        .cmd_id = CONNECTION_SET_TAGS,
-        .size_in = sizeof(connection_set_tags_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(s, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_connection_set_tags(hc_sock_t * s, const char * conn_id_or_name,
-        policy_tags_t tags)
-{
-    return _hc_connection_set_tags_internal(s, conn_id_or_name, tags, false);
-}
-
-static int
-_hc_connection_set_tags_async(hc_sock_t * s, const char * conn_id_or_name,
-        policy_tags_t tags)
-{
-    return _hc_connection_set_tags_internal(s, conn_id_or_name, tags, true);
-}
-
-/*----------------------------------------------------------------------------*
- * Routes
- *----------------------------------------------------------------------------*/
-
-/* ROUTE CREATE */
-
-static int
-_hc_route_create_internal(hc_sock_t * socket, hc_route_t * route, bool async)
-{
-    char route_s[MAXSZ_HC_ROUTE];
-    int rc = hc_route_snprintf(route_s, MAXSZ_HC_ROUTE, route);
-    if (rc >= MAXSZ_HC_ROUTE)
-        WARN("[_hc_route_create] Unexpected truncation of route string");
-    if (rc < 0)
-        WARN("[_hc_route_create] Error building route string");
-    else
-        DEBUG("[hc_route_create] route=%s async=%s", route_s, BOOLSTR(async));
-
-    if (!IS_VALID_FAMILY(route->family))
-         return -1;
-
-    struct {
-        header_control_message hdr;
-        add_route_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = ADD_ROUTE,
-            .length = 1,
-            .seqNum = 0,
-        },
-        .payload = {
-            .address = route->remote_addr,
-            .cost = route->cost,
-            .addressType = (u8)map_to_addr_type[route->family],
-            .len = route->len,
-        }
-    };
-
-    /*
-     * The route commands expects the ID (or name that we don't use) as part of
-     * the symbolicOrConnid attribute.
-     */
-    rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%d", route->face_id);
-    if (rc >= SYMBOLIC_NAME_LEN)
-        WARN("[_hc_route_create] Unexpected truncation of symbolic name string");
-
-    hc_command_params_t params = {
-        .cmd = ACTION_CREATE,
-        .cmd_id = ADD_ROUTE,
-        .size_in = sizeof(add_route_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_route_create(hc_sock_t * s, hc_route_t * route)
-{
-    return _hc_route_create_internal(s, route, false);
-}
-
-static int
-_hc_route_create_async(hc_sock_t * s, hc_route_t * route)
-{
-    return _hc_route_create_internal(s, route, true);
-}
-
-/* ROUTE DELETE */
-
-static int
-_hc_route_delete_internal(hc_sock_t * socket, hc_route_t * route, bool async)
-{
-    char route_s[MAXSZ_HC_ROUTE];
-    int rc = hc_route_snprintf(route_s, MAXSZ_HC_ROUTE, route);
-    if (rc >= MAXSZ_HC_ROUTE)
-        WARN("[_hc_route_delete] Unexpected truncation of route string");
-    DEBUG("[hc_route_delete] route=%s async=%s", route_s, BOOLSTR(async));
-
-    if (!IS_VALID_FAMILY(route->family))
-         return -1;
-
-    struct {
-        header_control_message hdr;
-        remove_route_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = REMOVE_ROUTE,
-            .length = 1,
-            .seqNum = 0,
-        },
-        .payload = {
-            .address = route->remote_addr,
-            .addressType = (u8)map_to_addr_type[route->family],
-            .len = route->len,
-        }
-    };
-
-    /*
-     * The route commands expects the ID (or name that we don't use) as part of
-     * the symbolicOrConnid attribute.
-     */
-    snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%d", route->face_id);
-
-    hc_command_params_t params = {
-        .cmd = ACTION_DELETE,
-        .cmd_id = REMOVE_ROUTE,
-        .size_in = sizeof(remove_route_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_route_delete(hc_sock_t * s, hc_route_t * route)
-{
-    return _hc_route_delete_internal(s, route, false);
-}
-
-static int
-_hc_route_delete_async(hc_sock_t * s, hc_route_t * route)
-{
-    return _hc_route_delete_internal(s, route, true);
-}
-
-/* ROUTE LIST */
-
-static int
-_hc_route_list_internal(hc_sock_t * socket, hc_data_t ** pdata, bool async)
-{
-    //DEBUG("[hc_route_list] async=%s", BOOLSTR(async));
-
-    struct {
-        header_control_message hdr;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = LIST_ROUTES,
-            .length = 0,
-            .seqNum = 0,
-        },
-    };
-
-    hc_command_params_t params = {
-        .cmd = ACTION_LIST,
-        .cmd_id = LIST_ROUTES,
-        .size_in = sizeof(list_routes_command),
-        .size_out = sizeof(hc_route_t),
-        .parse = (HC_PARSE)hc_route_parse,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, pdata, async);
-}
-
-static int
-_hc_route_list(hc_sock_t * s, hc_data_t ** pdata)
-{
-    return _hc_route_list_internal(s, pdata, false);
-}
-
-static int
-_hc_route_list_async(hc_sock_t * s)
-{
-    return _hc_route_list_internal(s, NULL, true);
-}
-
-/*----------------------------------------------------------------------------*
- * Face
- *
- * Face support is not directly available in hicn-light, but we can offer such
- * an interface through a combination of listeners and connections. The code
- * starts with some conversion functions between faces/listeners/connections.
- *
- * We also need to make sure that there always exist a (single) listener when a
- * connection is created, and in the hICN face case, that there is a single
- * connection attached to this listener.
- *
- *----------------------------------------------------------------------------*/
-
-/* FACE CREATE */
-
-static int
-_hc_face_create(hc_sock_t * socket, hc_face_t * face)
-{
-    hc_listener_t listener;
-    hc_listener_t * listener_found;
-
-    hc_connection_t connection;
-    hc_connection_t * connection_found;
-
-    char face_s[MAXSZ_HC_FACE];
-    int rc = hc_face_snprintf(face_s, MAXSZ_HC_FACE, face);
-    if (rc >= MAXSZ_HC_FACE)
-        WARN("[hc_face_create] Unexpected truncation of face string");
-    DEBUG("[hc_face_create] face=%s", face_s);
-
-    switch(face->face.type)
-    {
-        case FACE_TYPE_HICN:
-        case FACE_TYPE_TCP:
-        case FACE_TYPE_UDP:
-            if (hc_face_to_connection(face, &connection, true) < 0) {
-                ERROR("[hc_face_create] Could not convert face to connection.");
-                return -1;
-            }
-
-            /* Ensure we have a corresponding local listener */
-            if (hc_connection_to_local_listener(&connection, &listener) < 0) {
-                ERROR("[hc_face_create] Could not convert face to local listener.");
-                return -1;
-            }
-
-            if (_hc_listener_get(socket, &listener, &listener_found) < 0) {
-                ERROR("[hc_face_create] Could not retrieve listener");
-                return -1;
-            }
-
-            if (!listener_found) {
-                /* We need to create the listener if it does not exist */
-                if (_hc_listener_create(socket, &listener) < 0) {
-                    ERROR("[hc_face_create] Could not create listener.");
-                    free(listener_found);
-                    return -1;
-                }
-            } else {
-                free(listener_found);
-            }
-
-            /* Create corresponding connection */
-            if (_hc_connection_create(socket, &connection) < 0) {
-                ERROR("[hc_face_create] Could not create connection.");
-                return -1;
-            }
-
-            /*
-             * Once the connection is created, we need to list all connections
-             * and compare with the current one to find the created face ID.
-             */
-            if (_hc_connection_get(socket, &connection, &connection_found) < 0) {
-                ERROR("[hc_face_create] Could not retrieve connection");
-                return -1;
-            }
-
-            if (!connection_found) {
-                ERROR("[hc_face_create] Could not find newly created connection.");
-                return -1;
-            }
-
-            face->id = connection_found->id;
-            free(connection_found);
-
-            break;
-
-        case FACE_TYPE_HICN_LISTENER:
-        case FACE_TYPE_TCP_LISTENER:
-        case FACE_TYPE_UDP_LISTENER:
-            if (hc_face_to_listener(face, &listener) < 0) {
-                ERROR("Could not convert face to listener.");
-                return -1;
-            }
-            if (_hc_listener_create(socket, &listener) < 0) {
-                ERROR("[hc_face_create] Could not create listener.");
-                return -1;
-            }
-            return -1;
-            break;
-        default:
-            ERROR("[hc_face_create] Unknwon face type.");
-
-            return -1;
-    };
-
-    return 0;
-}
-
-static int
-_hc_face_get(hc_sock_t * socket, hc_face_t * face, hc_face_t ** face_found)
-{
-    hc_listener_t listener;
-    hc_listener_t * listener_found;
-
-    hc_connection_t connection;
-    hc_connection_t * connection_found;
-
-    char face_s[MAXSZ_HC_FACE];
-    int rc = hc_face_snprintf(face_s, MAXSZ_HC_FACE, face);
-    if (rc >= MAXSZ_HC_FACE)
-        WARN("[hc_face_get] Unexpected truncation of face string");
-    DEBUG("[hc_face_get] face=%s", face_s);
-
-    switch(face->face.type)
-    {
-        case FACE_TYPE_HICN:
-        case FACE_TYPE_TCP:
-        case FACE_TYPE_UDP:
-            if (hc_face_to_connection(face, &connection, false) < 0)
-                 return -1;
-            if (_hc_connection_get(socket, &connection, &connection_found) < 0)
-                 return -1;
-            if (!connection_found) {
-                *face_found = NULL;
-                return 0;
-            }
-            *face_found = malloc(sizeof(hc_face_t));
-            hc_connection_to_face(connection_found, *face_found);
-            free(connection_found);
-            break;
-
-        case FACE_TYPE_HICN_LISTENER:
-        case FACE_TYPE_TCP_LISTENER:
-        case FACE_TYPE_UDP_LISTENER:
-            if (hc_face_to_listener(face, &listener) < 0)
-                 return -1;
-            if (_hc_listener_get(socket, &listener, &listener_found) < 0)
-                 return -1;
-            if (!listener_found) {
-                *face_found = NULL;
-                return 0;
-            }
-            *face_found = malloc(sizeof(hc_face_t));
-            hc_listener_to_face(listener_found, *face_found);
-            free(listener_found);
-            break;
-
-        default:
-             return -1;
-    }
-
-    return 0;
-
-}
-
-/* FACE DELETE */
-
-static int
-_hc_face_delete(hc_sock_t * socket, hc_face_t * face)
-{
-    char face_s[MAXSZ_HC_FACE];
-    int rc = hc_face_snprintf(face_s, MAXSZ_HC_FACE, face);
-    if (rc >= MAXSZ_HC_FACE)
-        WARN("[hc_face_delete] Unexpected truncation of face string");
-    DEBUG("[hc_face_delete] face=%s", face_s);
-
-    hc_connection_t connection;
-    if (hc_face_to_connection(face, &connection, false) < 0) {
-        ERROR("[hc_face_delete] Could not convert face to connection.");
-        return -1;
-    }
-
-    if (_hc_connection_delete(socket, &connection) < 0) {
-        ERROR("[hc_face_delete] Error removing connection");
-        return -1;
-    }
-
-    /* If this is the last connection attached to the listener, remove it */
-
-    hc_data_t * connections;
-    hc_listener_t listener = {{0}};
-
-    /*
-     * Ensure we have a corresponding local listener
-     * NOTE: hc_face_to_listener is not appropriate
-     */
-    if (hc_connection_to_local_listener(&connection, &listener) < 0) {
-        ERROR("[hc_face_create] Could not convert face to local listener.");
-        return -1;
-    }
-#if 1
-    /*
-     * The name is generated to prepare listener creation, we need it to be
-     * empty for deletion. The id should not need to be reset though.
-     */
-    listener.id = 0;
-    memset(listener.name, 0, sizeof(listener.name));
-#endif
-    if (_hc_connection_list(socket, &connections) < 0) {
-        ERROR("[hc_face_delete] Error getting the list of listeners");
-        return -1;
-    }
-
-    bool delete = true;
-    foreach_connection(c, connections) {
-        if ((ip_address_cmp(&c->local_addr, &listener.local_addr, c->family) == 0) &&
-            (c->local_port == listener.local_port) &&
-                (strcmp(c->interface_name, listener.interface_name) == 0)) {
-            delete = false;
-        }
-    }
-
-    if (delete) {
-        if (_hc_listener_delete(socket, &listener) < 0) {
-            ERROR("[hc_face_delete] Error removing listener");
-            return -1;
-        }
-    }
-
-    hc_data_free(connections);
-
-    return 0;
-
-
-}
-
-/* FACE LIST */
-
-static int
-_hc_face_list(hc_sock_t * socket, hc_data_t ** pdata)
-{
-    hc_data_t * connection_data;
-    hc_face_t face;
-
-    //DEBUG("[hc_face_list]");
-
-    if (_hc_connection_list(socket, &connection_data) < 0) {
-        ERROR("[hc_face_list] Could not list connections.");
-        return -1;
-    }
-
-    hc_data_t * face_data = hc_data_create(sizeof(hc_connection_t), sizeof(hc_face_t), NULL);
-    foreach_connection(c, connection_data) {
-        if (hc_connection_to_face(c, &face) < 0) {
-            ERROR("[hc_face_list] Could not convert connection to face.");
-            goto ERR;
-        }
-        hc_data_push(face_data, &face);
-    }
-
-    *pdata = face_data;
-    hc_data_free(connection_data);
-    return 0;
-
-ERR:
-    hc_data_free(connection_data);
-    return -1;
-}
-
-static int
-_hc_face_list_async(hc_sock_t * socket)
-{
-    struct {
-        header_control_message hdr;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = LIST_CONNECTIONS,
-            .length = 0,
-            .seqNum = 0,
-        },
-    };
-
-    hc_command_params_t params = {
-        .cmd = ACTION_LIST,
-        .cmd_id = LIST_CONNECTIONS,
-        .size_in = sizeof(list_connections_command),
-        .size_out = sizeof(hc_face_t),
-        .parse = (HC_PARSE)hc_connection_parse_to_face,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, true);
-}
-
-static int
-_hc_face_set_admin_state(hc_sock_t * s, const char * conn_id_or_name,
-        face_state_t admin_state)
-{
-    return hc_connection_set_admin_state(s, conn_id_or_name, admin_state);
-}
-
-#ifdef WITH_POLICY
-static int
-_hc_face_set_priority(hc_sock_t * s, const char * conn_id_or_name,
-        uint32_t priority)
-{
-    return hc_connection_set_priority(s, conn_id_or_name, priority);
-}
-
-static int
-_hc_face_set_tags(hc_sock_t * s, const char * conn_id_or_name,
-        policy_tags_t tags)
-{
-    return hc_connection_set_tags(s, conn_id_or_name, tags);
-}
-#endif // WITH_POLICY
-
-/*----------------------------------------------------------------------------*
- * Punting
- *----------------------------------------------------------------------------*/
-
-static int
-_hc_punting_create_internal(hc_sock_t * socket, hc_punting_t * punting, bool async)
-{
-    int rc;
-
-    if (hc_punting_validate(punting) < 0)
-        return -1;
-
-    struct {
-        header_control_message hdr;
-        add_punting_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = ADD_PUNTING,
-            .length = 1,
-            .seqNum = 0,
-        },
-        .payload = {
-            .address = punting->prefix,
-            .addressType = (u8)map_to_addr_type[punting->family],
-            .len = punting->prefix_len,
-        }
-    };
-    rc = snprintf(msg.payload.symbolicOrConnid, SYMBOLIC_NAME_LEN, "%d", punting->face_id);
-    if (rc >= SYMBOLIC_NAME_LEN)
-        WARN("[_hc_punting_create] Unexpected truncation of symbolic name string");
-
-    hc_command_params_t params = {
-        .cmd = ACTION_CREATE,
-        .cmd_id = ADD_PUNTING,
-        .size_in = sizeof(add_punting_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_punting_create(hc_sock_t * s, hc_punting_t * punting)
-{
-    return _hc_punting_create_internal(s, punting, false);
-}
-
-static int
-_hc_punting_create_async(hc_sock_t * s, hc_punting_t * punting)
-{
-    return _hc_punting_create_internal(s, punting, true);
-}
-
-static int
-_hc_punting_get(hc_sock_t * s, hc_punting_t * punting, hc_punting_t ** punting_found)
-{
-    ERROR("hc_punting_get not (yet) implemented.");
-    return -1;
-}
-
-static int
-_hc_punting_delete(hc_sock_t * s, hc_punting_t * punting)
-{
-    ERROR("hc_punting_delete not (yet) implemented.");
-    return -1;
-}
-
-static int
-_hc_punting_list(hc_sock_t * s, hc_data_t ** pdata)
-{
-    ERROR("hc_punting_list not (yet) implemented.");
-    return -1;
-}
-
-
-/*----------------------------------------------------------------------------*
- * Cache
- *----------------------------------------------------------------------------*/
-
-static int
-_hc_cache_set_store_internal(hc_sock_t * socket, int enabled, bool async)
-{
-    struct {
-        header_control_message hdr;
-        cache_store_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = CACHE_STORE,
-            .length = 1,
-            .seqNum = 0,
-        },
-        .payload = {
-            .activate = enabled,
-        }
-    };
-
-    hc_command_params_t params = {
-        .cmd = ACTION_SET,
-        .cmd_id = CACHE_STORE,
-        .size_in = sizeof(cache_store_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_cache_set_store(hc_sock_t * s, int enabled)
-{
-    return _hc_cache_set_store_internal(s, enabled, false);
-}
-
-static int
-_hc_cache_set_store_async(hc_sock_t * s, int enabled)
-{
-    return _hc_cache_set_store_internal(s, enabled, true);
-}
-
-static int
-_hc_cache_set_serve_internal(hc_sock_t * socket, int enabled, bool async)
-{
-    struct {
-        header_control_message hdr;
-        cache_serve_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = CACHE_SERVE,
-            .length = 1,
-            .seqNum = 0,
-        },
-        .payload = {
-            .activate = enabled,
-        }
-    };
-
-    hc_command_params_t params = {
-        .cmd = ACTION_SET,
-        .cmd_id = CACHE_SERVE,
-        .size_in = sizeof(cache_serve_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_cache_set_serve(hc_sock_t * s, int enabled)
-{
-    return _hc_cache_set_serve_internal(s, enabled, false);
-}
-
-static int
-_hc_cache_set_serve_async(hc_sock_t * s, int enabled)
-{
-    return _hc_cache_set_serve_internal(s, enabled, true);
-}
-
-/*----------------------------------------------------------------------------*
- * Strategy
- *----------------------------------------------------------------------------*/
-
-// per prefix
-static int
-_hc_strategy_set(hc_sock_t * s /* XXX */)
-{
-     return 0;
-}
-
-/* How to retrieve that from the forwarder ? */
-static const char * strategies[] = {
-    "random",
-    "load_balancer",
-};
-
-#define ARRAY_SIZE(array) (sizeof(array) / sizeof(*array))
-
-static int
-_hc_strategy_list(hc_sock_t * s, hc_data_t ** data)
-{
-    int rc;
-
-    *data = hc_data_create(0, sizeof(hc_strategy_t), NULL);
-
-    for (unsigned i = 0; i < ARRAY_SIZE(strategies); i++) {
-        hc_strategy_t * strategy = (hc_strategy_t*)hc_data_get_next(*data);
-        if (!strategy)
-             return -1;
-        rc = snprintf(strategy->name, MAXSZ_HC_STRATEGY, "%s", strategies[i]);
-        if (rc >= MAXSZ_HC_STRATEGY)
-            WARN("[hc_strategy_list] Unexpected truncation of strategy name string");
-        (*data)->size++;
-    }
-
-    return 0;
-}
-
-/*----------------------------------------------------------------------------*
- * WLDR
- *----------------------------------------------------------------------------*/
-
-// per connection
-static int
-_hc_wldr_set(hc_sock_t * s /* XXX */)
-{
-     return 0;
-}
-
-/*----------------------------------------------------------------------------*
- * MAP-Me
- *----------------------------------------------------------------------------*/
-
-static int
-_hc_mapme_set(hc_sock_t * s, int enabled)
-{
-     return 0;
-}
-
-static int
-_hc_mapme_set_discovery(hc_sock_t * s, int enabled)
-{
-     return 0;
-}
-
-static int
-_hc_mapme_set_timescale(hc_sock_t * s, double timescale)
-{
-     return 0;
-}
-
-static int
-_hc_mapme_set_retx(hc_sock_t * s, double timescale)
-{
-     return 0;
-}
-
-/*----------------------------------------------------------------------------*
- * Policy
- *----------------------------------------------------------------------------*/
-
-#ifdef WITH_POLICY
-
-/* POLICY CREATE */
-
-static int
-_hc_policy_create_internal(hc_sock_t * socket, hc_policy_t * policy, bool async)
-{
-    if (!IS_VALID_FAMILY(policy->family))
-         return -1;
-
-    struct {
-        header_control_message hdr;
-        add_policy_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = ADD_POLICY,
-            .length = 1,
-            .seqNum = 0,
-        },
-        .payload = {
-            .address = policy->remote_addr,
-            .addressType = (u8)map_to_addr_type[policy->family],
-            .len = policy->len,
-            .policy = policy->policy,
-        }
-    };
-
-    hc_command_params_t params = {
-        .cmd = ACTION_CREATE,
-        .cmd_id = ADD_POLICY,
-        .size_in = sizeof(add_policy_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_policy_create(hc_sock_t * s, hc_policy_t * policy)
-{
-    return _hc_policy_create_internal(s, policy, false);
-}
-
-static int
-_hc_policy_create_async(hc_sock_t * s, hc_policy_t * policy)
-{
-    return _hc_policy_create_internal(s, policy, true);
-}
-
-/* POLICY DELETE */
-
-static int
-_hc_policy_delete_internal(hc_sock_t * socket, hc_policy_t * policy, bool async)
-{
-    if (!IS_VALID_FAMILY(policy->family))
-         return -1;
-
-    struct {
-        header_control_message hdr;
-        remove_policy_command payload;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = REMOVE_POLICY,
-            .length = 1,
-            .seqNum = 0,
-        },
-        .payload = {
-            .address = policy->remote_addr,
-            .addressType = (u8)map_to_addr_type[policy->family],
-            .len = policy->len,
-        }
-    };
-
-    hc_command_params_t params = {
-        .cmd = ACTION_DELETE,
-        .cmd_id = REMOVE_POLICY,
-        .size_in = sizeof(remove_policy_command),
-        .size_out = 0,
-        .parse = NULL,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, NULL, async);
-}
-
-static int
-_hc_policy_delete(hc_sock_t * s, hc_policy_t * policy)
-{
-    return _hc_policy_delete_internal(s, policy, false);
-}
-
-static int
-_hc_policy_delete_async(hc_sock_t * s, hc_policy_t * policy)
-{
-    return _hc_policy_delete_internal(s, policy, true);
-}
-
-/* POLICY LIST */
-
-static int
-_hc_policy_list_internal(hc_sock_t * socket, hc_data_t ** pdata, bool async)
-{
-    struct {
-        header_control_message hdr;
-    } msg = {
-        .hdr = {
-            .messageType = REQUEST_LIGHT,
-            .commandID = LIST_POLICIES,
-            .length = 0,
-            .seqNum = 0,
-        },
-    };
-
-    hc_command_params_t params = {
-        .cmd = ACTION_LIST,
-        .cmd_id = LIST_POLICIES,
-        .size_in = sizeof(list_policies_command),
-        .size_out = sizeof(hc_policy_t),
-        .parse = (HC_PARSE)hc_policy_parse,
-    };
-
-    return _hc_execute_command(socket, (hc_msg_t*)&msg, sizeof(msg), &params, pdata, async);
-}
-
-static int
-_hc_policy_list(hc_sock_t * s, hc_data_t ** pdata)
-{
-    return _hc_policy_list_internal(s, pdata, false);
-}
-
-static int
-_hc_policy_list_async(hc_sock_t * s, hc_data_t ** pdata)
-{
-    return _hc_policy_list_internal(s, pdata, true);
-}
-
-#endif /* WITH_POLICY */
-
-static hc_sock_t hc_sock_light_interface = (hc_sock_t) {
-    .hc_sock_get_next_seq = _hc_sock_light_get_next_seq,
-    .hc_sock_set_nonblocking = _hc_sock_light_set_nonblocking,
-    .hc_sock_get_fd = _hc_sock_light_get_fd,
-    .hc_sock_connect = _hc_sock_light_connect,
-    .hc_sock_get_available = _hc_sock_light_get_available,
-    .hc_sock_send = _hc_sock_light_send,
-    .hc_sock_recv = _hc_sock_light_recv,
-    .hc_sock_process = _hc_sock_light_process,
-    .hc_sock_callback = _hc_sock_light_callback,
-    .hc_sock_reset = _hc_sock_light_reset,
-    .hc_sock_free = _hc_sock_light_free,
-    .hc_listener_create = _hc_listener_create,
-    .hc_listener_create_async = _hc_listener_create_async,
-    .hc_listener_get = _hc_listener_get,
-    .hc_listener_delete = _hc_listener_delete,
-    .hc_listener_delete_async = _hc_listener_delete_async,
-    .hc_listener_list = _hc_listener_list,
-    .hc_listener_list_async = _hc_listener_list_async,
-    .hc_connection_create = _hc_connection_create,
-    .hc_connection_create_async = _hc_connection_create_async,
-    .hc_connection_get = _hc_connection_get,
-    .hc_connection_update_by_id = _hc_connection_update_by_id,
-    .hc_connection_update = _hc_connection_update,
-    .hc_connection_delete = _hc_connection_delete,
-    .hc_connection_delete_async = _hc_connection_delete_async,
-    .hc_connection_list = _hc_connection_list,
-    .hc_connection_list_async = _hc_connection_list_async,
-    .hc_connection_set_admin_state = _hc_connection_set_admin_state,
-    .hc_connection_set_admin_state_async = _hc_connection_set_admin_state_async,
-
-#ifdef WITH_POLICY
-    .hc_connection_set_priority = _hc_connection_set_priority,
-    .hc_connection_set_priority_async = _hc_connection_set_priority_async,
-    .hc_connection_set_tags = _hc_connection_set_tags,
-    .hc_connection_set_tags_async = _hc_connection_set_tags_async,
-#endif // WITH_POLICY
-
-    .hc_face_create = _hc_face_create,
-    .hc_face_get = _hc_face_get,
-    .hc_face_delete = _hc_face_delete,
-    .hc_face_list = _hc_face_list,
-    .hc_face_list_async = _hc_face_list_async,
-    .hc_face_set_admin_state = _hc_face_set_admin_state,
-
-#ifdef WITH_POLICY
-    .hc_face_set_priority = _hc_face_set_priority,
-    .hc_face_set_tags = _hc_face_set_tags,
-#endif // WITH_POLICY
-
-    .hc_route_create = _hc_route_create,
-    .hc_route_create_async = _hc_route_create_async,
-    .hc_route_delete = _hc_route_delete,
-    .hc_route_delete_async = _hc_route_delete_async,
-    .hc_route_list = _hc_route_list,
-    .hc_route_list_async = _hc_route_list_async,
-
-    .hc_punting_create = _hc_punting_create,
-    .hc_punting_create_async = _hc_punting_create_async,
-    .hc_punting_get = _hc_punting_get,
-    .hc_punting_delete = _hc_punting_delete,
-    .hc_punting_list = _hc_punting_list,
-
-    .hc_cache_set_store = _hc_cache_set_store,
-    .hc_cache_set_store_async = _hc_cache_set_store_async,
-    .hc_cache_set_serve = _hc_cache_set_serve,
-    .hc_cache_set_serve_async = _hc_cache_set_serve_async,
-
-    .hc_strategy_list = _hc_strategy_list,
-    .hc_strategy_set = _hc_strategy_set,
-    .hc_wldr_set = _hc_wldr_set,
-
-    .hc_mapme_set = _hc_mapme_set,
-    .hc_mapme_set_discovery = _hc_mapme_set_discovery,
-    .hc_mapme_set_timescale = _hc_mapme_set_timescale,
-    .hc_mapme_set_retx = _hc_mapme_set_retx,
-
-#ifdef WITH_POLICY
-    .hc_policy_create = _hc_policy_create,
-    .hc_policy_create_async = _hc_policy_create_async,
-    .hc_policy_delete = _hc_policy_delete,
-    .hc_policy_delete_async = _hc_policy_delete_async,
-    .hc_policy_list = _hc_policy_list,
-    .hc_policy_list_async = _hc_policy_list_async
-#endif // WITH_POLICY
-};
-
-// Public contructors
-
-hc_sock_t *
-_hc_sock_create_url(const char * url)
-{
-    hc_sock_light_t * s = malloc(sizeof(hc_sock_light_t));
-    if (!s)
-        goto ERR_MALLOC;
-
-    s->vft = hc_sock_light_interface;
-    s->url = url ? strdup(url) : NULL;
-
-    s->fd = socket(AF_INET, SOCK_STREAM, 0);
-    if (s->fd < 0)
-        goto ERR_SOCKET;
-
-    if (_hc_sock_light_reset((hc_sock_t*)s) < 0)
-        goto ERR_RESET;
-
-    s->seq = 0;
-    s->cur_request = NULL;
-
-    s->map = hc_sock_map_create();
-    if (!s->map)
-        goto ERR_MAP;
-
-    return (hc_sock_t*)(s);
-
-    //hc_sock_light_map_free(s->map);
-ERR_MAP:
-ERR_RESET:
-    if (s->url)
-        free(s->url);
-    close(s->fd);
-ERR_SOCKET:
-    free(s);
-ERR_MALLOC:
-    return NULL;
-}
-
-hc_sock_t *
-_hc_sock_create(void)
-{
-    return _hc_sock_create_url(NULL);
-}
diff --git a/ctrl/libhicnctrl/src/modules/hicn_light_common.c b/ctrl/libhicnctrl/src/modules/hicn_light_common.c
new file mode 100644
index 000000000..bc04404bf
--- /dev/null
+++ b/ctrl/libhicnctrl/src/modules/hicn_light_common.c
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "hicn_light_common.h"
+
+TYPEDEF_MAP(hc_sock_map, int, hc_sock_request_t *, int_cmp, int_snprintf,
+            generic_snprintf);
+
+hc_sock_request_t *hc_sock_request_create(int seq, hc_data_t *data,
+                                          HC_PARSE parse) {
+  assert(data);
+
+  hc_sock_request_t *request = malloc(sizeof(hc_sock_request_t));
+  if (!request) return NULL;
+  request->seq = seq;
+  request->data = data;
+  request->parse = parse;
+  return request;
+}
+
+void hc_sock_light_request_free(hc_sock_request_t *request) { free(request); }
diff --git a/ctrl/libhicnctrl/src/modules/hicn_light_common.h b/ctrl/libhicnctrl/src/modules/hicn_light_common.h
new file mode 100644
index 000000000..4749474c8
--- /dev/null
+++ b/ctrl/libhicnctrl/src/modules/hicn_light_common.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef HICNCTRL_HICN_LIGHT_COMMON
+#define HICNCTRL_HICN_LIGHT_COMMON
+
+#include <assert.h>  // assert
+
+#include "api_private.h"
+
+#define PORT 9695
+
+#define BOOLSTR(x) ((x) ? "true" : "false")
+
+/*
+ * Internal state associated to a pending request
+ */
+typedef struct {
+  int seq;
+  hc_data_t *data;
+  int (*parse)(const u8 *src, u8 *dst);
+} hc_sock_request_t;
+
+/**
+ * Messages to the forwarder might be multiplexed thanks to the seqNum fields in
+ * the header_control_message structure. The forwarder simply answers back the
+ * original sequence number. We maintain a map of such sequence number to
+ * outgoing queries so that replied can be demultiplexed and treated
+ * appropriately.
+ */
+TYPEDEF_MAP_H(hc_sock_map, int, hc_sock_request_t *);
+
+struct hc_sock_light_s {
+  /* This must be the first element of the struct */
+  hc_sock_t vft;
+
+  char *url;
+  int fd;
+
+  /* Partial receive buffer */
+  u8 buf[RECV_BUFLEN];
+  size_t roff; /**< Read offset */
+  size_t woff; /**< Write offset */
+
+  /*
+   * Because received messages are potentially unbounded in size, we might not
+   * guarantee that we can store a full packet before processing it. We must
+   * implement a very simple state machine remembering the current parsing
+   * status in order to partially process the packet.
+   */
+  size_t remaining;
+  u32 send_id;
+
+  /* Next sequence number to be used for requests */
+  int seq;
+
+  /* Request being parsed (NULL if none) */
+  hc_sock_request_t *cur_request;
+
+  bool async;
+  hc_sock_map_t *map;
+};
+
+typedef struct hc_sock_light_s hc_sock_light_t;
+
+#define TO_HC_SOCK_LIGHT(s) (hc_sock_light_t *)(s)
+
+hc_sock_request_t *hc_sock_request_create(int seq, hc_data_t *data,
+                                          HC_PARSE parse);
+
+void hc_sock_light_request_free(hc_sock_request_t *request);
+
+/*
+ * list was working with all seq set to 0, but it seems hicnLightControl uses
+ * 1, and replies with the same seqno
+ */
+#define HICN_CTRL_SEND_SEQ_INIT 1
+#define HICN_CTRL_RECV_SEQ_INIT 1
+
+#define MAX(x, y) ((x > y) ? x : y)
+
+static const struct in6_addr loopback_addr = IN6ADDR_LOOPBACK_INIT;
+
+#endif /* HICNCTRL_HICN_LIGHT_COMMON */
diff --git a/ctrl/libhicnctrl/src/modules/hicn_light_ng_api.c b/ctrl/libhicnctrl/src/modules/hicn_light_ng_api.c
new file mode 100644
index 000000000..a58ee909e
--- /dev/null
+++ b/ctrl/libhicnctrl/src/modules/hicn_light_ng_api.c
@@ -0,0 +1,3111 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file api.c
+ * \brief Implementation of hICN control library API
+ */
+
+#include <assert.h>  // assert
+#include <fcntl.h>   // fcntl
+#include <stdbool.h>
+#include <stdio.h>       // snprintf
+#include <string.h>      // memmove, strcasecmp
+#include <sys/socket.h>  // socket
+#include <sys/types.h>   // getpid
+#include <unistd.h>      // close, fcntl
+#include <unistd.h>      // getpid
+
+#include "api_private.h"
+#ifdef __linux__
+#include <sys/syscall.h>
+#define gettid() syscall(SYS_gettid)
+#endif /* __linux__ */
+#include <hicn/ctrl/hicn-light-ng.h>
+#include <strings.h>
+
+#include "hicn_light_common.h"
+#include <hicn/util/sstrncpy.h>
+
+#pragma GCC diagnostic ignored "-Warray-bounds"
+
+#if 0
+#ifdef __APPLE__
+#define RANDBYTE() (u8)(arc4random() & 0xFF)
+#else
+#define RANDBYTE() (u8)(random() & 0xFF)
+#endif
+#endif
+#define RANDBYTE() (u8)(rand() & 0xFF)
+
+/**
+ * \brief Defines the default size for the allocated data arrays holding the
+ * results of API calls.
+ *
+ * This size should not be too small to avoid wasting memoyy, but also not too
+ * big to avoid unnecessary realloc's. Later on this size is doubled at each
+ * reallocation.
+ */
+#define DEFAULT_SIZE_LOG 3
+
+#define connection_state_to_face_state(x) ((face_state_t)(x))
+#define face_state_to_connection_state(x) ((hc_connection_state_t)(x))
+
+/******************************************************************************
+ * Message helper types and aliases
+ ******************************************************************************/
+
+#define foreach_hc_command     \
+  _(connection_add)            \
+  _(connection_remove)         \
+  _(connection_list)           \
+  _(listener_add)              \
+  _(listener_remove)           \
+  _(listener_list)             \
+  _(route_add)                 \
+  _(route_remove)              \
+  _(route_list)                \
+  _(cache_set_store)           \
+  _(cache_set_serve)           \
+  _(cache_clear)               \
+  _(cache_list)                \
+  _(strategy_set)              \
+  _(strategy_add_local_prefix) \
+  _(wldr_set)                  \
+  _(punting_add)               \
+  _(mapme_activator)           \
+  _(mapme_timing)              \
+  _(subscription_add)          \
+  _(subscription_remove)
+
+const char *command_type_str[] = {
+#define _(l, u) [COMMAND_TYPE_##u] = STRINGIZE(u),
+    foreach_command_type
+#undef _
+};
+
+typedef cmd_header_t hc_msg_header_t;
+
+typedef union {
+#define _(x) cmd_##x##_t x;
+  foreach_hc_command
+#undef _
+} hc_msg_payload_t;
+
+typedef struct hc_msg_s {
+  hc_msg_header_t hdr;
+  hc_msg_payload_t payload;
+} hc_msg_t;
+
+/******************************************************************************
+ * Control socket
+ ******************************************************************************/
+
+#define AVAILABLE(s) ((s)->woff - (s)->roff)
+#define DEFAULT_SOCK_RECV_TIMEOUT_MS 100
+
+/**
+ * \brief Parse a connection URL into a sockaddr
+ * \param [in] url - URL
+ * \param [out] sa - Resulting struct sockaddr, expected zero'ed.
+ * \return 0 if parsing succeeded, a negative error value otherwise.
+ */
+static int _hcng_sock_light_parse_url(const char *url, struct sockaddr *sa) {
+  /* FIXME URL parsing is currently not implemented */
+  assert(!url);
+
+#ifdef __linux__
+  srand(time(NULL) ^ getpid() ^ gettid());
+#else
+  srand((unsigned int)(time(NULL) ^ getpid()));
+#endif /* __linux__ */
+
+  /*
+   * A temporary solution is to inspect the sa_family fields of the passed in
+   * sockaddr, which defaults to AF_UNSPEC (0) and thus creates an IPv4/TCP
+   * connection to localhost.
+   */
+  switch (sa->sa_family) {
+    case AF_UNSPEC:
+    case AF_INET: {
+      struct sockaddr_in *sai = (struct sockaddr_in *)sa;
+      sai->sin_family = AF_INET;
+      sai->sin_port = htons(PORT);
+      sai->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+      break;
+    }
+    case AF_INET6: {
+      struct sockaddr_in6 *sai6 = (struct sockaddr_in6 *)sa;
+      sai6->sin6_family = AF_INET6;
+      sai6->sin6_port = htons(PORT);
+      sai6->sin6_addr = loopback_addr;
+      break;
+    }
+    default:
+      return -1;
+  }
+
+  return 0;
+}
+
+static int _hcng_sock_light_reset(hc_sock_t *socket) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+  s->roff = s->woff = 0;
+  s->remaining = 0;
+  return 0;
+}
+
+void _hcng_sock_light_free(hc_sock_t *socket) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+  hc_sock_request_t **request_array = NULL;
+  int n = hc_sock_map_get_value_array(s->map, &request_array);
+  if (n < 0) {
+    ERROR("Could not retrieve pending request array for freeing up resources");
+  } else {
+    for (unsigned i = 0; i < n; i++) {
+      hc_sock_request_t *request = request_array[i];
+      if (hc_sock_map_remove(s->map, request->seq, NULL) < 0)
+        ERROR("[hc_sock_light_process] Error removing request from map");
+      hc_sock_light_request_free(request);
+    }
+    free(request_array);
+  }
+
+  hc_sock_map_free(s->map);
+  if (s->url) free(s->url);
+  close(s->fd);
+  free(s);
+}
+
+static void _hcng_sock_increment_woff(hc_sock_t *socket, size_t bytes) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+  s->woff += bytes;
+}
+
+static int _hcng_sock_light_get_next_seq(hc_sock_t *socket) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+  return s->seq++;
+}
+
+static int _hcng_sock_light_set_nonblocking(hc_sock_t *socket) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+  return (fcntl(s->fd, F_SETFL, fcntl(s->fd, F_GETFL) | O_NONBLOCK) < 0);
+}
+
+static int _hcng_sock_light_get_fd(hc_sock_t *socket) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+  return s->fd;
+}
+
+static int _hcng_sock_light_connect(hc_sock_t *socket) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+  struct sockaddr_storage ss;
+  memset(&ss, 0, sizeof(struct sockaddr_storage));
+
+  if (_hcng_sock_light_parse_url(s->url, (struct sockaddr *)&ss) < 0)
+    goto ERR_PARSE;
+
+  size_t size = ss.ss_family == AF_INET ? sizeof(struct sockaddr_in)
+                                        : sizeof(struct sockaddr_in6);
+  if (connect(s->fd, (struct sockaddr *)&ss, (socklen_t)size) < 0) {
+    perror("connect error");
+    goto ERR_CONNECT;
+  }
+  return 0;
+
+ERR_CONNECT:
+ERR_PARSE:
+  return -1;
+}
+
+static int _hcng_sock_light_send(hc_sock_t *socket, hc_msg_t *msg,
+                                 size_t msglen, uint32_t seq) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+  int rc;
+  msg->hdr.seq_num = seq;
+  rc = (int)send(s->fd, msg, msglen, 0);
+  if (rc < 0) {
+    perror("hc_sock_light_send");
+    return -1;
+  }
+  return 0;
+}
+
+static int _hcng_sock_light_get_available(hc_sock_t *socket, u8 **buffer,
+                                          size_t *size) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+  *buffer = s->buf + s->woff;
+  *size = RECV_BUFLEN - s->woff;
+
+  return 0;
+}
+
+static int _hcng_sock_light_recv(hc_sock_t *socket) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+  int rc;
+
+  /*
+   * This condition should be ensured to guarantee correct processing of
+   * messages. With TCP, we need at least a header as we will receive part of
+   * the stream. With UDP, we need the be able to receive the full datagram,
+   * otherwise the rest will be lost.
+   *
+   * Let's be sure to always be able to receive at least 1 JUMBO_MTU, which
+   * should be fine for al situations.
+   */
+  assert(RECV_BUFLEN - s->woff > JUMBO_MTU);
+
+  rc = (int)recv(s->fd, s->buf + s->woff, RECV_BUFLEN - s->woff, 0);
+  if (rc == 0) {
+    /* Connection has been closed */
+    return 0;
+  }
+  if (rc < 0) {
+    /*
+     * Let's not return 0 which currently means the socket has been closed
+     */
+    if (errno == EWOULDBLOCK) return -1;
+    if (errno == EINTR) {
+      WARN("recv has been stopped by signal");
+      return -1;
+    }
+    perror("hc_sock_light_recv");
+    return -1;
+  }
+  s->woff += rc;
+  return rc;
+}
+
+static void _hcng_sock_light_mark_complete(hc_sock_light_t *s,
+                                           hc_data_t **pdata) {
+  hc_data_t *data = s->cur_request->data;
+
+  if (hc_sock_map_remove(s->map, s->cur_request->seq, NULL) < 0) {
+    ERROR("[hc_sock_light_mark_complete] Error removing request from map");
+  }
+  hc_data_set_complete(data);
+  if (pdata) *pdata = data;
+
+  /* Free current request */
+  hc_sock_light_request_free(s->cur_request);
+  s->cur_request = NULL;
+}
+
+static int _hcng_sock_light_process_notification(hc_sock_light_t *s,
+                                                 hc_data_t **pdata) {
+  /* For now, notifications are not associated to requests */
+  assert(!s->cur_request);
+
+  /*
+   * Assumption: the whole notification data is returned in a single read and we
+   * immediately parse it.
+   *
+   * XXX This is only valid for UDP sockets.
+   */
+  size_t notification_size = AVAILABLE(s);
+
+  *pdata = hc_data_create(0, /* in_element_size, 0 = no parsing */
+                          notification_size, /* out_element_size */
+                          NULL);             /* complete_cb */
+
+  /* Copy the packet payload as the single entry in hc_data_t */
+  hc_data_push_many(*pdata, s->buf + s->roff, 1);
+
+  return notification_size;
+}
+
+/*
+ * Notifications have no sequence number and are not linked to any request
+ */
+static hc_sock_request_t *_hcng_sock_light_get_request(hc_sock_light_t *s,
+                                                       int seq) {
+  hc_sock_request_t *request;
+  /* Retrieve request from sock map */
+  if (hc_sock_map_get(s->map, seq, &request) < 0) {
+    ERROR("[hc_sock_light_process] Error searching for matching request");
+    return NULL;
+  }
+  if (!request) {
+    ERROR("[hc_sock_light_process] No request matching sequence number");
+    return NULL;
+  }
+  return request;
+}
+
+/*
+ * Return codes:
+ * 0 success, or not enough data yet to do something
+ * > 0 : notification type
+ * -99 invalid buffer data -> flush
+ */
+static int _hcng_sock_light_process_header(hc_sock_light_t *s,
+                                           hc_data_t **pdata) {
+  int rc;
+
+  /* Check we have at least a header's worth of data, and consume it */
+  if (AVAILABLE(s) < sizeof(hc_msg_header_t)) return 0;
+
+  hc_msg_t *msg = (hc_msg_t *)(s->buf + s->roff);
+
+  // INFO("Processing header header %s", command_type_str(msg->hdr.command_id));
+  s->roff += sizeof(hc_msg_header_t);
+
+  if (msg->hdr.message_type != NOTIFICATION_LIGHT) {
+    s->cur_request = _hcng_sock_light_get_request(s, msg->hdr.seq_num);
+    if (!s->cur_request) return -99;
+  }
+
+  /* How many elements are we expecting in the reply ? */
+  s->remaining = msg->hdr.length;
+  hc_data_t *request_data;
+
+  switch (msg->hdr.message_type) {
+    case ACK_LIGHT:
+      assert(s->remaining == 1);  // sic
+      assert(!pdata);
+      _hcng_sock_light_mark_complete(s, pdata);
+      break;
+
+    case NACK_LIGHT:
+      assert(!pdata);
+      assert(s->remaining == 1);  // sic
+      request_data = s->cur_request->data;
+      _hcng_sock_light_mark_complete(s, pdata);
+      hc_data_set_error(request_data);
+      break;
+
+    case RESPONSE_LIGHT:
+      assert(pdata);
+
+      if (s->remaining == 0) {
+        /* Empty response (i.e. containing 0 elements) */
+        _hcng_sock_light_mark_complete(s, pdata);
+        return 0;
+      }
+
+      /* Make room in hc_data_t... to avoid multiple calls */
+      rc = hc_data_ensure_available(s->cur_request->data, s->remaining);
+      if (rc < 0) {
+        ERROR("[hc_sock_light_process] Error in hc_data_ensure_available");
+        return -99;
+      }
+      break;
+
+    case NOTIFICATION_LIGHT: {
+      assert(pdata);
+      assert(s->remaining == 0);
+
+      /* This returns the notification size */
+      size_t notification_size =
+          _hcng_sock_light_process_notification(s, pdata);
+      s->roff += notification_size;
+      return msg->hdr.command_id;
+    }
+
+    default:
+      ERROR("[hc_sock_light_process] Invalid response received");
+      return -99;
+  }
+
+  return 0;
+}
+
+static int _hcng_sock_light_process_payload(hc_sock_light_t *s,
+                                            hc_data_t **pdata) {
+  int err = 0;
+  int rc;
+
+  hc_data_t *data = s->cur_request->data;
+
+  /* We only process full elements (size is stored in data) */
+  size_t num_chunks = AVAILABLE(s) / data->in_element_size;
+
+  /* Check whether we have enough data to process */
+  if (num_chunks == 0) return 0;
+
+  /* Safeguard: assert(num_chunks < s->remaining); */
+  if (num_chunks > s->remaining) {
+    WARN(
+        "[_hcng_sock_light_process_payload] Unexpected num_chunks > "
+        "s->remaining");
+    num_chunks = s->remaining;
+  }
+
+  if (!s->cur_request->parse) {
+    /* If we don't need to parse results, then we can directly push
+     * all of them into the result data structure */
+    hc_data_push_many(data, s->buf + s->roff, num_chunks);
+  } else {
+    /* Iterate on chunks of data */
+    for (int i = 0; i < num_chunks; i++) {
+      /* Get storage offset in hc_data_t */
+      u8 *dst = hc_data_get_next(data);
+      if (!dst) {
+        ERROR("[hc_sock_light_process] Error in hc_data_get_next");
+        err = -2;
+        break;
+      }
+
+      /* Parse element #i */
+      rc = s->cur_request->parse(s->buf + s->roff + i * data->in_element_size,
+                                 dst);
+      if (rc < 0) {
+        ERROR("[hc_sock_light_process] Error in parse");
+        err = -1;
+        /* In this case we let the loop complete to collect other results */
+      }
+      data->size++;
+    }
+  }
+
+  s->roff += num_chunks * data->in_element_size;
+
+  /*
+   * If we are not expecting any more data, mark the reply as complete
+   */
+  s->remaining -= num_chunks;
+  if (s->remaining == 0) _hcng_sock_light_mark_complete(s, pdata);
+
+  return err;
+}
+
+/*
+ * Process messages as they are received in the ring buffer. There can be
+ * interleaved queries and replies (they are identified by sequence number),
+ * and the assumption is that a reply can arrive over mutiple packets (in
+ * other terms, it is possible that not all data from the reply is available
+ * in the buffer at a given time). However, we assume that a full query is
+ * received at once.
+ */
+static int _hcng_sock_light_process(hc_sock_t *socket, hc_data_t **data) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+  int rc = 0;
+
+  /*
+   * We loop consuming messages until there is no more data in the buffer,
+   * or that we can find an entire message. Messages are received
+   * sequentially, and we keep track of incomplete requests in s->cur_request.
+   */
+  while (AVAILABLE(s) > 0) {
+    if (!s->cur_request) {
+      rc = _hcng_sock_light_process_header(s, data);
+    } else {
+      rc = _hcng_sock_light_process_payload(s, data);
+    }
+    if (rc < 0) break;
+  }
+
+  if ((rc == -99) || (s->roff == s->woff)) {
+    /* Flush buffer */
+    s->woff = 0;
+  } else {
+    /* Clean up read data from buffer */
+    memmove(s->buf, s->buf + s->roff, AVAILABLE(s));
+    s->woff -= s->roff;
+  }
+  s->roff = 0;
+
+  return rc;
+}
+
+static int _hcng_sock_light_callback(hc_sock_t *socket, hc_data_t **pdata) {
+  hc_data_t *data = NULL;
+  int rc = 0;
+
+  for (;;) {
+    int n = _hcng_sock_light_recv(socket);
+    if (n == 0) goto ERR_EOF;
+    if (n < 0) {
+      switch (errno) {
+        case ECONNRESET:
+        case ENODEV:
+          /* Forwarder restarted */
+          WARN("Forwarder likely restarted: not (yet) implemented");
+          goto ERR;
+        case EWOULDBLOCK:
+          // DEBUG("Would block... stop reading from socket");
+          goto END;
+        case EINTR:
+          WARN("callback has been stopped by signal");
+          goto ERR;
+        default:
+          perror("hc_sock_light_callback");
+          goto ERR;
+      }
+    }
+    rc = _hcng_sock_light_process(socket, &data);
+    if (rc < 0) goto ERR;
+    if (rc > 0)  // i.e. rc = notification type
+      goto END;
+  }
+END:
+  if (pdata)
+    *pdata = data;
+  else
+    hc_data_free(data);
+  return rc;
+
+ERR:
+  hc_data_free(data);
+ERR_EOF:
+  return -1;
+}
+
+/******************************************************************************
+ * Command-specific structures and functions
+ ******************************************************************************/
+
+typedef int (*HC_PARSE)(const u8 *, u8 *);
+
+typedef struct {
+  hc_action_t cmd;
+  command_type_t cmd_id;
+  size_t size_in;
+  size_t size_out;
+  HC_PARSE parse;
+} hc_command_params_t;
+
+typedef struct hc_result_s {
+  hc_msg_t msg;
+  hc_command_params_t params;
+  bool async;
+  bool success;
+} hc_result_t;
+
+int _hcng_sock_prepare_send(hc_sock_t *socket, hc_result_t *result,
+                            data_callback_t complete_cb,
+                            void *complete_cb_data) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+
+  // Prepare data
+  hc_data_t *data =
+      hc_data_create(result->params.size_in, result->params.size_out, NULL);
+  if (!data) {
+    ERROR("[_hcng_execute_command] Could not create data storage");
+    goto ERR_DATA;
+  }
+  hc_data_set_callback(data, complete_cb, complete_cb_data);
+
+  // Update the sequence number
+  int seq = _hcng_sock_light_get_next_seq(socket);
+  result->msg.hdr.seq_num = seq;  // Like in _hcng_sock_light_send
+
+  // Create state used to process the request
+  hc_sock_request_t *request = NULL;
+  request = hc_sock_request_create(seq, data, result->params.parse);
+  if (!request) {
+    ERROR("[_hcng_execute_command] Could not create request state");
+    goto ERR_REQUEST;
+  }
+
+  // Add state to map
+  if (hc_sock_map_add(s->map, seq, request) < 0) {
+    ERROR("[_hcng_execute_command] Error adding request state to map");
+    goto ERR_MAP;
+  }
+
+  return sizeof(result->msg);
+
+ERR_MAP:
+  hc_sock_light_request_free(request);
+ERR_REQUEST:
+  hc_data_free(data);
+ERR_DATA:
+  return -99;
+}
+
+int _hcng_sock_set_recv_timeout_ms(hc_sock_t *socket, long timeout_ms) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+
+  struct timeval tv;
+  tv.tv_sec = 0;
+  tv.tv_usec = timeout_ms * 1000;  // Convert ms into us
+  if (setsockopt(s->fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
+    perror("setsockopt");
+    return -1;
+  }
+
+  return 0;
+}
+
+static int _hcng_execute_command(hc_sock_t *socket, hc_msg_t *msg,
+                                 size_t msg_len, hc_command_params_t *params,
+                                 hc_data_t **pdata, bool async) {
+  hc_sock_light_t *s = TO_HC_SOCK_LIGHT(socket);
+  int ret;
+  if (async) assert(!pdata);
+
+  /* Sanity check */
+  switch (params->cmd) {
+    case ACTION_CREATE:
+      assert(params->size_in != 0); /* payload repeated */
+      assert(params->size_out == 0);
+      assert(params->parse == NULL);
+      break;
+    case ACTION_DELETE:
+      assert(params->size_in != 0); /* payload repeated */
+      assert(params->size_out == 0);
+      assert(params->parse == NULL);
+      break;
+    case ACTION_LIST:
+      assert(params->size_in != 0);
+      assert(params->size_out != 0);
+      assert(params->parse != NULL);
+      break;
+    case ACTION_SET:
+    case ACTION_SERVE:
+    case ACTION_STORE:
+    case ACTION_UPDATE:
+      assert(params->size_in != 0);
+      assert(params->size_out == 0);
+      assert(params->parse == NULL);
+      break;
+    case ACTION_CLEAR:
+      assert(params->size_in == 0);
+      assert(params->size_out == 0);
+      assert(params->parse == NULL);
+      break;
+    default:
+      return -1;
+  }
+
+  // hc_sock_light_reset(s);
+
+  /* XXX data will at least store the result (complete) */
+  hc_data_t *data = hc_data_create(params->size_in, params->size_out, NULL);
+  if (!data) {
+    ERROR("[_hcng_execute_command] Could not create data storage");
+    goto ERR_DATA;
+  }
+
+  int seq = _hcng_sock_light_get_next_seq(socket);
+
+  /* Create state used to process the request */
+  hc_sock_request_t *request = NULL;
+  request = hc_sock_request_create(seq, data, params->parse);
+  if (!request) {
+    ERROR("[_hcng_execute_command] Could not create request state");
+    goto ERR_REQUEST;
+  }
+
+  /* Add state to map */
+  if (hc_sock_map_add(s->map, seq, request) < 0) {
+    ERROR("[_hcng_execute_command] Error adding request state to map");
+    goto ERR_MAP;
+  }
+
+  if (_hcng_sock_light_send(socket, msg, msg_len, seq) < 0) {
+    ERROR("[_hcng_execute_command] Error sending message");
+    goto ERR_PROCESS;
+  }
+
+  if (async) return 0;
+
+  /*
+   * Dangerous zone, we might be doing blocking operations on a non-blocking
+   * UDP socket
+   */
+  int retries = 0;
+  while (!data->complete) {
+    /*
+     * As the socket is non blocking it might happen that we need to read
+     * several times before success...
+     */
+    int n = _hcng_sock_light_recv(socket);
+    if (n == 0) goto ERR_EOF;
+    if (n < 0) {
+      if ((errno == EWOULDBLOCK) && (retries < 10)) { /* Max 500ms */
+        DEBUG("read = EWOULDBLOCK... sleeping for 50ms (max 500ms)");
+        usleep(50000); /* 50ms */
+        retries++;
+        continue;
+      }
+      break;
+    }
+    int rc = _hcng_sock_light_process(socket, pdata);
+    switch (rc) {
+      case 0:
+      case -1:
+        break;
+      case -99:
+        ERROR("[_hcng_execute_command] Error processing socket results");
+        goto ERR;
+      default:
+        ERROR("[_hcng_execute_command] Unexpected return value");
+        goto ERR;
+    }
+  }
+
+ERR_EOF:
+  ret = data->ret;
+  if (!data->complete) return -1;
+  if (!pdata) hc_data_free(data);
+
+  return ret;
+
+ERR_PROCESS:
+ERR_MAP:
+  hc_sock_light_request_free(request);
+ERR:
+ERR_REQUEST:
+  hc_data_free(data);
+ERR_DATA:
+  return -99;
+}
+
+/*----------------------------------------------------------------------------*
+ * Listeners
+ *----------------------------------------------------------------------------*/
+
+/* LISTENER CREATE */
+
+static hc_result_t *_listener_create_serialize(hc_sock_t *s,
+                                               hc_listener_t *listener,
+                                               bool async) {
+  hc_result_t *res = malloc(sizeof(*res));
+  char listener_s[MAXSZ_HC_LISTENER];
+  int rc = hc_listener_snprintf(listener_s, MAXSZ_HC_LISTENER, listener);
+  if (rc >= MAXSZ_HC_LISTENER)
+    WARN("[_hcng_listener_create] Unexpected truncation of listener string");
+  DEBUG("[_hcng_listener_create] listener=%s async=%s", listener_s,
+        BOOLSTR(async));
+
+  if (hc_listener_validate(listener) < 0) {
+    res->success = false;
+    return res;
+  }
+
+  msg_listener_add_t msg = {.header =
+                                {
+                                    .message_type = REQUEST_LIGHT,
+                                    .command_id = COMMAND_TYPE_LISTENER_ADD,
+                                    .length = 1,
+                                    .seq_num = 0,
+                                },
+                            .payload = {
+                                .address = listener->local_addr,
+                                .port = htons(listener->local_port),
+                                .family = listener->family,
+                                .type = listener->type,
+                            }};
+
+  rc = snprintf(msg.payload.symbolic, SYMBOLIC_NAME_LEN, "%s", listener->name);
+  if (rc >= SYMBOLIC_NAME_LEN)
+    WARN(
+        "[_hc_listener_create] Unexpected truncation of symbolic name "
+        "string");
+
+  rc = snprintf(msg.payload.interface_name, INTERFACE_LEN, "%s",
+                listener->interface_name);
+  if (rc >= INTERFACE_LEN)
+    WARN(
+        "[_hc_listener_create] Unexpected truncation of interface name "
+        "string");
+
+  hc_command_params_t params = {
+      .cmd = ACTION_CREATE,
+      .cmd_id = COMMAND_TYPE_LISTENER_ADD,
+      .size_in = sizeof(cmd_listener_add_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  *res = (hc_result_t){
+      .msg =
+          (hc_msg_t){
+              .hdr = msg.header,
+              .payload.listener_add = msg.payload,
+          },
+      .params = params,
+      .async = async,
+      .success = true,
+  };
+  return res;
+}
+
+static hc_result_t *_hcng_listener_create_conf(hc_sock_t *s,
+                                               hc_listener_t *listener) {
+  return _listener_create_serialize(s, listener, false);
+}
+
+static int _hcng_listener_create_internal(hc_sock_t *socket,
+                                          hc_listener_t *listener, bool async) {
+  hc_result_t *result = _listener_create_serialize(socket, listener, async);
+
+  int ret = INPUT_ERROR;
+  if (result->success) {
+    ret = _hcng_execute_command(socket, (hc_msg_t *)&result->msg,
+                                sizeof(result->msg), &result->params, NULL,
+                                result->async);
+  }
+
+  free(result);
+  DEBUG("[_hcng_listener_create] done or error");
+  return ret;
+}
+
+static int _hcng_listener_create(hc_sock_t *s, hc_listener_t *listener) {
+  DEBUG("[_hcng_listener_create]");
+  return _hcng_listener_create_internal(s, listener, false);
+}
+
+static int _hcng_listener_create_async(hc_sock_t *s, hc_listener_t *listener) {
+  DEBUG("[_hcng_listener_create_async]");
+  return _hcng_listener_create_internal(s, listener, true);
+}
+
+/* LISTENER PARSE */
+
+static int hc_listener_parse(void *in, hc_listener_t *listener) {
+  int rc;
+  cmd_listener_list_item_t *item = (cmd_listener_list_item_t *)in;
+
+  if (!IS_VALID_ID(item->id)) {
+    ERROR("[hc_listener_parse] Invalid id received");
+    return -1;
+  }
+
+  *listener = (hc_listener_t){
+      .id = item->id,
+      .type = item->type,
+      .family = item->family,
+      .local_addr = UNION_CAST(item->address, ip_address_t),
+      .local_port = ntohs(item->port),
+  };
+  rc = snprintf(listener->name, SYMBOLIC_NAME_LEN, "%s", item->name);
+  if (rc >= SYMBOLIC_NAME_LEN)
+    WARN("[hc_listener_parse] Unexpected truncation of symbolic name string");
+  rc = snprintf(listener->interface_name, INTERFACE_LEN, "%s",
+                item->interface_name);
+  if (rc >= INTERFACE_LEN)
+    WARN("[hc_listener_parse] Unexpected truncation of interface name string");
+
+  if (hc_listener_validate(listener) < 0) return -1;
+  return 0;
+}
+
+/* LISTENER LIST */
+
+static hc_result_t *_hcng_listener_list_serialize(hc_sock_t *socket,
+                                                  hc_data_t **pdata,
+                                                  bool async) {
+  hc_result_t *res = malloc(sizeof(*res));
+  DEBUG("[hc_listener_list] async=%s", BOOLSTR(async));
+
+  msg_listener_list_t msg = {.header = {
+                                 .message_type = REQUEST_LIGHT,
+                                 .command_id = COMMAND_TYPE_LISTENER_LIST,
+                                 .length = 0,
+                                 .seq_num = 0,
+                             }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_LIST,
+      .cmd_id = COMMAND_TYPE_LISTENER_LIST,
+      .size_in = sizeof(cmd_listener_list_item_t),
+      .size_out = sizeof(hc_listener_t),
+      .parse = (HC_PARSE)hc_listener_parse,
+  };
+
+  *res = (hc_result_t){
+      .msg =
+          (hc_msg_t){
+              .hdr = msg.header,
+              .payload.listener_list = msg.payload,
+          },
+      .params = params,
+      .async = async,
+      .success = true,
+  };
+  return res;
+}
+
+static hc_result_t *_hcng_listener_list_conf(hc_sock_t *s, hc_data_t **pdata) {
+  return _hcng_listener_list_serialize(s, pdata, false);
+}
+
+static int _hcng_listener_list_internal(hc_sock_t *socket, hc_data_t **pdata,
+                                        bool async) {
+  hc_result_t *result = _hcng_listener_list_serialize(socket, pdata, async);
+
+  int ret = INPUT_ERROR;
+  if (result->success) {
+    ret = _hcng_execute_command(socket, (hc_msg_t *)&result->msg,
+                                sizeof(result->msg), &result->params, pdata,
+                                result->async);
+  }
+
+  hc_result_free(result);
+  DEBUG("[_hcng_listener_list] done or error");
+  return ret;
+}
+
+static int _hcng_listener_list(hc_sock_t *s, hc_data_t **pdata) {
+  DEBUG("[_hcng_listener_list]");
+  return _hcng_listener_list_internal(s, pdata, false);
+}
+
+static int _hcng_listener_list_async(hc_sock_t *s, hc_data_t **pdata) {
+  DEBUG("[_hcng_listener_list_as-nc]");
+  return _hcng_listener_list_internal(s, pdata, true);
+}
+
+/* LISTENER GET */
+
+static int _hcng_listener_get(hc_sock_t *socket, hc_listener_t *listener,
+                              hc_listener_t **listener_found) {
+  hc_data_t *listeners;
+  hc_listener_t *found;
+
+  char listener_s[MAXSZ_HC_LISTENER];
+  int rc = hc_listener_snprintf(listener_s, MAXSZ_HC_LISTENER, listener);
+  if (rc >= MAXSZ_HC_LISTENER)
+    WARN("[hc_listener_get] Unexpected truncation of listener string");
+  DEBUG("[hc_listener_get] listener=%s", listener_s);
+
+  if (_hcng_listener_list(socket, &listeners) < 0) return -1;
+
+  /* Test */
+  if (hc_listener_find(listeners, listener, &found) < 0) {
+    hc_data_free(listeners);
+    return -1;
+  }
+
+  if (found) {
+    *listener_found = malloc(sizeof(hc_listener_t));
+    if (!*listener_found) return -1;
+    **listener_found = *found;
+  } else {
+    *listener_found = NULL;
+  }
+
+  hc_data_free(listeners);
+
+  return 0;
+}
+
+/* LISTENER DELETE */
+
+static int _hcng_listener_delete_internal(hc_sock_t *socket,
+                                          hc_listener_t *listener, bool async) {
+  char listener_s[MAXSZ_HC_LISTENER];
+  int rc = hc_listener_snprintf(listener_s, MAXSZ_HC_LISTENER, listener);
+  if (rc >= MAXSZ_HC_LISTENER)
+    WARN("[_hcng_listener_delete] Unexpected truncation of listener string");
+  DEBUG("[_hcng_listener_delete] listener=%s async=%s", listener_s,
+        BOOLSTR(async));
+
+  msg_listener_remove_t msg = {.header = {
+                                   .message_type = REQUEST_LIGHT,
+                                   .command_id = COMMAND_TYPE_LISTENER_REMOVE,
+                                   .length = 1,
+                                   .seq_num = 0,
+                               }};
+
+  if (listener->id) {
+    rc = snprintf(msg.payload.symbolicOrListenerid, SYMBOLIC_NAME_LEN, "%d",
+                  listener->id);
+    if (rc >= SYMBOLIC_NAME_LEN)
+      WARN(
+          "[_hc_listener_delete] Unexpected truncation of symbolic name "
+          "string");
+  } else if (*listener->name) {
+    rc = snprintf(msg.payload.symbolicOrListenerid, SYMBOLIC_NAME_LEN, "%s",
+                  listener->name);
+    if (rc >= SYMBOLIC_NAME_LEN)
+      WARN(
+          "[_hc_listener_delete] Unexpected truncation of symbolic name "
+          "string");
+  } else {
+    hc_listener_t *listener_found;
+    if (_hcng_listener_get(socket, listener, &listener_found) < 0) return -1;
+    if (!listener_found) return -1;
+    rc = snprintf(msg.payload.symbolicOrListenerid, SYMBOLIC_NAME_LEN, "%d",
+                  listener_found->id);
+    if (rc >= SYMBOLIC_NAME_LEN)
+      WARN(
+          "[_hc_listener_delete] Unexpected truncation of symbolic name "
+          "string");
+    free(listener_found);
+  }
+
+  hc_command_params_t params = {
+      .cmd = ACTION_DELETE,
+      .cmd_id = COMMAND_TYPE_LISTENER_REMOVE,
+      .size_in = sizeof(cmd_listener_remove_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, async);
+}
+
+static int _hcng_listener_delete(hc_sock_t *s, hc_listener_t *listener) {
+  return _hcng_listener_delete_internal(s, listener, false);
+}
+
+static int _hcng_listener_delete_async(hc_sock_t *s, hc_listener_t *listener) {
+  return _hcng_listener_delete_internal(s, listener, true);
+}
+
+/*----------------------------------------------------------------------------*
+ * CONNECTION
+ *----------------------------------------------------------------------------*/
+
+/* CONNECTION CREATE */
+
+static hc_result_t *_connection_create_serialize(hc_sock_t *socket,
+                                                 hc_connection_t *connection,
+                                                 bool async) {
+  hc_result_t *res = malloc(sizeof(*res));
+  char connection_s[MAXSZ_HC_CONNECTION];
+  int rc =
+      hc_connection_snprintf(connection_s, MAXSZ_HC_CONNECTION, connection);
+  if (rc >= MAXSZ_HC_CONNECTION)
+    WARN(
+        "[_hcng_connection_create] Unexpected truncation of connection "
+        "string");
+  DEBUG("[_hcng_connection_create] connection=%s async=%s", connection_s,
+        BOOLSTR(async));
+
+  if (hc_connection_validate(connection) < 0) {
+    res->success = false;
+    return res;
+  }
+
+  msg_connection_add_t msg = {.header =
+                                  {
+                                      .message_type = REQUEST_LIGHT,
+                                      .command_id = COMMAND_TYPE_CONNECTION_ADD,
+                                      .length = 1,
+                                      .seq_num = 0,
+                                  },
+                              .payload = {
+                                  .remote_ip = connection->remote_addr,
+                                  .local_ip = connection->local_addr,
+                                  .remote_port = htons(connection->remote_port),
+                                  .local_port = htons(connection->local_port),
+                                  .family = connection->family,
+                                  .type = connection->type,
+                                  .admin_state = connection->admin_state,
+#ifdef WITH_POLICY
+                                  .priority = connection->priority,
+                                  .tags = connection->tags,
+#endif /* WITH_POLICY */
+                              }};
+  rc =
+      snprintf(msg.payload.symbolic, SYMBOLIC_NAME_LEN, "%s", connection->name);
+  if (rc >= SYMBOLIC_NAME_LEN)
+    WARN(
+        "[_hc_connection_create] Unexpected truncation of symbolic name "
+        "string");
+  // snprintf(msg.payload.interface_name, INTERFACE_NAME_LEN, "%s",
+  // connection->interface_name);
+
+  hc_command_params_t params = {
+      .cmd = ACTION_CREATE,
+      .cmd_id = COMMAND_TYPE_CONNECTION_ADD,
+      .size_in = sizeof(cmd_connection_add_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  *res = (hc_result_t){
+      .msg =
+          (hc_msg_t){
+              .hdr = msg.header,
+              .payload.connection_add = msg.payload,
+          },
+      .params = params,
+      .async = async,
+      .success = true,
+  };
+  return res;
+}
+
+static hc_result_t *_hcng_connection_create_conf(hc_sock_t *s,
+                                                 hc_connection_t *connection) {
+  return _connection_create_serialize(s, connection, false);
+}
+
+static int _hcng_connection_create_internal(hc_sock_t *socket,
+                                            hc_connection_t *connection,
+                                            bool async) {
+  hc_result_t *result = _connection_create_serialize(socket, connection, async);
+
+  int ret = INPUT_ERROR;
+  if (result->success) {
+    ret = _hcng_execute_command(socket, (hc_msg_t *)&result->msg,
+                                sizeof(result->msg), &result->params, NULL,
+                                result->async);
+  }
+
+  hc_result_free(result);
+  DEBUG("[_hcng_connection_create] done or error");
+  return ret;
+}
+
+static int _hcng_connection_create(hc_sock_t *s, hc_connection_t *connection) {
+  DEBUG("[_hcng_connection_create]");
+  return _hcng_connection_create_internal(s, connection, false);
+}
+
+static int _hcng_connection_create_async(hc_sock_t *s,
+                                         hc_connection_t *connection) {
+  DEBUG("[_hcng_connection_create_async]");
+  return _hcng_connection_create_internal(s, connection, true);
+}
+
+/* CONNECTION PARSE */
+
+static int hc_connection_parse(void *in, hc_connection_t *connection) {
+  int rc;
+  cmd_connection_list_item_t *item = (cmd_connection_list_item_t *)in;
+
+  if (!IS_VALID_ID(item->id)) {
+    ERROR("[hc_connection_parse] Invalid id received");
+    return -1;
+  }
+
+  *connection = (hc_connection_t){
+      .id = item->id,
+      .type = item->type,
+      .family = item->family,
+      .local_addr = item->local_addr,
+      .local_port = ntohs(item->local_port),
+      .remote_addr = item->remote_addr,
+      .remote_port = ntohs(item->remote_port),
+      .admin_state = item->admin_state,
+#ifdef WITH_POLICY
+      .priority = item->priority,
+      .tags = item->tags,
+#endif /* WITH_POLICY */
+      .state = item->state,
+  };
+  rc = snprintf(connection->name, SYMBOLIC_NAME_LEN, "%s", item->name);
+  if (rc >= SYMBOLIC_NAME_LEN)
+    WARN(
+        "[hc_connection_parse] Unexpected truncation of symbolic name "
+        "string");
+  rc = snprintf(connection->interface_name, INTERFACE_LEN, "%s",
+                item->interface_name);
+  if (rc >= INTERFACE_LEN)
+    WARN(
+        "[hc_connection_parse] Unexpected truncation of interface name "
+        "string");
+
+  if (hc_connection_validate(connection) < 0) return -1;
+  return 0;
+}
+
+/* CONNECTION LIST */
+
+static int _hcng_connection_list_internal(hc_sock_t *socket, hc_data_t **pdata,
+                                          bool async) {
+  DEBUG("[hc_connection_list] async=%s", BOOLSTR(async));
+
+  msg_connection_list_t msg = {.header = {
+                                   .message_type = REQUEST_LIGHT,
+                                   .command_id = COMMAND_TYPE_CONNECTION_LIST,
+                                   .length = 0,
+                                   .seq_num = 0,
+                               }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_LIST,
+      .cmd_id = COMMAND_TYPE_CONNECTION_LIST,
+      .size_in = sizeof(cmd_connection_list_item_t),
+      .size_out = sizeof(hc_connection_t),
+      .parse = (HC_PARSE)hc_connection_parse,
+  };
+
+  int ret = _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg),
+                                  &params, pdata, async);
+
+  DEBUG("[hc_connection_list] done or error");
+  return ret;
+}
+
+static int _hcng_connection_list(hc_sock_t *s, hc_data_t **pdata) {
+  DEBUG("[hc_connection_list]");
+  return _hcng_connection_list_internal(s, pdata, false);
+}
+
+static int _hcng_connection_list_async(hc_sock_t *s, hc_data_t **pdata) {
+  DEBUG("[hc_connection_list_async]");
+  return _hcng_connection_list_internal(s, pdata, true);
+}
+
+/* CONNECTION GET */
+
+static int _hcng_connection_get(hc_sock_t *socket, hc_connection_t *connection,
+                                hc_connection_t **connection_found) {
+  hc_data_t *connections;
+  hc_connection_t *found;
+
+  char connection_s[MAXSZ_HC_CONNECTION];
+  int rc =
+      hc_connection_snprintf(connection_s, MAXSZ_HC_CONNECTION, connection);
+  if (rc >= MAXSZ_HC_CONNECTION)
+    WARN("[hc_connection_get] Unexpected truncation of connection string");
+  DEBUG("[hc_connection_get] connection=%s", connection_s);
+
+  if (_hcng_connection_list(socket, &connections) < 0) return -1;
+
+  /* Test */
+  if (hc_connection_find(connections, connection, &found) < 0) {
+    hc_data_free(connections);
+    return -1;
+  }
+
+  if (found) {
+    *connection_found = malloc(sizeof(hc_connection_t));
+    if (!*connection_found) return -1;
+    **connection_found = *found;
+  } else {
+    *connection_found = NULL;
+  }
+
+  hc_data_free(connections);
+
+  return 0;
+}
+
+/* CONNECTION DELETE */
+
+static hc_result_t *_hcng_connection_delete_serialize(
+    hc_sock_t *socket, hc_connection_t *connection, bool async) {
+  hc_result_t *res = malloc(sizeof(*res));
+  res->success = false;
+
+  char connection_s[MAXSZ_HC_CONNECTION];
+  int rc =
+      hc_connection_snprintf(connection_s, MAXSZ_HC_CONNECTION, connection);
+  if (rc >= MAXSZ_HC_CONNECTION)
+    WARN(
+        "[_hcng_connection_delete] Unexpected truncation of connection "
+        "string");
+  DEBUG("[_hcng_connection_delete] connection=%s async=%s", connection_s,
+        BOOLSTR(async));
+
+  msg_connection_remove_t msg = {
+      .header =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_CONNECTION_REMOVE,
+              .length = 1,
+              .seq_num = 0,
+          },
+  };
+
+  if (connection->id) {
+    rc = snprintf(msg.payload.symbolic_or_connid, SYMBOLIC_NAME_LEN, "%d",
+                  connection->id);
+    if (rc >= SYMBOLIC_NAME_LEN)
+      WARN(
+          "[_hc_connection_delete] Unexpected truncation of symbolic name "
+          "string");
+  } else if (*connection->name) {
+    rc = snprintf(msg.payload.symbolic_or_connid, SYMBOLIC_NAME_LEN, "%s",
+                  connection->name);
+    if (rc >= SYMBOLIC_NAME_LEN)
+      WARN(
+          "[_hc_connection_delete] Unexpected truncation of symbolic name "
+          "string");
+  } else {
+    hc_connection_t *connection_found;
+    if (hc_connection_get(socket, connection, &connection_found) < 0)
+      return res;
+    if (!connection_found) return res;
+    rc = snprintf(msg.payload.symbolic_or_connid, SYMBOLIC_NAME_LEN, "%d",
+                  connection_found->id);
+    if (rc >= SYMBOLIC_NAME_LEN)
+      WARN(
+          "[_hc_connection_delete] Unexpected truncation of symbolic name "
+          "string");
+    free(connection_found);
+  }
+
+  hc_command_params_t params = {
+      .cmd = ACTION_DELETE,
+      .cmd_id = COMMAND_TYPE_CONNECTION_REMOVE,
+      .size_in = sizeof(cmd_connection_remove_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  *res = (hc_result_t){
+      .msg =
+          (hc_msg_t){
+              .hdr = msg.header,
+              .payload.connection_remove = msg.payload,
+          },
+      .params = params,
+      .async = async,
+      .success = true,
+  };
+  return res;
+}
+
+static hc_result_t *_hcng_connection_delete_conf(hc_sock_t *s,
+                                                 hc_connection_t *connection) {
+  return _hcng_connection_delete_serialize(s, connection, false);
+}
+
+static int _hcng_connection_delete_internal(hc_sock_t *socket,
+                                            hc_connection_t *connection,
+                                            bool async) {
+  hc_result_t *result =
+      _hcng_connection_delete_serialize(socket, connection, async);
+
+  int ret = INPUT_ERROR;
+  if (result->success) {
+    ret = _hcng_execute_command(socket, (hc_msg_t *)&result->msg,
+                                sizeof(result->msg), &result->params, NULL,
+                                result->async);
+  }
+
+  hc_result_free(result);
+  return ret;
+}
+
+static int _hcng_connection_delete(hc_sock_t *s, hc_connection_t *connection) {
+  return _hcng_connection_delete_internal(s, connection, false);
+}
+
+static int _hcng_connection_delete_async(hc_sock_t *s,
+                                         hc_connection_t *connection) {
+  return _hcng_connection_delete_internal(s, connection, true);
+}
+
+/* CONNECTION UPDATE */
+
+static int _hcng_connection_update_by_id(hc_sock_t *s, int hc_connection_id,
+                                         hc_connection_t *connection) {
+  // Not implemented
+  return -1;
+}
+
+static int _hcng_connection_update(hc_sock_t *s,
+                                   hc_connection_t *connection_current,
+                                   hc_connection_t *connection_updated) {
+  // Not implemented
+  return -1;
+}
+
+/* CONNECTION SET ADMIN STATE */
+
+static int _hcng_connection_set_admin_state_internal(
+    hc_sock_t *socket, const char *conn_id_or_name, face_state_t state,
+    bool async) {
+  int rc;
+  DEBUG(
+      "[hc_connection_set_admin_state] connection_id/name=%s admin_state=%s "
+      "async=%s",
+      conn_id_or_name, face_state_str(state), BOOLSTR(async));
+
+  struct {
+    cmd_header_t hdr;
+    cmd_connection_set_admin_state_t payload;
+  } msg = {
+      .hdr =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_CONNECTION_SET_ADMIN_STATE,
+              .length = 1,
+              .seq_num = 0,
+          },
+      .payload =
+          {
+              .admin_state = state,
+          },
+  };
+  rc = snprintf(msg.payload.symbolic_or_connid, SYMBOLIC_NAME_LEN, "%s",
+                conn_id_or_name);
+  if (rc >= SYMBOLIC_NAME_LEN)
+    WARN(
+        "[_hc_connection_set_admin_state] Unexpected truncation of symbolic "
+        "name string");
+
+  hc_command_params_t params = {
+      .cmd = ACTION_SET,
+      .cmd_id = COMMAND_TYPE_CONNECTION_SET_ADMIN_STATE,
+      .size_in = sizeof(cmd_connection_set_admin_state_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, async);
+}
+
+static int _hcng_connection_set_admin_state(hc_sock_t *s,
+                                            const char *conn_id_or_name,
+                                            face_state_t state) {
+  return _hcng_connection_set_admin_state_internal(s, conn_id_or_name, state,
+                                                   false);
+}
+
+static int _hcng_connection_set_admin_state_async(hc_sock_t *s,
+                                                  const char *conn_id_or_name,
+                                                  face_state_t state) {
+  return _hcng_connection_set_admin_state_internal(s, conn_id_or_name, state,
+                                                   true);
+}
+
+#ifdef WITH_POLICY
+
+static int _hcng_connection_set_priority_internal(hc_sock_t *socket,
+                                                  const char *conn_id_or_name,
+                                                  uint32_t priority,
+                                                  bool async) {
+  int rc;
+  DEBUG(
+      "[hc_connection_set_priority] connection_id/name=%s priority=%d "
+      "async=%s",
+      conn_id_or_name, priority, BOOLSTR(async));
+  struct {
+    cmd_header_t hdr;
+    cmd_connection_set_priority_t payload;
+  } msg = {
+      .hdr =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_CONNECTION_SET_PRIORITY,
+              .length = 1,
+              .seq_num = 0,
+          },
+      .payload =
+          {
+              .priority = priority,
+          },
+  };
+  rc = snprintf(msg.payload.symbolic_or_connid, SYMBOLIC_NAME_LEN, "%s",
+                conn_id_or_name);
+  if (rc >= SYMBOLIC_NAME_LEN)
+    WARN(
+        "[_hc_connection_set_priority] Unexpected truncation of symbolic "
+        "name "
+        "string");
+
+  hc_command_params_t params = {
+      .cmd = ACTION_SET,
+      .cmd_id = COMMAND_TYPE_CONNECTION_SET_PRIORITY,
+      .size_in = sizeof(cmd_connection_set_priority_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, async);
+}
+
+static int _hcng_connection_set_priority(hc_sock_t *s,
+                                         const char *conn_id_or_name,
+                                         uint32_t priority) {
+  return _hcng_connection_set_priority_internal(s, conn_id_or_name, priority,
+                                                false);
+}
+
+static int _hcng_connection_set_priority_async(hc_sock_t *s,
+                                               const char *conn_id_or_name,
+                                               uint32_t priority) {
+  return _hcng_connection_set_priority_internal(s, conn_id_or_name, priority,
+                                                true);
+}
+
+#endif  // WITH_POLICY
+
+static int _hcng_connection_set_tags_internal(hc_sock_t *s,
+                                              const char *conn_id_or_name,
+                                              policy_tags_t tags, bool async) {
+  int rc;
+  DEBUG("[hc_connection_set_tags] connection_id/name=%s tags=%d async=%s",
+        conn_id_or_name, tags, BOOLSTR(async));
+  struct {
+    cmd_header_t hdr;
+    cmd_connection_set_tags_t payload;
+  } msg = {
+      .hdr =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_CONNECTION_SET_TAGS,
+              .length = 1,
+              .seq_num = 0,
+          },
+      .payload =
+          {
+              .tags = tags,
+          },
+  };
+  rc = snprintf(msg.payload.symbolic_or_connid, SYMBOLIC_NAME_LEN, "%s",
+                conn_id_or_name);
+  if (rc >= SYMBOLIC_NAME_LEN)
+    WARN(
+        "[_hc_connection_set_tags] Unexpected truncation of symbolic name "
+        "string");
+
+  hc_command_params_t params = {
+      .cmd = ACTION_SET,
+      .cmd_id = COMMAND_TYPE_CONNECTION_SET_TAGS,
+      .size_in = sizeof(cmd_connection_set_tags_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(s, (hc_msg_t *)&msg, sizeof(msg), &params, NULL,
+                               async);
+}
+
+static int _hcng_connection_set_tags(hc_sock_t *s, const char *conn_id_or_name,
+                                     policy_tags_t tags) {
+  return _hcng_connection_set_tags_internal(s, conn_id_or_name, tags, false);
+}
+
+static int _hcng_connection_set_tags_async(hc_sock_t *s,
+                                           const char *conn_id_or_name,
+                                           policy_tags_t tags) {
+  return _hcng_connection_set_tags_internal(s, conn_id_or_name, tags, true);
+}
+
+/*----------------------------------------------------------------------------*
+ * Routes
+ *----------------------------------------------------------------------------*/
+
+/* ROUTE CREATE */
+
+static hc_result_t *_route_create_serialize(hc_sock_t *socket,
+                                            hc_route_t *route, bool async) {
+  hc_result_t *res = malloc(sizeof(*res));
+  char route_s[MAXSZ_HC_ROUTE];
+  int rc = hc_route_snprintf(route_s, MAXSZ_HC_ROUTE, route);
+  if (rc >= MAXSZ_HC_ROUTE)
+    WARN("[_hc_route_create] Unexpected truncation of route string");
+  if (rc < 0)
+    WARN("[_hc_route_create] Error building route string");
+  else
+    DEBUG("[hc_route_create] route=%s async=%s", route_s, BOOLSTR(async));
+
+  if (hc_route_validate(route) < 0) {
+    res->success = false;
+    return res;
+  }
+
+  msg_route_add_t msg = {.header =
+                             {
+                                 .message_type = REQUEST_LIGHT,
+                                 .command_id = COMMAND_TYPE_ROUTE_ADD,
+                                 .length = 1,
+                                 .seq_num = 0,
+                             },
+                         .payload = {
+                             .address = route->remote_addr,
+                             .cost = route->cost,
+                             .family = route->family,
+                             .len = route->len,
+                         }};
+
+  /*
+   * The route commands expects the ID or name as part of the
+   * symbolic_or_connid attribute.
+   */
+  if (route->name[0] != '\0') {
+    rc = snprintf(msg.payload.symbolic_or_connid, SYMBOLIC_NAME_LEN, "%s",
+                  route->name);
+  } else {
+    rc = snprintf(msg.payload.symbolic_or_connid, SYMBOLIC_NAME_LEN, "%d",
+                  route->face_id);
+  }
+
+  if (rc >= SYMBOLIC_NAME_LEN)
+    WARN("[_hc_route_create] Unexpected truncation of symbolic name string");
+
+  hc_command_params_t params = {
+      .cmd = ACTION_CREATE,
+      .cmd_id = COMMAND_TYPE_ROUTE_ADD,
+      .size_in = sizeof(cmd_route_add_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  *res = (hc_result_t){
+      .msg =
+          (hc_msg_t){
+              .hdr = msg.header,
+              .payload.route_add = msg.payload,
+          },
+      .params = params,
+      .async = async,
+      .success = true,
+  };
+  return res;
+}
+
+static hc_result_t *_hcng_route_create_conf(hc_sock_t *s, hc_route_t *route) {
+  return _route_create_serialize(s, route, false);
+}
+
+static int _hcng_route_create_internal(hc_sock_t *socket, hc_route_t *route,
+                                       bool async) {
+  hc_result_t *result = _route_create_serialize(socket, route, async);
+
+  int ret = INPUT_ERROR;
+  if (result->success) {
+    ret = _hcng_execute_command(socket, (hc_msg_t *)&result->msg,
+                                sizeof(result->msg), &result->params, NULL,
+                                result->async);
+  }
+
+  hc_result_free(result);
+  return ret;
+}
+
+static int _hcng_route_create(hc_sock_t *s, hc_route_t *route) {
+  return _hcng_route_create_internal(s, route, false);
+}
+
+static int _hcng_route_create_async(hc_sock_t *s, hc_route_t *route) {
+  return _hcng_route_create_internal(s, route, true);
+}
+
+/* ROUTE DELETE */
+
+static int _hcng_route_delete_internal(hc_sock_t *socket, hc_route_t *route,
+                                       bool async) {
+  char route_s[MAXSZ_HC_ROUTE];
+  int rc = hc_route_snprintf(route_s, MAXSZ_HC_ROUTE, route);
+  if (rc >= MAXSZ_HC_ROUTE)
+    WARN("[_hc_route_delete] Unexpected truncation of route string");
+  DEBUG("[hc_route_delete] route=%s async=%s", route_s, BOOLSTR(async));
+
+  if (!IS_VALID_FAMILY(route->family)) return -1;
+
+  struct {
+    cmd_header_t hdr;
+    cmd_route_remove_t payload;
+  } msg = {.hdr =
+               {
+                   .message_type = REQUEST_LIGHT,
+                   .command_id = COMMAND_TYPE_ROUTE_REMOVE,
+                   .length = 1,
+                   .seq_num = 0,
+               },
+           .payload = {
+               .address = route->remote_addr,
+               .family = route->family,
+               .len = route->len,
+           }};
+
+  /*
+   * The route commands expects the ID or name as part of the
+   * symbolic_or_connid attribute.
+   */
+  if (route->name[0] != '\0') {
+    rc = snprintf(msg.payload.symbolic_or_connid, SYMBOLIC_NAME_LEN, "%s",
+                  route->name);
+  } else {
+    rc = snprintf(msg.payload.symbolic_or_connid, SYMBOLIC_NAME_LEN, "%d",
+                  route->face_id);
+  }
+
+  hc_command_params_t params = {
+      .cmd = ACTION_DELETE,
+      .cmd_id = COMMAND_TYPE_ROUTE_REMOVE,
+      .size_in = sizeof(cmd_route_remove_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, async);
+}
+
+static int _hcng_route_delete(hc_sock_t *s, hc_route_t *route) {
+  return _hcng_route_delete_internal(s, route, false);
+}
+
+static int _hcng_route_delete_async(hc_sock_t *s, hc_route_t *route) {
+  return _hcng_route_delete_internal(s, route, true);
+}
+
+/* ROUTE PARSE */
+
+static int hc_route_parse(void *in, hc_route_t *route) {
+  cmd_route_list_item_t *item = (cmd_route_list_item_t *)in;
+
+  *route = (hc_route_t){
+      .name = "", /* This is not reported back */
+      .face_id = item->connection_id,
+      .family = item->family,
+      .remote_addr = item->address,
+      .len = item->len,
+      .cost = item->cost,
+  };
+
+  if (hc_route_validate(route) < 0) return -1;
+  return 0;
+}
+
+/* ROUTE LIST */
+
+static int _hcng_route_list_internal(hc_sock_t *socket, hc_data_t **pdata,
+                                     bool async) {
+  // DEBUG("[hc_route_list] async=%s", BOOLSTR(async));
+  msg_route_list_t msg = {.header = {
+                              .message_type = REQUEST_LIGHT,
+                              .command_id = COMMAND_TYPE_ROUTE_LIST,
+                              .length = 0,
+                              .seq_num = 0,
+                          }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_LIST,
+      .cmd_id = COMMAND_TYPE_ROUTE_LIST,
+      .size_in = sizeof(cmd_route_list_item_t),
+      .size_out = sizeof(hc_route_t),
+      .parse = (HC_PARSE)hc_route_parse,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               pdata, async);
+}
+
+static int _hcng_route_list(hc_sock_t *s, hc_data_t **pdata) {
+  return _hcng_route_list_internal(s, pdata, false);
+}
+
+static int _hcng_route_list_async(hc_sock_t *s) {
+  return _hcng_route_list_internal(s, NULL, true);
+}
+
+/*----------------------------------------------------------------------------*
+ * Face
+ *
+ * Face support is not directly available in hicn-light, but we can offer such
+ * an interface through a combination of listeners and connections. The code
+ * starts with some conversion functions between faces/listeners/connections.
+ *
+ * We also need to make sure that there always exist a (single) listener when
+ *a connection is created, and in the hICN face case, that there is a single
+ * connection attached to this listener.
+ *
+ *----------------------------------------------------------------------------*/
+
+/* FACE CREATE */
+
+static int _hcng_face_create(hc_sock_t *socket, hc_face_t *face) {
+  hc_listener_t listener;
+  hc_listener_t *listener_found;
+
+  hc_connection_t connection;
+  hc_connection_t *connection_found;
+
+  char face_s[MAXSZ_HC_FACE];
+  int rc = hc_face_snprintf(face_s, MAXSZ_HC_FACE, face);
+  if (rc >= MAXSZ_HC_FACE)
+    WARN("[hc_face_create] Unexpected truncation of face string");
+  DEBUG("[hc_face_create] face=%s", face_s);
+
+  switch (face->face.type) {
+    case FACE_TYPE_HICN:
+    case FACE_TYPE_TCP:
+    case FACE_TYPE_UDP:
+      if (hc_face_to_connection(face, &connection, true) < 0) {
+        ERROR("[hc_face_create] Could not convert face to connection.");
+        return -1;
+      }
+
+      /* Ensure we have a corresponding local listener */
+      if (hc_connection_to_local_listener(&connection, &listener) < 0) {
+        ERROR("[hc_face_create] Could not convert face to local listener.");
+        return -1;
+      }
+
+      if (_hcng_listener_get(socket, &listener, &listener_found) < 0) {
+        ERROR("[hc_face_create] Could not retrieve listener");
+        return -1;
+      }
+
+      if (!listener_found) {
+        /* We need to create the listener if it does not exist */
+        if (hc_listener_create(socket, &listener) < 0) {
+          ERROR("[hc_face_create] Could not create listener.");
+          free(listener_found);
+          return -1;
+        }
+      } else {
+        free(listener_found);
+      }
+
+      /* Create corresponding connection */
+      if (_hcng_connection_create(socket, &connection) < 0) {
+        ERROR("[hc_face_create] Could not create connection.");
+        return -1;
+      }
+
+      /*
+       * Once the connection is created, we need to list all connections
+       * and compare with the current one to find the created face ID.
+       */
+      if (_hcng_connection_get(socket, &connection, &connection_found) < 0) {
+        ERROR("[hc_face_create] Could not retrieve connection");
+        return -1;
+      }
+
+      if (!connection_found) {
+        ERROR("[hc_face_create] Could not find newly created connection.");
+        return -1;
+      }
+
+      face->id = connection_found->id;
+      free(connection_found);
+
+      break;
+
+    case FACE_TYPE_HICN_LISTENER:
+    case FACE_TYPE_TCP_LISTENER:
+    case FACE_TYPE_UDP_LISTENER:
+      if (hc_face_to_listener(face, &listener) < 0) {
+        ERROR("Could not convert face to listener.");
+        return -1;
+      }
+      if (hc_listener_create(socket, &listener) < 0) {
+        ERROR("[hc_face_create] Could not create listener.");
+        return -1;
+      }
+      break;
+    default:
+      ERROR("[hc_face_create] Unknwon face type.");
+
+      return -1;
+  };
+
+  return 0;
+}
+
+static int _hcng_face_get(hc_sock_t *socket, hc_face_t *face,
+                          hc_face_t **face_found) {
+  hc_listener_t listener;
+  hc_listener_t *listener_found;
+
+  hc_connection_t connection;
+  hc_connection_t *connection_found;
+
+  char face_s[MAXSZ_HC_FACE];
+  int rc = hc_face_snprintf(face_s, MAXSZ_HC_FACE, face);
+  if (rc >= MAXSZ_HC_FACE)
+    WARN("[hc_face_get] Unexpected truncation of face string");
+  DEBUG("[hc_face_get] face=%s", face_s);
+
+  switch (face->face.type) {
+    case FACE_TYPE_HICN:
+    case FACE_TYPE_TCP:
+    case FACE_TYPE_UDP:
+      if (hc_face_to_connection(face, &connection, false) < 0) return -1;
+      if (_hcng_connection_get(socket, &connection, &connection_found) < 0)
+        return -1;
+      if (!connection_found) {
+        *face_found = NULL;
+        return 0;
+      }
+      *face_found = malloc(sizeof(hc_face_t));
+      hc_connection_to_face(connection_found, *face_found);
+      free(connection_found);
+      break;
+
+    case FACE_TYPE_HICN_LISTENER:
+    case FACE_TYPE_TCP_LISTENER:
+    case FACE_TYPE_UDP_LISTENER:
+      if (hc_face_to_listener(face, &listener) < 0) return -1;
+      if (_hcng_listener_get(socket, &listener, &listener_found) < 0) return -1;
+      if (!listener_found) {
+        *face_found = NULL;
+        return 0;
+      }
+      *face_found = malloc(sizeof(hc_face_t));
+      hc_listener_to_face(listener_found, *face_found);
+      free(listener_found);
+      break;
+
+    default:
+      return -1;
+  }
+
+  return 0;
+}
+
+/* FACE DELETE */
+
+static int _hcng_face_delete(hc_sock_t *socket, hc_face_t *face,
+                             uint8_t delete_listener) {
+  char face_s[MAXSZ_HC_FACE];
+  int rc = hc_face_snprintf(face_s, MAXSZ_HC_FACE, face);
+  if (rc >= MAXSZ_HC_FACE)
+    WARN("[hc_face_delete] Unexpected truncation of face string");
+  DEBUG("[hc_face_delete] face=%s", face_s);
+
+  hc_connection_t connection;
+  if (hc_face_to_connection(face, &connection, false) < 0) {
+    ERROR("[hc_face_delete] Could not convert face to connection.");
+    return -1;
+  }
+
+  if (_hcng_connection_delete(socket, &connection) < 0) {
+    ERROR("[hc_face_delete] Error removing connection");
+    return -1;
+  }
+
+  if (!delete_listener) {
+    return 0;
+  }
+
+  /* If this is the last connection attached to the listener, remove it */
+
+  hc_data_t *connections;
+  hc_listener_t listener = {{0}};
+
+  /*
+   * Ensure we have a corresponding local listener
+   * NOTE: hc_face_to_listener is not appropriate
+   */
+  if (hc_connection_to_local_listener(&connection, &listener) < 0) {
+    ERROR("[hc_face_create] Could not convert face to local listener.");
+    return -1;
+  }
+#if 1
+  /*
+   * The name is generated to prepare listener creation, we need it to be
+   * empty for deletion. The id should not need to be reset though.
+   */
+  listener.id = 0;
+  memset(listener.name, 0, sizeof(listener.name));
+#endif
+  if (_hcng_connection_list(socket, &connections) < 0) {
+    ERROR("[hc_face_delete] Error getting the list of listeners");
+    return -1;
+  }
+
+  bool delete = true;
+  foreach_connection(c, connections) {
+    if ((ip_address_cmp(&c->local_addr, &listener.local_addr, c->family) ==
+         0) &&
+        (c->local_port == listener.local_port) &&
+        (strcmp(c->interface_name, listener.interface_name) == 0)) {
+      delete = false;
+    }
+  }
+
+  if (delete) {
+    if (_hcng_listener_delete(socket, &listener) < 0) {
+      ERROR("[hc_face_delete] Error removing listener");
+      return -1;
+    }
+  }
+
+  hc_data_free(connections);
+
+  return 0;
+}
+
+/* FACE LIST */
+
+static int _hcng_face_list(hc_sock_t *socket, hc_data_t **pdata) {
+  hc_data_t *connection_data;
+  hc_face_t face;
+
+  DEBUG("[hc_face_list]");
+
+  if (_hcng_connection_list(socket, &connection_data) < 0) {
+    ERROR("[hc_face_list] Could not list connections.");
+    return -1;
+  }
+
+  hc_data_t *face_data =
+      hc_data_create(sizeof(hc_connection_t), sizeof(hc_face_t), NULL);
+  foreach_connection(c, connection_data) {
+    if (hc_connection_to_face(c, &face) < 0) {
+      ERROR("[hc_face_list] Could not convert connection to face.");
+      goto ERR;
+    }
+    hc_data_push(face_data, &face);
+  }
+
+  *pdata = face_data;
+  hc_data_free(connection_data);
+  DEBUG("[hc_face_list] done");
+  return 0;
+
+ERR:
+  hc_data_free(connection_data);
+  DEBUG("[hc_face_list] error");
+  return -1;
+}
+
+static int hc_connection_parse_to_face(void *in, hc_face_t *face) {
+  hc_connection_t connection;
+
+  if (hc_connection_parse(in, &connection) < 0) {
+    ERROR("[hc_connection_parse_to_face] Could not parse connection");
+    return -1;
+  }
+
+  if (hc_connection_to_face(&connection, face) < 0) {
+    ERROR(
+        "[hc_connection_parse_to_face] Could not convert connection to "
+        "face.");
+    return -1;
+  }
+
+  return 0;
+}
+
+static int _hcng_face_list_async(hc_sock_t *socket) {
+  struct {
+    cmd_header_t hdr;
+  } msg = {
+      .hdr =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_CONNECTION_LIST,
+              .length = 0,
+              .seq_num = 0,
+          },
+  };
+
+  hc_command_params_t params = {
+      .cmd = ACTION_LIST,
+      .cmd_id = COMMAND_TYPE_CONNECTION_LIST,
+      .size_in = sizeof(cmd_connection_list_item_t),
+      .size_out = sizeof(hc_face_t),
+      .parse = (HC_PARSE)hc_connection_parse_to_face,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, true);
+}
+
+static int _hcng_face_set_admin_state(hc_sock_t *s, const char *conn_id_or_name,
+                                      face_state_t admin_state) {
+  return hc_connection_set_admin_state(s, conn_id_or_name, admin_state);
+}
+
+#ifdef WITH_POLICY
+static int _hcng_face_set_priority(hc_sock_t *s, const char *conn_id_or_name,
+                                   uint32_t priority) {
+  return hc_connection_set_priority(s, conn_id_or_name, priority);
+}
+
+static int _hcng_face_set_tags(hc_sock_t *s, const char *conn_id_or_name,
+                               policy_tags_t tags) {
+  return hc_connection_set_tags(s, conn_id_or_name, tags);
+}
+#endif  // WITH_POLICY
+
+/*----------------------------------------------------------------------------*
+ * Punting
+ *----------------------------------------------------------------------------*/
+
+static int _hcng_punting_create_internal(hc_sock_t *socket,
+                                         hc_punting_t *punting, bool async) {
+  int rc;
+
+  if (hc_punting_validate(punting) < 0) return -1;
+
+  struct {
+    cmd_header_t hdr;
+    cmd_punting_add_t payload;
+  } msg = {.hdr =
+               {
+                   .message_type = REQUEST_LIGHT,
+                   .command_id = COMMAND_TYPE_PUNTING_ADD,
+                   .length = 1,
+                   .seq_num = 0,
+               },
+           .payload = {
+               .address = punting->prefix,
+               .family = punting->family,
+               .len = punting->prefix_len,
+           }};
+  rc = snprintf(msg.payload.symbolic_or_connid, SYMBOLIC_NAME_LEN, "%d",
+                punting->face_id);
+  if (rc >= SYMBOLIC_NAME_LEN)
+    WARN("[_hc_punting_create] Unexpected truncation of symbolic name string");
+
+  hc_command_params_t params = {
+      .cmd = ACTION_CREATE,
+      .cmd_id = COMMAND_TYPE_PUNTING_ADD,
+      .size_in = sizeof(cmd_punting_add_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, async);
+}
+
+static int _hcng_punting_create(hc_sock_t *s, hc_punting_t *punting) {
+  return _hcng_punting_create_internal(s, punting, false);
+}
+
+static int _hcng_punting_create_async(hc_sock_t *s, hc_punting_t *punting) {
+  return _hcng_punting_create_internal(s, punting, true);
+}
+
+static int _hcng_punting_get(hc_sock_t *s, hc_punting_t *punting,
+                             hc_punting_t **punting_found) {
+  ERROR("hc_punting_get not (yet) implemented.");
+  return -1;
+}
+
+static int _hcng_punting_delete(hc_sock_t *s, hc_punting_t *punting) {
+  ERROR("hc_punting_delete not (yet) implemented.");
+  return -1;
+}
+
+#if 0
+static int hc_punting_parse(void * in, hc_punting_t * punting)
+{
+    ERROR("hc_punting_parse not (yet) implemented.");
+    return -1;
+}
+#endif
+
+static int _hcng_punting_list(hc_sock_t *s, hc_data_t **pdata) {
+  ERROR("hc_punting_list not (yet) implemented.");
+  return -1;
+}
+
+/*----------------------------------------------------------------------------*
+ * Cache
+ *----------------------------------------------------------------------------*/
+
+/* CACHE SET STORE */
+
+static int _hcng_cache_set_store_internal(hc_sock_t *socket, hc_cache_t *cache,
+                                          bool async) {
+  msg_cache_set_store_t msg = {
+      .header =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_CACHE_SET_STORE,
+              .length = 1,
+              .seq_num = 0,
+          },
+      .payload = {
+          .activate = cache->store,
+      }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_STORE,
+      .cmd_id = COMMAND_TYPE_CACHE_SET_STORE,
+      .size_in = sizeof(cmd_cache_set_store_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, async);
+}
+
+static int _hcng_cache_set_store(hc_sock_t *s, hc_cache_t *cache) {
+  return _hcng_cache_set_store_internal(s, cache, false);
+}
+
+static int _hcng_cache_set_store_async(hc_sock_t *s, hc_cache_t *cache) {
+  return _hcng_cache_set_store_internal(s, cache, true);
+}
+
+/* CACHE SET SERVE */
+
+static int _hcng_cache_set_serve_internal(hc_sock_t *socket, hc_cache_t *cache,
+                                          bool async) {
+  msg_cache_set_serve_t msg = {
+      .header =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_CACHE_SET_SERVE,
+              .length = 1,
+              .seq_num = 0,
+          },
+      .payload = {
+          .activate = cache->serve,
+      }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_SERVE,
+      .cmd_id = COMMAND_TYPE_CACHE_SET_SERVE,
+      .size_in = sizeof(cmd_cache_set_serve_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, async);
+}
+
+static int _hcng_cache_set_serve(hc_sock_t *s, hc_cache_t *cache) {
+  return _hcng_cache_set_serve_internal(s, cache, false);
+}
+
+static int _hcng_cache_set_serve_async(hc_sock_t *s, hc_cache_t *cache) {
+  return _hcng_cache_set_serve_internal(s, cache, true);
+}
+
+/* CACHE CLEAR */
+
+static int _hcng_cache_clear_internal(hc_sock_t *socket, hc_cache_t *cache,
+                                      bool async) {
+  msg_cache_clear_t msg = {.header = {
+                               .message_type = REQUEST_LIGHT,
+                               .command_id = COMMAND_TYPE_CACHE_CLEAR,
+                               .length = 1,
+                               .seq_num = 0,
+                           }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_CLEAR,
+      .cmd_id = COMMAND_TYPE_CACHE_CLEAR,
+      .size_in = sizeof(cmd_cache_clear_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, async);
+}
+
+static int _hcng_cache_clear(hc_sock_t *s, hc_cache_t *cache) {
+  return _hcng_cache_clear_internal(s, cache, false);
+}
+
+/* CACHE PARSE */
+
+static int hc_cache_parse(void *in, hc_cache_info_t *cache_info) {
+  cmd_cache_list_reply_t *item = (cmd_cache_list_reply_t *)in;
+  *cache_info = (hc_cache_info_t){.store = item->store_in_cs,
+                                  .serve = item->serve_from_cs,
+                                  .cs_size = item->cs_size,
+                                  .num_stale_entries = item->num_stale_entries};
+
+  return 0;
+}
+
+/* CACHE LIST */
+
+static hc_result_t *_hcng_cache_list_serialize(hc_sock_t *socket,
+                                               hc_data_t **pdata, bool async) {
+  hc_result_t *res = malloc(sizeof(*res));
+  DEBUG("[hc_cache_list] async=%s", BOOLSTR(async));
+
+  msg_cache_list_t msg = {.header = {
+                              .message_type = REQUEST_LIGHT,
+                              .command_id = COMMAND_TYPE_CACHE_LIST,
+                              .length = 0,
+                              .seq_num = 0,
+                          }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_LIST,
+      .cmd_id = COMMAND_TYPE_CACHE_LIST,
+      .size_in = sizeof(cmd_cache_list_reply_t),
+      .size_out = sizeof(hc_cache_info_t),
+      .parse = (HC_PARSE)hc_cache_parse,
+  };
+
+  *res = (hc_result_t){
+      .msg =
+          (hc_msg_t){
+              .hdr = msg.header,
+              .payload.cache_list = msg.payload,
+          },
+      .params = params,
+      .async = async,
+      .success = true,
+  };
+  return res;
+}
+
+static int _hcng_cache_list_internal(hc_sock_t *socket, hc_data_t **pdata,
+                                     bool async) {
+  hc_result_t *result = _hcng_cache_list_serialize(socket, pdata, async);
+
+  int ret = INPUT_ERROR;
+  if (result->success) {
+    ret = _hcng_execute_command(socket, (hc_msg_t *)&result->msg,
+                                sizeof(result->msg), &result->params, pdata,
+                                result->async);
+  }
+
+  hc_result_free(result);
+  return ret;
+}
+
+static int _hcng_cache_list(hc_sock_t *s, hc_data_t **pdata) {
+  return _hcng_cache_list_internal(s, pdata, false);
+}
+
+/*----------------------------------------------------------------------------*
+ * Strategy
+ *----------------------------------------------------------------------------*/
+
+// per prefix
+static hc_result_t *_strategy_set_serialize(hc_sock_t *socket,
+                                            hc_strategy_t *strategy) {
+  hc_result_t *res = malloc(sizeof(*res));
+
+  char strategy_s[MAXSZ_HC_STRATEGY];
+  int rc = strcpy_s(strategy->name, MAXSZ_STRATEGY_NAME,
+                    strategy_str(strategy->type));
+  if (rc != EOK) goto ERR;
+  rc = hc_strategy_snprintf(strategy_s, MAXSZ_HC_STRATEGY, strategy);
+  if (rc >= MAXSZ_HC_STRATEGY)
+    WARN("[_hcng_strategy_create] Unexpected truncation of strategy string");
+  DEBUG("[_hcng_strategy_create] strategy=%s", strategy_s);
+
+  if (!IS_VALID_FAMILY(strategy->family) ||
+      !IS_VALID_STRATEGY_TYPE(strategy->type)) {
+    goto ERR;
+  }
+
+  msg_strategy_set_t msg = {.header =
+                                {
+                                    .message_type = REQUEST_LIGHT,
+                                    .command_id = COMMAND_TYPE_STRATEGY_SET,
+                                    .length = 1,
+                                    .seq_num = 0,
+                                },
+                            .payload = {
+                                .address = strategy->address,
+                                .family = strategy->family,
+                                .len = strategy->len,
+                                .type = strategy->type,
+                            }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_SET,
+      .cmd_id = COMMAND_TYPE_STRATEGY_SET,
+      .size_in = sizeof(cmd_strategy_set_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  *res = (hc_result_t){
+      .msg =
+          (hc_msg_t){
+              .hdr = msg.header,
+              .payload.strategy_set = msg.payload,
+          },
+      .params = params,
+      .async = false,
+      .success = true,
+  };
+  return res;
+
+ERR:
+  res->success = false;
+  return res;
+}
+
+static hc_result_t *_strategy_add_local_prefix_serialize(
+    hc_sock_t *socket, hc_strategy_t *strategy) {
+  hc_result_t *res = malloc(sizeof(*res));
+
+  char strategy_s[MAXSZ_HC_STRATEGY];
+  int rc = strcpy_s(strategy->name, MAXSZ_STRATEGY_NAME,
+                    strategy_str(strategy->type));
+  if (rc != EOK) goto ERR;
+  rc = hc_strategy_snprintf(strategy_s, MAXSZ_HC_STRATEGY, strategy);
+  if (rc >= MAXSZ_HC_STRATEGY)
+    WARN("[_hcng_strategy_create] Unexpected truncation of strategy string");
+  DEBUG("[_hcng_strategy_create] strategy=%s", strategy_s);
+
+  if (!IS_VALID_FAMILY(strategy->family) ||
+      !IS_VALID_STRATEGY_TYPE(strategy->type) ||
+      !IS_VALID_FAMILY(strategy->local_family)) {
+    goto ERR;
+  }
+
+  msg_strategy_add_local_prefix_t msg = {
+      .header =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_STRATEGY_ADD_LOCAL_PREFIX,
+              .length = 1,
+              .seq_num = 0,
+          },
+      .payload = {
+          .type = strategy->type,
+          .address = strategy->address,
+          .family = strategy->family,
+          .len = strategy->len,
+          .local_address = strategy->local_address,
+          .local_family = strategy->local_family,
+          .local_len = strategy->local_len,
+      }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_SET,
+      .cmd_id = COMMAND_TYPE_STRATEGY_ADD_LOCAL_PREFIX,
+      .size_in = sizeof(cmd_strategy_add_local_prefix_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  *res = (hc_result_t){
+      .msg =
+          (hc_msg_t){
+              .hdr = msg.header,
+              .payload.strategy_add_local_prefix = msg.payload,
+          },
+      .params = params,
+      .async = false,
+      .success = true,
+  };
+  return res;
+
+ERR:
+  res->success = false;
+  return res;
+}
+
+static hc_result_t *_hcng_strategy_set_conf(hc_sock_t *s,
+                                            hc_strategy_t *strategy) {
+  return _strategy_set_serialize(s, strategy);
+}
+
+static int _hcng_strategy_set(hc_sock_t *socket, hc_strategy_t *strategy) {
+  hc_result_t *result = _strategy_set_serialize(socket, strategy);
+
+  int ret = INPUT_ERROR;
+  if (result->success) {
+    ret = _hcng_execute_command(socket, (hc_msg_t *)&result->msg,
+                                sizeof(result->msg), &result->params, NULL,
+                                result->async);
+  }
+
+  hc_result_free(result);
+  return ret;
+}
+
+static hc_result_t *_hcng_strategy_add_local_prefix_conf(
+    hc_sock_t *s, hc_strategy_t *strategy) {
+  return _strategy_add_local_prefix_serialize(s, strategy);
+}
+
+static int _hcng_strategy_add_local_prefix(hc_sock_t *socket,
+                                           hc_strategy_t *strategy) {
+  hc_result_t *result = _strategy_add_local_prefix_serialize(socket, strategy);
+
+  int ret = INPUT_ERROR;
+  if (result->success) {
+    ret = _hcng_execute_command(socket, (hc_msg_t *)&result->msg,
+                                sizeof(result->msg), &result->params, NULL,
+                                result->async);
+  }
+
+  hc_result_free(result);
+  return ret;
+}
+
+/* How to retrieve that from the forwarder ? */
+static const char *strategies[] = {
+    "random",
+    "load_balancer",
+};
+
+#define ARRAY_SIZE(array) (sizeof(array) / sizeof(*array))
+
+static int _hcng_strategy_list(hc_sock_t *s, hc_data_t **data) {
+  int rc;
+
+  *data = hc_data_create(0, sizeof(hc_strategy_t), NULL);
+
+  for (unsigned i = 0; i < ARRAY_SIZE(strategies); i++) {
+    hc_strategy_t *strategy = (hc_strategy_t *)hc_data_get_next(*data);
+    if (!strategy) return -1;
+    rc = snprintf(strategy->name, MAXSZ_STRATEGY_NAME, "%s", strategies[i]);
+    if (rc >= MAXSZ_STRATEGY_NAME)
+      WARN("[hc_strategy_list] Unexpected truncation of strategy name string");
+    (*data)->size++;
+  }
+
+  return 0;
+}
+
+/*----------------------------------------------------------------------------*
+ * WLDR
+ *----------------------------------------------------------------------------*/
+
+// per connection
+static int _hcng_wldr_set(hc_sock_t *s /* XXX */) { return 0; }
+
+/*----------------------------------------------------------------------------*
+ * MAP-Me
+ *----------------------------------------------------------------------------*/
+
+static int _hcng_mapme_set(hc_sock_t *socket, int enabled) {
+  msg_mapme_enable_t msg = {.header =
+                                {
+                                    .message_type = REQUEST_LIGHT,
+                                    .command_id = COMMAND_TYPE_MAPME_ENABLE,
+                                    .length = 1,
+                                    .seq_num = 0,
+                                },
+                            .payload = {
+                                .activate = enabled,
+                            }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_SET,
+      .cmd_id = COMMAND_TYPE_MAPME_ENABLE,
+      .size_in = sizeof(cmd_mapme_enable_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, false);
+}
+
+static int _hcng_mapme_set_discovery(hc_sock_t *socket, int enabled) {
+  msg_mapme_enable_t msg = {
+      .header =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_MAPME_SET_DISCOVERY,
+              .length = 1,
+              .seq_num = 0,
+          },
+      .payload = {
+          .activate = enabled,
+      }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_SET,
+      .cmd_id = COMMAND_TYPE_MAPME_SET_DISCOVERY,
+      .size_in = sizeof(cmd_mapme_set_discovery_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, false);
+}
+
+static int _hcng_mapme_set_timescale(hc_sock_t *socket, uint32_t timescale) {
+  msg_mapme_set_timescale_t msg = {
+      .header =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_MAPME_SET_TIMESCALE,
+              .length = 1,
+              .seq_num = 0,
+          },
+      .payload = {
+          .timePeriod = timescale,
+      }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_SET,
+      .cmd_id = COMMAND_TYPE_MAPME_SET_TIMESCALE,
+      .size_in = sizeof(cmd_mapme_set_timescale_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, false);
+}
+
+static int _hcng_mapme_set_retx(hc_sock_t *socket, uint32_t timescale) {
+  msg_mapme_set_retx_t msg = {.header =
+                                  {
+                                      .message_type = REQUEST_LIGHT,
+                                      .command_id = COMMAND_TYPE_MAPME_SET_RETX,
+                                      .length = 1,
+                                      .seq_num = 0,
+                                  },
+                              .payload = {
+                                  .timePeriod = timescale,
+                              }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_SET,
+      .cmd_id = COMMAND_TYPE_MAPME_SET_RETX,
+      .size_in = sizeof(msg_mapme_set_retx_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, false);
+}
+
+static int _hcng_mapme_send_update(hc_sock_t *socket, hc_mapme_t *mapme) {
+  if (!IS_VALID_FAMILY(mapme->family)) return -1;
+
+  msg_mapme_send_update_t msg = {
+      .header =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_MAPME_SEND_UPDATE,
+              .length = 1,
+              .seq_num = 0,
+          },
+  };
+
+  hc_command_params_t params = {
+      .cmd = ACTION_UPDATE,
+      .cmd_id = COMMAND_TYPE_MAPME_SEND_UPDATE,
+      .size_in = sizeof(msg_mapme_send_update_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, false);
+}
+
+/*----------------------------------------------------------------------------*
+ * Policy
+ *----------------------------------------------------------------------------*/
+
+#ifdef WITH_POLICY
+
+/* POLICY CREATE */
+
+static int _hcng_policy_create_internal(hc_sock_t *socket, hc_policy_t *policy,
+                                        bool async) {
+  if (!IS_VALID_FAMILY(policy->family)) return -1;
+
+  struct {
+    cmd_header_t hdr;
+    cmd_policy_add_t payload;
+  } msg = {.hdr =
+               {
+                   .message_type = REQUEST_LIGHT,
+                   COMMAND_TYPE_POLICY_ADD,
+                   .length = 1,
+                   .seq_num = 0,
+               },
+           .payload = {
+               .address = policy->remote_addr,
+               .family = policy->family,
+               .len = policy->len,
+               .policy = policy->policy,
+           }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_CREATE,
+      .cmd_id = COMMAND_TYPE_POLICY_ADD,
+      .size_in = sizeof(cmd_policy_add_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, async);
+}
+
+static int _hcng_policy_create(hc_sock_t *s, hc_policy_t *policy) {
+  return _hcng_policy_create_internal(s, policy, false);
+}
+
+static int _hcng_policy_create_async(hc_sock_t *s, hc_policy_t *policy) {
+  return _hcng_policy_create_internal(s, policy, true);
+}
+
+/* POLICY DELETE */
+
+static int _hcng_policy_delete_internal(hc_sock_t *socket, hc_policy_t *policy,
+                                        bool async) {
+  if (!IS_VALID_FAMILY(policy->family)) return -1;
+
+  struct {
+    cmd_header_t hdr;
+    cmd_policy_remove_t payload;
+  } msg = {.hdr =
+               {
+                   .message_type = REQUEST_LIGHT,
+                   .command_id = COMMAND_TYPE_POLICY_REMOVE,
+                   .length = 1,
+                   .seq_num = 0,
+               },
+           .payload = {
+               .address = policy->remote_addr,
+               .family = policy->family,
+               .len = policy->len,
+           }};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_DELETE,
+      .cmd_id = COMMAND_TYPE_POLICY_REMOVE,
+      .size_in = sizeof(cmd_policy_remove_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               NULL, async);
+}
+
+static int _hcng_policy_delete(hc_sock_t *s, hc_policy_t *policy) {
+  return _hcng_policy_delete_internal(s, policy, false);
+}
+
+static int _hcng_policy_delete_async(hc_sock_t *s, hc_policy_t *policy) {
+  return _hcng_policy_delete_internal(s, policy, true);
+}
+
+/* POLICY PARSE */
+
+static int hc_policy_parse(void *in, hc_policy_t *policy) {
+  cmd_policy_list_item_t *item = (cmd_policy_list_item_t *)in;
+
+  if (!IS_VALID_ADDRESS(&item->address, item->family)) {
+    ERROR("[hc_policy_parse] Invalid address");
+    return -1;
+  }
+  if (!IS_VALID_FAMILY(item->family)) {
+    ERROR("[hc_policy_parse] Invalid family");
+    return -1;
+  }
+  if (!IS_VALID_PREFIX_LEN(item->len)) {
+    ERROR("[hc_policy_parse] Invalid len");
+    return -1;
+  }
+  if (!IS_VALID_POLICY(item->policy)) {
+    ERROR("[hc_policy_parse] Invalid policy");
+    return -1;
+  }
+
+  *policy = (hc_policy_t){
+      .family = item->family,
+      .remote_addr = item->address,
+      .len = item->len,
+      .policy = item->policy,
+  };
+  return 0;
+}
+
+/* POLICY LIST */
+
+static int _hcng_policy_list_internal(hc_sock_t *socket, hc_data_t **pdata,
+                                      bool async) {
+  struct {
+    cmd_header_t hdr;
+  } msg = {
+      .hdr =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_POLICY_LIST,
+              .length = 0,
+              .seq_num = 0,
+          },
+  };
+
+  hc_command_params_t params = {
+      .cmd = ACTION_LIST,
+      .cmd_id = COMMAND_TYPE_POLICY_LIST,
+      .size_in = sizeof(cmd_policy_list_item_t),
+      .size_out = sizeof(hc_policy_t),
+      .parse = (HC_PARSE)hc_policy_parse,
+  };
+
+  return _hcng_execute_command(socket, (hc_msg_t *)&msg, sizeof(msg), &params,
+                               pdata, async);
+}
+
+static int _hcng_policy_list(hc_sock_t *s, hc_data_t **pdata) {
+  return _hcng_policy_list_internal(s, pdata, false);
+}
+
+static int _hcng_policy_list_async(hc_sock_t *s, hc_data_t **pdata) {
+  return _hcng_policy_list_internal(s, pdata, true);
+}
+
+#endif /* WITH_POLICY */
+
+/*----------------------------------------------------------------------------*
+ * Subscriptioins
+ *----------------------------------------------------------------------------*/
+
+/* SUBSCRIPTION CREATE */
+
+static hc_result_t *_subscription_create_serialize(
+    hc_sock_t *s, hc_subscription_t *subscription) {
+  msg_subscription_add_t msg = {
+      .header =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_SUBSCRIPTION_ADD,
+              .length = 1,
+              .seq_num = 0,
+          },
+      .payload = {.topics = subscription->topics}};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_CREATE,
+      .cmd_id = COMMAND_TYPE_SUBSCRIPTION_ADD,
+      .size_in = sizeof(cmd_subscription_add_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  hc_result_t *res = malloc(sizeof(*res));
+  *res = (hc_result_t){
+      .msg =
+          (hc_msg_t){
+              .hdr = msg.header,
+              .payload.subscription_add = msg.payload,
+          },
+      .params = params,
+      .async = false,
+      .success = true,
+  };
+  return res;
+}
+
+static hc_result_t *_hcng_subscription_create_conf(
+    hc_sock_t *s, hc_subscription_t *subscription) {
+  return _subscription_create_serialize(s, subscription);
+}
+
+static int _hcng_subscription_create(hc_sock_t *socket,
+                                     hc_subscription_t *subscriiption) {
+  hc_result_t *result = _subscription_create_serialize(socket, subscriiption);
+
+  int ret = INPUT_ERROR;
+  if (result->success) {
+    ret = _hcng_execute_command(socket, (hc_msg_t *)&result->msg,
+                                sizeof(result->msg), &result->params, NULL,
+                                result->async);
+  }
+
+  hc_result_free(result);
+  return ret;
+}
+
+/* SUBSCRIPTION DELETE */
+
+static hc_result_t *_subscription_delete_serialize(
+    hc_sock_t *s, hc_subscription_t *subscription) {
+  msg_subscription_remove_t msg = {
+      .header =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_SUBSCRIPTION_REMOVE,
+              .length = 1,
+              .seq_num = 0,
+          },
+      .payload = {.topics = subscription->topics}};
+
+  hc_command_params_t params = {
+      .cmd = ACTION_DELETE,
+      .cmd_id = COMMAND_TYPE_SUBSCRIPTION_REMOVE,
+      .size_in = sizeof(cmd_subscription_remove_t),
+      .size_out = 0,
+      .parse = NULL,
+  };
+
+  hc_result_t *res = malloc(sizeof(*res));
+  *res = (hc_result_t){
+      .msg =
+          (hc_msg_t){
+              .hdr = msg.header,
+              .payload.subscription_remove = msg.payload,
+          },
+      .params = params,
+      .async = false,
+      .success = true,
+  };
+  return res;
+}
+
+static hc_result_t *_hcng_subscription_delete_conf(
+    hc_sock_t *s, hc_subscription_t *subscription) {
+  return _subscription_delete_serialize(s, subscription);
+}
+
+static int _hcng_subscription_delete(hc_sock_t *socket,
+                                     hc_subscription_t *subscriiption) {
+  hc_result_t *result = _subscription_delete_serialize(socket, subscriiption);
+
+  int ret = INPUT_ERROR;
+  if (result->success) {
+    ret = _hcng_execute_command(socket, (hc_msg_t *)&result->msg,
+                                sizeof(result->msg), &result->params, NULL,
+                                result->async);
+  }
+
+  hc_result_free(result);
+  return ret;
+}
+
+/* RESULT */
+hc_msg_t *_hcng_result_get_msg(hc_result_t *result) { return &result->msg; }
+int _hcng_result_get_cmd_id(hc_result_t *result) {
+  return result->params.cmd_id;
+}
+bool _hcng_result_get_success(hc_result_t *result) { return result->success; }
+
+static hc_sock_t hc_sock_light_ng_interface = (hc_sock_t){
+    .hc_sock_get_next_seq = _hcng_sock_light_get_next_seq,
+    .hc_sock_set_nonblocking = _hcng_sock_light_set_nonblocking,
+    .hc_sock_get_fd = _hcng_sock_light_get_fd,
+    .hc_sock_connect = _hcng_sock_light_connect,
+    .hc_sock_get_available = _hcng_sock_light_get_available,
+    .hc_sock_send = _hcng_sock_light_send,
+    .hc_sock_recv = _hcng_sock_light_recv,
+    .hc_sock_process = _hcng_sock_light_process,
+    .hc_sock_callback = _hcng_sock_light_callback,
+    .hc_sock_reset = _hcng_sock_light_reset,
+    .hc_sock_free = _hcng_sock_light_free,
+    .hc_sock_increment_woff = _hcng_sock_increment_woff,
+    .hc_sock_prepare_send = _hcng_sock_prepare_send,
+    .hc_sock_set_recv_timeout_ms = _hcng_sock_set_recv_timeout_ms,
+    .hc_listener_create = _hcng_listener_create,
+    .hc_listener_create_async = _hcng_listener_create_async,
+    .hc_listener_get = _hcng_listener_get,
+    .hc_listener_delete = _hcng_listener_delete,
+    .hc_listener_delete_async = _hcng_listener_delete_async,
+    .hc_listener_list = _hcng_listener_list,
+    .hc_listener_list_async = _hcng_listener_list_async,
+    .hc_connection_create = _hcng_connection_create,
+    .hc_connection_create_async = _hcng_connection_create_async,
+    .hc_connection_get = _hcng_connection_get,
+    .hc_connection_update_by_id = _hcng_connection_update_by_id,
+    .hc_connection_update = _hcng_connection_update,
+    .hc_connection_delete = _hcng_connection_delete,
+    .hc_connection_delete_async = _hcng_connection_delete_async,
+    .hc_connection_list = _hcng_connection_list,
+    .hc_connection_list_async = _hcng_connection_list_async,
+    .hc_connection_set_admin_state = _hcng_connection_set_admin_state,
+    .hc_connection_set_admin_state_async =
+        _hcng_connection_set_admin_state_async,
+
+#ifdef WITH_POLICY
+    .hc_connection_set_priority = _hcng_connection_set_priority,
+    .hc_connection_set_priority_async = _hcng_connection_set_priority_async,
+    .hc_connection_set_tags = _hcng_connection_set_tags,
+    .hc_connection_set_tags_async = _hcng_connection_set_tags_async,
+#endif  // WITH_POLICY
+
+    .hc_face_create = _hcng_face_create,
+    .hc_face_get = _hcng_face_get,
+    .hc_face_delete = _hcng_face_delete,
+    .hc_face_list = _hcng_face_list,
+    .hc_face_list_async = _hcng_face_list_async,
+    .hc_face_set_admin_state = _hcng_face_set_admin_state,
+
+#ifdef WITH_POLICY
+    .hc_face_set_priority = _hcng_face_set_priority,
+    .hc_face_set_tags = _hcng_face_set_tags,
+#endif  // WITH_POLICY
+    .hc_subscription_create = _hcng_subscription_create,
+    .hc_subscription_delete = _hcng_subscription_delete,
+
+    .hc_route_create = _hcng_route_create,
+    .hc_route_create_async = _hcng_route_create_async,
+    .hc_route_delete = _hcng_route_delete,
+    .hc_route_delete_async = _hcng_route_delete_async,
+    .hc_route_list = _hcng_route_list,
+    .hc_route_list_async = _hcng_route_list_async,
+
+    .hc_punting_create = _hcng_punting_create,
+    .hc_punting_create_async = _hcng_punting_create_async,
+    .hc_punting_get = _hcng_punting_get,
+    .hc_punting_delete = _hcng_punting_delete,
+    .hc_punting_list = _hcng_punting_list,
+
+    .hc_cache_set_store = _hcng_cache_set_store,
+    .hc_cache_set_store_async = _hcng_cache_set_store_async,
+    .hc_cache_set_serve = _hcng_cache_set_serve,
+    .hc_cache_set_serve_async = _hcng_cache_set_serve_async,
+    .hc_cache_clear = _hcng_cache_clear,
+    .hc_cache_list = _hcng_cache_list,
+
+    .hc_strategy_list = _hcng_strategy_list,
+    .hc_strategy_set = _hcng_strategy_set,
+    .hc_strategy_add_local_prefix = _hcng_strategy_add_local_prefix,
+    .hc_wldr_set = _hcng_wldr_set,
+
+    .hc_mapme_set = _hcng_mapme_set,
+    .hc_mapme_set_discovery = _hcng_mapme_set_discovery,
+    .hc_mapme_set_timescale = _hcng_mapme_set_timescale,
+    .hc_mapme_set_retx = _hcng_mapme_set_retx,
+    .hc_mapme_send_update = _hcng_mapme_send_update,
+
+#ifdef WITH_POLICY
+    .hc_policy_create = _hcng_policy_create,
+    .hc_policy_create_async = _hcng_policy_create_async,
+    .hc_policy_delete = _hcng_policy_delete,
+    .hc_policy_delete_async = _hcng_policy_delete_async,
+    .hc_policy_list = _hcng_policy_list,
+    .hc_policy_list_async = _hcng_policy_list_async,
+#endif  // WITH_POLICY
+
+    .hc_listener_create_conf = _hcng_listener_create_conf,
+    .hc_listener_list_conf = _hcng_listener_list_conf,
+    .hc_connection_create_conf = _hcng_connection_create_conf,
+    .hc_connection_delete_conf = _hcng_connection_delete_conf,
+    .hc_route_create_conf = _hcng_route_create_conf,
+    .hc_strategy_set_conf = _hcng_strategy_set_conf,
+    .hc_strategy_add_local_prefix_conf = _hcng_strategy_add_local_prefix_conf,
+    .hc_subscription_create_conf = _hcng_subscription_create_conf,
+    .hc_subscription_delete_conf = _hcng_subscription_delete_conf,
+
+    .hc_result_get_msg = _hcng_result_get_msg,
+    .hc_result_get_cmd_id = _hcng_result_get_cmd_id,
+    .hc_result_get_success = _hcng_result_get_success,
+};
+
+// Public contructors
+
+hc_sock_t *_hc_sock_create_url(const char *url) {
+  hc_sock_light_t *s = malloc(sizeof(hc_sock_light_t));
+  if (!s) goto ERR_MALLOC;
+
+  s->vft = hc_sock_light_ng_interface;
+  s->url = url ? strdup(url) : NULL;
+
+  s->fd = socket(AF_INET, SOCK_DGRAM, 0);
+  if (s->fd < 0) goto ERR_SOCKET;
+
+  if (_hcng_sock_set_recv_timeout_ms((hc_sock_t *)s,
+                                     DEFAULT_SOCK_RECV_TIMEOUT_MS) < 0)
+    goto ERR_SOCKET;
+
+  if (_hcng_sock_light_reset((hc_sock_t *)s) < 0) goto ERR_RESET;
+
+  s->seq = 0;
+  s->cur_request = NULL;
+
+  s->map = hc_sock_map_create();
+  if (!s->map) goto ERR_MAP;
+
+  return (hc_sock_t *)(s);
+
+  // hc_sock_light_map_free(s->map);
+ERR_MAP:
+ERR_RESET:
+  if (s->url) free(s->url);
+  close(s->fd);
+ERR_SOCKET:
+  free(s);
+ERR_MALLOC:
+  return NULL;
+}
diff --git a/ctrl/libhicnctrl/src/modules/hicn_plugin_api.c b/ctrl/libhicnctrl/src/modules/hicn_plugin_api.c
index e59a2e41e..6d1baa786 100644
--- a/ctrl/libhicnctrl/src/modules/hicn_plugin_api.c
+++ b/ctrl/libhicnctrl/src/modules/hicn_plugin_api.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -18,8 +18,6 @@
  * \brief Implementation of hICN control library API
  */
 
-#include "api_private.h"
-
 #include <assert.h>  // assert
 #include <fcntl.h>   // fcntl
 #include <math.h>    // log2
@@ -29,40 +27,10 @@
 #include <sys/socket.h>  // socket
 #include <unistd.h>      // close, fcntl
 #include <vapi/vapi_safe.h>
-#include <vapi/hicn.api.vapi.h>
-#include <vapi/ip.api.vapi.h>
-#include <vapi/udp.api.vapi.h>
-#include <vapi/interface.api.vapi.h>
-
-
-#if __GNUC__ >= 9
-#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
-#endif
-
-#include <vnet/ip/ip46_address.h>
-
-#if __GNUC__ >= 9
-#pragma GCC diagnostic pop
-#endif
-
-#define APP_NAME "hicn_plugin"
-#define MAX_OUTSTANDING_REQUESTS 4
-#define RESPONSE_QUEUE_SIZE 2
-
-DEFINE_VAPI_MSG_IDS_HICN_API_JSON
-DEFINE_VAPI_MSG_IDS_INTERFACE_API_JSON
-DEFINE_VAPI_MSG_IDS_IP_API_JSON
-DEFINE_VAPI_MSG_IDS_UDP_API_JSON
+#include <vppinfra/clib.h>
+#include <vpp_plugins/hicn/error.h>
 
-typedef struct {
-  vapi_ctx_t g_vapi_ctx_instance;
-  bool async;
-} vapi_skc_ctx_t;
-
-vapi_skc_ctx_t vapi_skc = {
-  .g_vapi_ctx_instance = NULL,
-  .async = false,
-};
+#include "api_private.h"
 
 /**
  * Messages to the forwarder might be multiplexed thanks to the seqNum fields in
@@ -81,7 +49,6 @@ struct hc_sock_vpp_s {
 
   vapi_ctx_t g_vapi_ctx_instance;
   char *url;
-  int fd;
 
   size_t roff; /**< Read offset */
   size_t woff; /**< Write offset */
@@ -94,43 +61,42 @@ struct hc_sock_vpp_s {
 
 typedef struct hc_sock_vpp_s hc_sock_vpp_t;
 
-#define TO_HC_SOCK_VPP(s) (hc_sock_vpp_t*)(s)
+#define TO_HC_SOCK_VPP(s) (hc_sock_vpp_t *)(s)
 
 /******************************************************************************
  * Message helper types and aliases
  ******************************************************************************/
 
-#define foreach_hc_command             \
-  _(hicn_api_node_params_set)          \
-  _(hicn_api_node_params_set_reply)    \
-  _(hicn_api_node_params_get_reply)    \
-  _(hicn_api_node_stats_get_reply)     \
-  _(hicn_api_face_get)                 \
-  _(hicn_api_faces_details)            \
-  _(hicn_api_face_stats_details)       \
-  _(hicn_api_face_get_reply)           \
-  _(hicn_api_route_get)                \
-  _(hicn_api_route_get_reply)          \
-  _(hicn_api_routes_details)           \
-  _(hicn_api_strategies_get_reply)     \
-  _(hicn_api_strategy_get)             \
+#define foreach_hc_command          \
+  _(hicn_api_node_params_set)       \
+  _(hicn_api_node_params_set_reply) \
+  _(hicn_api_node_params_get_reply) \
+  _(hicn_api_node_stats_get_reply)  \
+  _(hicn_api_face_get)              \
+  _(hicn_api_faces_details)         \
+  _(hicn_api_face_stats_details)    \
+  _(hicn_api_face_get_reply)        \
+  _(hicn_api_route_get)             \
+  _(hicn_api_route_get_reply)       \
+  _(hicn_api_routes_details)        \
+  _(hicn_api_strategies_get_reply)  \
+  _(hicn_api_strategy_get)          \
   _(hicn_api_strategy_get_reply)
 
-
 typedef vapi_type_msg_header2_t hc_msg_header_t;
 
 typedef union {
-#define _(a) vapi_payload_ ## a a;
+#define _(a) vapi_payload_##a a;
   foreach_hc_command
 #undef _
 } hc_msg_payload_t;
 
-typedef struct __attribute__ ((__packed__)) {
+typedef struct __attribute__((__packed__)) {
   hc_msg_header_t hdr;
   hc_msg_payload_t payload;
 } hc_hicnp_t;
 
-typedef void (* NTOH)(void *msg);
+typedef void (*NTOH)(void *msg);
 
 typedef struct __attribute__((__packed__)) {
   hc_data_t *data;
@@ -138,7 +104,7 @@ typedef struct __attribute__((__packed__)) {
 } callback_ctx_t;
 
 typedef struct __attribute__((__packed__)) {
-  hc_hicnp_t * hicnp_msg;
+  hc_hicnp_t *hicnp_msg;
   vapi_cb_t callback;
   callback_ctx_t *callback_ctx;
   NTOH ntoh;
@@ -151,11 +117,9 @@ typedef struct __attribute__((__packed__)) {
 static void _hc_sock_vpp_free(hc_sock_t *socket) {
   hc_sock_vpp_t *s = TO_HC_SOCK_VPP(socket);
   if (s->url) free(s->url);
-  close(s->fd);
   free(s);
 
   vapi_disconnect_safe();
-  vapi_skc.g_vapi_ctx_instance = NULL;
 }
 
 static int _hc_sock_vpp_get_next_seq(hc_sock_t *socket) {
@@ -174,8 +138,7 @@ static int _hc_sock_vpp_get_fd(hc_sock_t *s) { return 1; }
 static int _hc_sock_vpp_connect(hc_sock_t *socket) {
   hc_sock_vpp_t *s = TO_HC_SOCK_VPP(socket);
   vapi_error_e rv = vapi_connect_safe(&s->g_vapi_ctx_instance, s->async);
-  if (rv != VAPI_OK)
-    goto ERR_CONNECT;
+  if (rv != VAPI_OK) goto ERR_CONNECT;
 
   return 0;
 
@@ -184,7 +147,8 @@ ERR_CONNECT:
   return -1;
 }
 
-static int _hc_sock_vpp_send(hc_sock_t *s, hc_msg_t *msg, size_t msglen, int seq) {
+static int _hc_sock_vpp_send(hc_sock_t *s, hc_msg_t *msg, size_t msglen,
+                             uint32_t seq) {
   return -1;
 }
 
@@ -199,16 +163,16 @@ static int _hc_sock_vpp_recv(hc_sock_t *s) {
 }
 
 static int _hc_sock_vpp_process(hc_sock_t *s, hc_data_t **pdata) {
-  //NOT IMPLEMENTED
+  // NOT IMPLEMENTED
   return -1;
 }
 
-static int _hc_sock_vpp_callback(hc_sock_t * socket, hc_data_t ** pdata) {
+static int _hc_sock_vpp_callback(hc_sock_t *socket, hc_data_t **pdata) {
   // NOT IMPLEMENTED
   return -1;
 }
 
-static int _hc_sock_vpp_reset(hc_sock_t * socket) {
+static int _hc_sock_vpp_reset(hc_sock_t *socket) {
   // NOT IMPLEMENTED
   return -1;
 }
@@ -217,7 +181,6 @@ static int _hc_sock_vpp_reset(hc_sock_t * socket) {
  * Command-specific structures and functions
  ******************************************************************************/
 
-
 /*----------------------------------------------------------------------------*
  * Listeners
  *----------------------------------------------------------------------------*/
@@ -236,7 +199,7 @@ static int _hc_listener_create_async(hc_sock_t *s, hc_listener_t *listener) {
 
 /* LISTENER GET */
 static int _hc_listener_get(hc_sock_t *s, hc_listener_t *listener,
-                    hc_listener_t **listener_found) {
+                            hc_listener_t **listener_found) {
   // NOT IMPLEMENTED
   return -1;
 }
@@ -253,33 +216,32 @@ static int _hc_listener_delete_async(hc_sock_t *s, hc_listener_t *listener) {
   return -1;
 }
 
-static vapi_error_e process_ip_info(struct vapi_ctx_s *ctx,
-                                    void *callback_ctx,
-                                    vapi_error_e rv,
-                                    bool is_last,
+static vapi_error_e process_ip_info(struct vapi_ctx_s *ctx, void *callback_ctx,
+                                    vapi_error_e rv, bool is_last,
                                     vapi_payload_ip_address_details *reply) {
-
-  if (is_last)
-    return 0;
+  if (is_last) return 0;
   hc_data_t *data = (hc_data_t *)callback_ctx;
 
   if (data->size == data->current) {
-    data->buffer = realloc(data->buffer, sizeof(hc_listener_t) * data->size * 2);
+    data->buffer =
+        realloc(data->buffer, sizeof(hc_listener_t) * data->size * 2);
 
-    if (!data->buffer)
-      return VAPI_ENOMEM;
+    if (!data->buffer) return VAPI_ENOMEM;
 
-    data->size *=2;
+    data->size *= 2;
   }
 
-  hc_listener_t * listener = (hc_listener_t *)(data->buffer + data->current * sizeof(hc_listener_t));
+  hc_listener_t *listener =
+      (hc_listener_t *)(data->buffer + data->current * sizeof(hc_listener_t));
+  memset(listener, 0, sizeof(hc_listener_t));
 
-  if(reply->prefix.address.af == ADDRESS_IP4) {
-    memcpy(listener->local_addr.v4.as_u8, reply->prefix.address.un.ip4, IPV4_ADDR_LEN);
+  if (reply->prefix.address.af == ADDRESS_IP4) {
+    memcpy(listener->local_addr.v4.as_u8, reply->prefix.address.un.ip4,
+           IPV4_ADDR_LEN);
     listener->family = AF_INET;
-  }
-  else {
-    memcpy(listener->local_addr.v6.as_u8, reply->prefix.address.un.ip6, IPV6_ADDR_LEN);
+  } else {
+    memcpy(listener->local_addr.v6.as_u8, reply->prefix.address.un.ip6,
+           IPV6_ADDR_LEN);
     listener->family = AF_INET6;
   }
 
@@ -293,31 +255,26 @@ typedef struct {
   char interface_name[INTERFACE_LEN];
 } hc_vapi_interface_t;
 
-static vapi_error_e listener_list_complete_cb (
-                struct vapi_ctx_s *ctx,
-                void *callback_ctx,
-                vapi_error_e rv,
-                bool is_last,
-				        vapi_payload_sw_interface_details *reply) {
+static vapi_error_e listener_list_complete_cb(
+    struct vapi_ctx_s *ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_sw_interface_details *reply) {
+  if (reply == NULL || rv != VAPI_OK) return rv;
 
-  if (reply == NULL || rv != VAPI_OK)
-    return rv;
-
-  if (is_last)
-    return 0;
+  if (is_last) return 0;
 
   hc_data_t *data = (hc_data_t *)callback_ctx;
 
   if (data->size == data->current) {
-    data->buffer = realloc(data->buffer, sizeof(hc_vapi_interface_t) * data->size * 2);
+    data->buffer =
+        realloc(data->buffer, sizeof(hc_vapi_interface_t) * data->size * 2);
 
-    if (!data->buffer)
-      return VAPI_ENOMEM;
+    if (!data->buffer) return VAPI_ENOMEM;
 
-    data->size *=2;
+    data->size *= 2;
   }
 
-  hc_vapi_interface_t *swif = &((hc_vapi_interface_t*)data->buffer)[data->current];
+  hc_vapi_interface_t *swif =
+      &((hc_vapi_interface_t *)data->buffer)[data->current];
 
   swif[0].swif = reply->sw_if_index;
   memcpy(swif[0].interface_name, reply->interface_name, INTERFACE_LEN);
@@ -327,7 +284,6 @@ static vapi_error_e listener_list_complete_cb (
   return rv;
 }
 
-
 /* LISTENER LIST */
 static int _hc_listener_list(hc_sock_t *socket, hc_data_t **pdata) {
   hc_sock_vpp_t *s = TO_HC_SOCK_VPP(socket);
@@ -344,14 +300,14 @@ static int _hc_listener_list(hc_sock_t *socket, hc_data_t **pdata) {
   hicnp_msg->payload.sw_if_index = ~0;
   hicnp_msg->payload.name_filter_valid = 0;
 
-  hc_data_t *data = hc_data_create(0, sizeof(hc_vapi_interface_t),NULL);
+  hc_data_t *data = hc_data_create(0, sizeof(hc_vapi_interface_t), NULL);
 
   if (!data) {
     retval = -1;
     goto END;
   }
 
-  hc_data_t *data2 = hc_data_create(0, 1,NULL);
+  hc_data_t *data2 = hc_data_create(0, 1, NULL);
 
   if (!data2) {
     retval = -1;
@@ -362,12 +318,13 @@ static int _hc_listener_list(hc_sock_t *socket, hc_data_t **pdata) {
   data->size = 1;
 
   if (!data->buffer) {
-    free (data);
+    free(data);
     retval = -1;
     goto FREE_DATA;
   }
 
-  int ret = vapi_sw_interface_dump(s->g_vapi_ctx_instance, hicnp_msg, listener_list_complete_cb, data);
+  int ret = vapi_sw_interface_dump(s->g_vapi_ctx_instance, hicnp_msg,
+                                   listener_list_complete_cb, data);
 
   if (ret != VAPI_OK) {
     free(data->buffer);
@@ -381,28 +338,34 @@ static int _hc_listener_list(hc_sock_t *socket, hc_data_t **pdata) {
   data2->out_element_size = 1;
 
   if (!data2->buffer) {
-    free (data2->buffer);
-    retval =1 -1;
+    free(data2->buffer);
+    retval = -1;
     goto CLEAN;
   }
 
   /* Query the forwarder for each interface */
-  for(int i = 0; i < data->current; i++) {
+  for (int i = 0; i < data->current; i++) {
     int index = data2->current;
-    vapi_msg_ip_address_dump* msg = vapi_alloc_ip_address_dump(s->g_vapi_ctx_instance);
+    vapi_msg_ip_address_dump *msg =
+        vapi_alloc_ip_address_dump(s->g_vapi_ctx_instance);
     msg->payload.sw_if_index = ((hc_vapi_interface_t *)data->buffer)[i].swif;
     msg->payload.is_ipv6 = 0;
-    retval = vapi_ip_address_dump(s->g_vapi_ctx_instance, msg, process_ip_info, data2);
-    vapi_msg_ip_address_dump* msg2 = vapi_alloc_ip_address_dump(s->g_vapi_ctx_instance);
+    retval = vapi_ip_address_dump(s->g_vapi_ctx_instance, msg, process_ip_info,
+                                  data2);
+    vapi_msg_ip_address_dump *msg2 =
+        vapi_alloc_ip_address_dump(s->g_vapi_ctx_instance);
 
     if (retval) goto CLEAN;
 
     msg2->payload.sw_if_index = ((hc_vapi_interface_t *)data->buffer)[i].swif;
     msg2->payload.is_ipv6 = 1;
-    retval = vapi_ip_address_dump(s->g_vapi_ctx_instance, msg2, process_ip_info, data2);
+    retval = vapi_ip_address_dump(s->g_vapi_ctx_instance, msg2, process_ip_info,
+                                  data2);
     for (size_t j = index; j < data2->current; j++) {
-      memcpy(((hc_listener_t *)(data2->buffer))[j].interface_name, ((hc_vapi_interface_t*)(data->buffer))[i].interface_name, INTERFACE_LEN);
-      ((hc_listener_t *)(data2->buffer))[j].type = CONNECTION_TYPE_HICN;
+      memcpy(((hc_listener_t *)(data2->buffer))[j].interface_name,
+             ((hc_vapi_interface_t *)(data->buffer))[i].interface_name,
+             INTERFACE_LEN);
+      ((hc_listener_t *)(data2->buffer))[j].type = FACE_TYPE_HICN;
     }
 
     if (retval) goto CLEAN;
@@ -417,7 +380,7 @@ FREE_DATA:
   data2->size = data2->current;
   data2->out_element_size = sizeof(hc_listener_t);
   *pdata = data2;
- END:
+END:
   vapi_unlock();
   return retval;
 }
@@ -438,7 +401,8 @@ static int _hc_connection_create(hc_sock_t *s, hc_connection_t *connection) {
   return -1;
 }
 
-static int _hc_connection_create_async(hc_sock_t *s, hc_connection_t *connection) {
+static int _hc_connection_create_async(hc_sock_t *s,
+                                       hc_connection_t *connection) {
   // NOT IMPLEMENTED
   return -1;
 }
@@ -446,17 +410,20 @@ static int _hc_connection_create_async(hc_sock_t *s, hc_connection_t *connection
 /* CONNECTION GET */
 
 static int _hc_connection_get(hc_sock_t *s, hc_connection_t *connection,
-                      hc_connection_t **connection_found) {
+                              hc_connection_t **connection_found) {
   // NOT IMPLEMENTED
   return -1;
 }
 
-static int _hc_connection_update_by_id(hc_sock_t *s, int hc_connection_id, hc_connection_t *connection) {
+static int _hc_connection_update_by_id(hc_sock_t *s, int hc_connection_id,
+                                       hc_connection_t *connection) {
   // Not implemented
   return -1;
 }
 
-static int  _hc_connection_update(hc_sock_t *s, hc_connection_t *connection_current, hc_connection_t *connection_updated) {
+static int _hc_connection_update(hc_sock_t *s,
+                                 hc_connection_t *connection_current,
+                                 hc_connection_t *connection_updated) {
   // Not implemented
   return -1;
 }
@@ -468,7 +435,8 @@ static int _hc_connection_delete(hc_sock_t *s, hc_connection_t *connection) {
   return -1;
 }
 
-static int _hc_connection_delete_async(hc_sock_t *s, hc_connection_t *connection) {
+static int _hc_connection_delete_async(hc_sock_t *s,
+                                       hc_connection_t *connection) {
   // NOT IMPLEMENTED
   return -1;
 }
@@ -487,39 +455,47 @@ static int _hc_connection_list_async(hc_sock_t *s, hc_data_t **pdata) {
 
 /* CONNECTION SET ADMIN STATE */
 
-static int _hc_connection_set_admin_state(hc_sock_t *s, const char *conn_id_or_name,
-                                  face_state_t state) {
+static int _hc_connection_set_admin_state(hc_sock_t *s,
+                                          const char *conn_id_or_name,
+                                          face_state_t state) {
   // NOT IMPLEMENTED
   return -1;
 }
 
 static int _hc_connection_set_admin_state_async(hc_sock_t *s,
-                                        const char *conn_id_or_name,
-                                        face_state_t state) {
+                                                const char *conn_id_or_name,
+                                                face_state_t state) {
   // NOT IMPLEMENTED
   return -1;
 }
 
 #ifdef WITH_POLICY
 
-static int _hc_connection_set_priority(hc_sock_t * s, const char * conn_id_or_name, uint32_t priority) {
+static int _hc_connection_set_priority(hc_sock_t *s,
+                                       const char *conn_id_or_name,
+                                       uint32_t priority) {
   // NOT IMPLEMENTED
   return -1;
 }
 
-static int _hc_connection_set_priority_async(hc_sock_t * s, const char * conn_id_or_name, uint32_t priority) {
+static int _hc_connection_set_priority_async(hc_sock_t *s,
+                                             const char *conn_id_or_name,
+                                             uint32_t priority) {
   // NOT IMPLEMENTED
   return -1;
 }
 
-#endif // WITH_POLICY
+#endif  // WITH_POLICY
 
-static int _hc_connection_set_tags(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t tags) {
+static int _hc_connection_set_tags(hc_sock_t *s, const char *conn_id_or_name,
+                                   policy_tags_t tags) {
   // NOT IMPLEMENTED
   return -1;
 }
 
-static int _hc_connection_set_tags_async(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t tags) {
+static int _hc_connection_set_tags_async(hc_sock_t *s,
+                                         const char *conn_id_or_name,
+                                         policy_tags_t tags) {
   // NOT IMPLEMENTED
   return -1;
 }
@@ -528,66 +504,65 @@ static int _hc_connection_set_tags_async(hc_sock_t * s, const char * conn_id_or_
  * Routes
  *----------------------------------------------------------------------------*/
 
-static vapi_error_e create_udp_tunnel_cb( vapi_ctx_t ctx,
-				void *callback_ctx,
-				vapi_error_e rv,
-				bool is_last,
-				vapi_payload_hicn_api_udp_tunnel_add_del_reply *reply) {
-  if (reply == NULL || rv != VAPI_OK)
-    return rv;
+static vapi_error_e create_udp_tunnel_cb(
+    vapi_ctx_t ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_hicn_api_udp_tunnel_add_del_reply *reply) {
+  if (reply == NULL || rv != VAPI_OK) return rv;
 
-  if (reply->retval != VAPI_OK)
-    return reply->retval;
+  if (reply->retval != VAPI_OK) return reply->retval;
 
-  u32 * uei = (u32*) callback_ctx;
+  u32 *uei = (u32 *)callback_ctx;
   *uei = reply->uei;
 
   return reply->retval;
 }
 
 /* ROUTE CREATE */
-static vapi_error_e parse_route_create( vapi_ctx_t ctx,
-				void *callback_ctx,
-				vapi_error_e rv,
-				bool is_last,
-				vapi_payload_ip_route_add_del_reply *reply) {
-  if (reply == NULL || rv != VAPI_OK)
-    return rv;
+static vapi_error_e parse_route_create(
+    vapi_ctx_t ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_ip_route_add_del_reply *reply) {
+  if (reply == NULL || rv != VAPI_OK) return rv;
 
-  if (reply->retval != VAPI_OK)
-    return reply->retval;
+  if (reply->retval != VAPI_OK) return reply->retval;
 
   return reply->retval;
 }
 
-static vapi_error_e hicn_enable_cb( vapi_ctx_t ctx,
-                              void *callback_ctx,
-                              vapi_error_e rv,
-                              bool is_last,
-                              vapi_payload_hicn_api_enable_disable_reply *reply) {
-  if (reply == NULL || rv != VAPI_OK)
-    return rv;
+static vapi_error_e hicn_enable_cb(
+    vapi_ctx_t ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_hicn_api_enable_disable_reply *reply) {
+  if (reply == NULL || rv != VAPI_OK) return rv;
+  face_id_t *faceid = (face_id_t *)callback_ctx;
+
+  if (reply->nfaces) {
+    *faceid = reply->faceids[0];
+  }
 
   return reply->retval;
 }
 
-static int _hc_route_create_internal(hc_sock_t *socket, hc_route_t *route, bool async) {
+static int _hc_route_create_internal(hc_sock_t *socket, hc_route_t *route,
+                                     bool async) {
   if (!IS_VALID_FAMILY(route->family)) return -1;
 
   hc_sock_vpp_t *s = TO_HC_SOCK_VPP(socket);
-  int ret;
+  int ret = -1;
   vapi_lock();
 
-  vapi_msg_ip_route_add_del *hicnp_msg = vapi_alloc_ip_route_add_del(s->g_vapi_ctx_instance, 1);
+  vapi_msg_ip_route_add_del *hicnp_msg =
+      vapi_alloc_ip_route_add_del(s->g_vapi_ctx_instance, 1);
 
   hicnp_msg->payload.is_add = 1;
   if (route->family == AF_INET) {
-    memcpy(&hicnp_msg->payload.route.prefix.address.un.ip4[0], &route->remote_addr.v4, 4);
+    memcpy(&hicnp_msg->payload.route.prefix.address.un.ip4[0],
+           &route->remote_addr.v4, 4);
     hicnp_msg->payload.route.prefix.address.af = ADDRESS_IP4;
-  }
-  else {
-    memcpy(&hicnp_msg->payload.route.prefix.address.un.ip6[0], &route->remote_addr.v6, 16);
+    hicnp_msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP4;
+  } else {
+    memcpy(&hicnp_msg->payload.route.prefix.address.un.ip6[0],
+           &route->remote_addr.v6, 16);
     hicnp_msg->payload.route.prefix.address.af = ADDRESS_IP6;
+    hicnp_msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP6;
   }
 
   hicnp_msg->payload.route.prefix.len = route->len;
@@ -596,87 +571,101 @@ static int _hc_route_create_internal(hc_sock_t *socket, hc_route_t *route, bool
   hicnp_msg->payload.route.paths[0].table_id = 0;
 
   hc_face_t *face = &(route->face);
-  switch (face->face.type) {
-    case FACE_TYPE_HICN:
-      {
-        if (ip46_address_is_ip4((ip46_address_t *)(&(face->face.remote_addr)))) {
-          memcpy(&(hicnp_msg->payload.route.paths[0].nh.address.ip4), &face->face.remote_addr.v4, sizeof(ip4_address_t));
-          hicnp_msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP4;
-        }
-        else{
-          memcpy(&(hicnp_msg->payload.route.paths[0].nh.address.ip6), &face->face.remote_addr.v6, sizeof(ip6_address_t));
-          hicnp_msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP6;
-        }
-
-        hicnp_msg->payload.route.paths[0].type = FIB_API_PATH_FLAG_NONE;
-        hicnp_msg->payload.route.paths[0].flags = FIB_API_PATH_FLAG_NONE;
-
-        break;
-      }
-    case FACE_TYPE_UDP:
-      {
-        vapi_msg_hicn_api_udp_tunnel_add_del *msg = NULL;
-        u32 uei = ~0;
-
-        if (ip46_address_is_ip4((ip46_address_t *)(&(face->face.remote_addr))) &&
-            ip46_address_is_ip4((ip46_address_t *)(&(face->face.local_addr)))) {
 
-          msg = vapi_alloc_hicn_api_udp_tunnel_add_del(s->g_vapi_ctx_instance);
-          memcpy(msg->payload.src_addr.un.ip4, &face->face.local_addr.v4, sizeof(ip4_address_t));
-          msg->payload.src_addr.af = ADDRESS_IP4;
+  face->face.netdevice.index = ~0;
+  face->id = INVALID_FACE_ID;
 
-          memcpy(msg->payload.dst_addr.un.ip4, &face->face.remote_addr.v4, sizeof(ip4_address_t));
-          msg->payload.dst_addr.af = ADDRESS_IP4;
+  switch (face->face.type) {
+    case FACE_TYPE_HICN: {
+      if (ip_address_is_v4((ip_address_t *)(&(face->face.remote_addr)))) {
+        memcpy(&(hicnp_msg->payload.route.paths[0].nh.address.ip4),
+               &face->face.remote_addr.v4, sizeof(ip4_address_t));
+        hicnp_msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP4;
+      } else {
+        memcpy(&(hicnp_msg->payload.route.paths[0].nh.address.ip6),
+               &face->face.remote_addr.v6, sizeof(ip6_address_t));
+        hicnp_msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP6;
+      }
 
-        } else if (!ip46_address_is_ip4((ip46_address_t *)(&(route->face.face.remote_addr))) &&
-                  !ip46_address_is_ip4((ip46_address_t *)(&(route->face.face.local_addr)))) {
+      hicnp_msg->payload.route.paths[0].type = FIB_API_PATH_TYPE_NORMAL;
+      hicnp_msg->payload.route.paths[0].flags = FIB_API_PATH_FLAG_NONE;
 
-          msg = vapi_alloc_hicn_api_udp_tunnel_add_del(s->g_vapi_ctx_instance);
-          memcpy(msg->payload.src_addr.un.ip6, &face->face.local_addr.v6, sizeof(ip6_address_t));
-          msg->payload.src_addr.af = ADDRESS_IP4;
+      break;
+    }
+    case FACE_TYPE_UDP: {
+      vapi_msg_hicn_api_udp_tunnel_add_del *msg = NULL;
+      u32 uei = ~0;
+
+      if (ip_address_is_v4((ip_address_t *)(&(face->face.remote_addr))) &&
+          ip_address_is_v4((ip_address_t *)(&(face->face.local_addr)))) {
+        msg = vapi_alloc_hicn_api_udp_tunnel_add_del(s->g_vapi_ctx_instance);
+        memcpy(msg->payload.src_addr.un.ip4, &face->face.local_addr.v4,
+               sizeof(ip4_address_t));
+        msg->payload.src_addr.af = ADDRESS_IP4;
+
+        memcpy(msg->payload.dst_addr.un.ip4, &face->face.remote_addr.v4,
+               sizeof(ip4_address_t));
+        msg->payload.dst_addr.af = ADDRESS_IP4;
+
+      } else if (!ip_address_is_v4(
+                     (ip_address_t *)(&(route->face.face.remote_addr))) &&
+                 !ip_address_is_v4(
+                     (ip_address_t *)(&(route->face.face.local_addr)))) {
+        msg = vapi_alloc_hicn_api_udp_tunnel_add_del(s->g_vapi_ctx_instance);
+        memcpy(msg->payload.src_addr.un.ip6, &face->face.local_addr.v6,
+               sizeof(ip6_address_t));
+        msg->payload.src_addr.af = ADDRESS_IP6;
+
+        memcpy(msg->payload.dst_addr.un.ip6, &face->face.remote_addr.v6,
+               sizeof(ip6_address_t));
+        msg->payload.dst_addr.af = ADDRESS_IP6;
+      } else {
+        // NOT IMPLEMENTED
+        ret = -1;
+        goto done;
+      }
 
-          memcpy(msg->payload.dst_addr.un.ip6, &face->face.remote_addr.v6, sizeof(ip6_address_t));
-          msg->payload.dst_addr.af = ADDRESS_IP6;
+      msg->payload.src_port = face->face.local_port;
+      msg->payload.dst_port = face->face.remote_port;
+      msg->payload.is_add = 1;
 
-        } else {
-          //NOT IMPLEMENTED
-          ret = -1;
-          goto done;
-        }
+      int ret = vapi_hicn_api_udp_tunnel_add_del(s->g_vapi_ctx_instance, msg,
+                                                 create_udp_tunnel_cb, &uei);
 
-        msg->payload.src_port = face->face.local_port;
-        msg->payload.dst_port = face->face.remote_port;
-        msg->payload.is_add = 1;
+      if (ret) {
+        ERROR("Error in vapi_hicn_api_udp_tunnel_add_del");
+        vapi_msg_free(s->g_vapi_ctx_instance, hicnp_msg);
+        goto done;
+      }
 
-        int ret = vapi_hicn_api_udp_tunnel_add_del(s->g_vapi_ctx_instance, msg, create_udp_tunnel_cb, &uei);
+      hicnp_msg->payload.route.paths[0].type = FIB_API_PATH_TYPE_UDP_ENCAP;
+      hicnp_msg->payload.route.paths[0].flags = FIB_API_PATH_FLAG_NONE;
+      hicnp_msg->payload.route.paths[0].nh.obj_id = uei;
 
-        if(ret) {
-          vapi_msg_free(s->g_vapi_ctx_instance, hicnp_msg);
-          goto done;
-        }
+      face->face.netdevice.index = uei;
 
-        hicnp_msg->payload.route.paths[0].type = FIB_API_PATH_TYPE_UDP_ENCAP;
-        hicnp_msg->payload.route.paths[0].flags = FIB_API_PATH_FLAG_NONE;
-        hicnp_msg->payload.route.paths[0].nh.obj_id = uei;
-        break;
-      }
+      break;
+    }
     default:
       ret = -1;
       goto done;
   }
 
-  ret = vapi_ip_route_add_del(s->g_vapi_ctx_instance, hicnp_msg, parse_route_create, NULL);
+  ret = vapi_ip_route_add_del(s->g_vapi_ctx_instance, hicnp_msg,
+                              parse_route_create, NULL);
 
-  if (ret)
+  if (ret) {
+    ERROR("Error in vapi_ip_route_add_del");
     goto done;
+  }
 
-  vapi_msg_hicn_api_enable_disable *msg = vapi_alloc_hicn_api_enable_disable(s->g_vapi_ctx_instance);
+  vapi_msg_hicn_api_enable_disable *msg =
+      vapi_alloc_hicn_api_enable_disable(s->g_vapi_ctx_instance);
 
   if (route->family == AF_INET) {
     memcpy(&msg->payload.prefix.address.un.ip4[0], &route->remote_addr.v4, 4);
     msg->payload.prefix.address.af = ADDRESS_IP4;
-  }
-  else {
+  } else {
     memcpy(&msg->payload.prefix.address.un.ip6[0], &route->remote_addr.v6, 16);
     msg->payload.prefix.address.af = ADDRESS_IP6;
   }
@@ -684,7 +673,13 @@ static int _hc_route_create_internal(hc_sock_t *socket, hc_route_t *route, bool
   msg->payload.prefix.len = route->len;
   msg->payload.enable_disable = 1;
 
-  ret = vapi_hicn_api_enable_disable(s->g_vapi_ctx_instance, msg, hicn_enable_cb, NULL);
+  ret = vapi_hicn_api_enable_disable(s->g_vapi_ctx_instance, msg,
+                                     hicn_enable_cb, &face->id);
+
+  if (ret) {
+    ERROR("Error in vapi_hicn_api_enable_disable");
+  }
+
 done:
   vapi_unlock();
   return ret;
@@ -699,32 +694,63 @@ static int _hc_route_create_async(hc_sock_t *s, hc_route_t *route) {
 }
 
 /* ROUTE DELETE */
-static vapi_error_e parse_route_delete( vapi_ctx_t ctx,
-				void *callback_ctx,
-				vapi_error_e rv,
-				bool is_last,
-				vapi_payload_ip_route_add_del_reply *reply) {
-  if (reply == NULL || rv != VAPI_OK)
-    return rv;
+static vapi_error_e parse_route_delete(
+    vapi_ctx_t ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_ip_route_add_del_reply *reply) {
+  if (reply == NULL || rv != VAPI_OK) return rv;
+
+  return reply->retval;
+}
+
+static vapi_error_e hicn_disable_cb(
+    vapi_ctx_t ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_hicn_api_enable_disable_reply *reply) {
+  if (reply == NULL || rv != VAPI_OK) return rv;
 
   return reply->retval;
 }
 
-static int _hc_route_delete_internal(hc_sock_t *socket, hc_route_t *route, bool async) {
+static int _hc_route_delete_internal(hc_sock_t *socket, hc_route_t *route,
+                                     bool async) {
   if (!IS_VALID_FAMILY(route->family)) return -1;
 
   hc_sock_vpp_t *s = TO_HC_SOCK_VPP(socket);
 
   vapi_lock();
-  vapi_msg_ip_route_add_del *hicnp_msg = vapi_alloc_ip_route_add_del(s->g_vapi_ctx_instance, 1);
+
+  vapi_msg_hicn_api_enable_disable *msg =
+      vapi_alloc_hicn_api_enable_disable(s->g_vapi_ctx_instance);
+
+  if (route->family == AF_INET) {
+    memcpy(&msg->payload.prefix.address.un.ip4[0], &route->remote_addr.v4, 4);
+    msg->payload.prefix.address.af = ADDRESS_IP4;
+  } else {
+    memcpy(&msg->payload.prefix.address.un.ip6[0], &route->remote_addr.v6, 16);
+    msg->payload.prefix.address.af = ADDRESS_IP6;
+  }
+
+  msg->payload.prefix.len = route->len;
+  msg->payload.enable_disable = 0;
+
+  vapi_error_e ret = vapi_hicn_api_enable_disable(s->g_vapi_ctx_instance, msg,
+                                                  hicn_disable_cb, NULL);
+
+  if (ret) {
+    ERROR("Error in vapi_hicn_api_enable_disable in route delete");
+    goto done;
+  }
+
+  vapi_msg_ip_route_add_del *hicnp_msg =
+      vapi_alloc_ip_route_add_del(s->g_vapi_ctx_instance, 1);
 
   hicnp_msg->payload.is_add = 0;
   if (route->family == AF_INET) {
-    memcpy(&hicnp_msg->payload.route.prefix.address.un.ip4[0], &route->remote_addr.v4, 4);
+    memcpy(&hicnp_msg->payload.route.prefix.address.un.ip4[0],
+           &route->remote_addr.v4, 4);
     hicnp_msg->payload.route.prefix.address.af = ADDRESS_IP4;
-  }
-  else {
-    memcpy(&hicnp_msg->payload.route.prefix.address.un.ip6[0], &route->remote_addr.v6, 16);
+  } else {
+    memcpy(&hicnp_msg->payload.route.prefix.address.un.ip6[0],
+           &route->remote_addr.v6, 16);
     hicnp_msg->payload.route.prefix.address.af = ADDRESS_IP6;
   }
 
@@ -735,34 +761,41 @@ static int _hc_route_delete_internal(hc_sock_t *socket, hc_route_t *route, bool
 
   hc_face_t *face = &(route->face);
   switch (face->face.type) {
-    case FACE_TYPE_HICN:
-      {
-        if (ip46_address_is_ip4((ip46_address_t *)(&(face->face.remote_addr)))) {
-          memcpy(&(hicnp_msg->payload.route.paths[0].nh.address.ip4), &face->face.remote_addr.v4, sizeof(ip4_address_t));
-          hicnp_msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP4;
-        }
-        else{
-          memcpy(&(hicnp_msg->payload.route.paths[0].nh.address.ip6), &face->face.remote_addr.v6, sizeof(ip6_address_t));
-          hicnp_msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP6;
-        }
-
-        hicnp_msg->payload.route.paths[0].type = FIB_API_PATH_FLAG_NONE;
-        hicnp_msg->payload.route.paths[0].flags = FIB_API_PATH_FLAG_NONE;
-
-        break;
-      }
-    case FACE_TYPE_UDP:
-      {
-        hicnp_msg->payload.route.paths[0].type = FIB_API_PATH_TYPE_UDP_ENCAP;
-        hicnp_msg->payload.route.paths[0].flags = FIB_API_PATH_FLAG_NONE;
-        hicnp_msg->payload.route.paths[0].nh.obj_id = face->face.netdevice.index;
-        break;
+    case FACE_TYPE_HICN: {
+      if (ip_address_is_v4((ip_address_t *)(&(face->face.remote_addr)))) {
+        memcpy(&(hicnp_msg->payload.route.paths[0].nh.address.ip4),
+               &face->face.remote_addr.v4, sizeof(ip4_address_t));
+        hicnp_msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP4;
+      } else {
+        memcpy(&(hicnp_msg->payload.route.paths[0].nh.address.ip6),
+               &face->face.remote_addr.v6, sizeof(ip6_address_t));
+        hicnp_msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP6;
       }
+
+      hicnp_msg->payload.route.paths[0].type = FIB_API_PATH_TYPE_NORMAL;
+      hicnp_msg->payload.route.paths[0].flags = FIB_API_PATH_FLAG_NONE;
+
+      break;
+    }
+    case FACE_TYPE_UDP: {
+      hicnp_msg->payload.route.paths[0].type = FIB_API_PATH_TYPE_UDP_ENCAP;
+      hicnp_msg->payload.route.paths[0].flags = FIB_API_PATH_FLAG_NONE;
+      hicnp_msg->payload.route.paths[0].nh.obj_id = face->face.netdevice.index;
+      break;
+    }
     default:
       return -1;
   }
 
-  vapi_error_e ret = vapi_ip_route_add_del(s->g_vapi_ctx_instance, hicnp_msg, parse_route_delete, NULL);
+  ret = vapi_ip_route_add_del(s->g_vapi_ctx_instance, hicnp_msg,
+                              parse_route_delete, NULL);
+
+  if (ret) {
+    ERROR("Error in vapi_ip_route_add_del in route delete");
+    goto done;
+  }
+
+done:
 
   vapi_unlock();
   return ret;
@@ -776,33 +809,31 @@ static int _hc_route_delete_async(hc_sock_t *s, hc_route_t *route) {
   return _hc_route_delete_internal(s, route, true);
 }
 
-static vapi_error_e parse_udp_encap_list( vapi_ctx_t ctx,
-			      void *callback_ctx,
-			      vapi_error_e rv,
-			      bool is_last,
-			      vapi_payload_udp_encap_details *reply) {
-  if (reply == NULL || rv != VAPI_OK)
-    return rv;
+static vapi_error_e parse_udp_encap_list(
+    vapi_ctx_t ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_udp_encap_details *reply) {
+  if (reply == NULL || rv != VAPI_OK) return rv;
 
-  hc_face_t * face = (hc_face_t *)callback_ctx;
+  hc_face_t *face = (hc_face_t *)callback_ctx;
 
-  if (face->face.netdevice.index == reply->udp_encap.id)
-  {
-    switch(reply->udp_encap.src_ip.af) {
-      case ADDRESS_IP4:
-      {
-        memcpy(&face->face.local_addr.v4, &(reply->udp_encap.src_ip.un.ip4), sizeof(ip4_address_t));
-        memcpy(&face->face.remote_addr.v4, &(reply->udp_encap.dst_ip.un.ip4), sizeof(ip4_address_t));
+  if (face->face.netdevice.index == reply->udp_encap.id) {
+    switch (reply->udp_encap.src_ip.af) {
+      case ADDRESS_IP4: {
+        memcpy(&face->face.local_addr.v4, &(reply->udp_encap.src_ip.un.ip4),
+               sizeof(ip4_address_t));
+        memcpy(&face->face.remote_addr.v4, &(reply->udp_encap.dst_ip.un.ip4),
+               sizeof(ip4_address_t));
         break;
       }
-      case ADDRESS_IP6:
-      {
-        memcpy(&face->face.local_addr.v6, &(reply->udp_encap.src_ip.un.ip6), sizeof(ip6_address_t));
-        memcpy(&face->face.remote_addr.v6, &(reply->udp_encap.dst_ip.un.ip6), sizeof(ip6_address_t));
+      case ADDRESS_IP6: {
+        memcpy(&face->face.local_addr.v6, &(reply->udp_encap.src_ip.un.ip6),
+               sizeof(ip6_address_t));
+        memcpy(&face->face.remote_addr.v6, &(reply->udp_encap.dst_ip.un.ip6),
+               sizeof(ip6_address_t));
         break;
       }
       default:
-      break;
+        break;
     }
 
     face->face.local_port = reply->udp_encap.src_port;
@@ -811,35 +842,35 @@ static vapi_error_e parse_udp_encap_list( vapi_ctx_t ctx,
   return rv;
 }
 
-static int _fill_face_with_info(hc_face_t * face, vapi_type_fib_path *path, hc_sock_t *s) {
-  switch(path->type){
-    case FIB_API_PATH_FLAG_NONE:
-    {
+static int _fill_face_with_info(hc_face_t *face, vapi_type_fib_path *path,
+                                hc_sock_t *s) {
+  switch (path->type) {
+    case FIB_API_PATH_FLAG_NONE: {
       face->face.type = FACE_TYPE_HICN;
-      switch(path->proto){
+      switch (path->proto) {
         case FIB_API_PATH_NH_PROTO_IP4:
-          memcpy(&face->face.remote_addr.v4, &(path->nh.address.ip4), sizeof(ip4_address_t));
-        break;
+          memcpy(&face->face.remote_addr.v4, &(path->nh.address.ip4),
+                 sizeof(ip4_address_t));
+          break;
         case FIB_API_PATH_NH_PROTO_IP6:
-          memcpy(&face->face.remote_addr.v6, &(path->nh.address.ip6), sizeof(ip6_address_t));
-        break;
+          memcpy(&face->face.remote_addr.v6, &(path->nh.address.ip6),
+                 sizeof(ip6_address_t));
+          break;
         default:
-        break;
+          break;
       }
       face->face.netdevice.index = path->sw_if_index;
-    }
-    break;
-    case FIB_API_PATH_TYPE_UDP_ENCAP:
-    {
+    } break;
+    case FIB_API_PATH_TYPE_UDP_ENCAP: {
       face->face.type = FACE_TYPE_UDP;
       face->face.netdevice.index = clib_net_to_host_u32(path->nh.obj_id);
       // Let's make the compiler happy
       (void)parse_udp_encap_list;
-      //vapi_msg_udp_encap_dump *msg;
-      //msg = vapi_alloc_udp_encap_dump(s->g_vapi_ctx_instance);
-      //vapi_udp_encap_dump(s->g_vapi_ctx_instance, msg, parse_udp_encap_list, face);
-    }
-    break;
+      // vapi_msg_udp_encap_dump *msg;
+      // msg = vapi_alloc_udp_encap_dump(s->g_vapi_ctx_instance);
+      // vapi_udp_encap_dump(s->g_vapi_ctx_instance, msg, parse_udp_encap_list,
+      // face);
+    } break;
     default:
       return -1;
   }
@@ -852,32 +883,33 @@ typedef struct hicn_route_socket_s {
   hc_sock_t *s;
 } hicn_route_socket_t;
 
-static vapi_error_e parse_route_list( vapi_ctx_t ctx,
-			      void *callback_ctx,
-			      vapi_error_e rv,
-			      bool is_last,
-			      vapi_payload_ip_route_details *reply) {
-
-  if (reply == NULL || rv != VAPI_OK)
-    return rv;
+static vapi_error_e parse_route_list(vapi_ctx_t ctx, void *callback_ctx,
+                                     vapi_error_e rv, bool is_last,
+                                     vapi_payload_ip_route_details *reply) {
+  if (reply == NULL || rv != VAPI_OK) return rv;
 
   hicn_route_socket_t *rs = (hicn_route_socket_t *)callback_ctx;
   hc_data_t *data = rs->data;
 
   u8 found = false;
-  for (int j = 0; j < reply->route.n_paths; j++){
+  for (int j = 0; j < reply->route.n_paths; j++) {
     for (int i = 0; i < data->size && !found; i++) {
-      hc_route_t * route = &((hc_route_t*)(data->buffer))[i];
-
-      if(ip46_address_is_ip4((ip46_address_t *)&(route->remote_addr)) &&
-        memcmp(route->remote_addr.v4.as_u8, reply->route.prefix.address.un.ip4, sizeof(ip4_address_t)) == 0 &&
-        route->len == reply->route.prefix.len && route->face_id == ~0) {
-          _fill_face_with_info(&(route->face), &reply->route.paths[j], rs->s);
-          found = true;
-      } else if (memcmp(route->remote_addr.v6.as_u8, reply->route.prefix.address.un.ip6, sizeof(ip6_address_t)) == 0 &&
-                route->len == reply->route.prefix.len && route->face_id == ~0) {
-          _fill_face_with_info(&(route->face), &reply->route.paths[j], rs->s);
-          found = true;
+      hc_route_t *route = &((hc_route_t *)(data->buffer))[i];
+
+      if (ip_address_is_v4((ip_address_t *)&(route->remote_addr)) &&
+          memcmp(route->remote_addr.v4.as_u8,
+                 reply->route.prefix.address.un.ip4,
+                 sizeof(ip4_address_t)) == 0 &&
+          route->len == reply->route.prefix.len && route->face_id == ~0) {
+        _fill_face_with_info(&(route->face), &reply->route.paths[j], rs->s);
+        found = true;
+      } else if (memcmp(route->remote_addr.v6.as_u8,
+                        reply->route.prefix.address.un.ip6,
+                        sizeof(ip6_address_t)) == 0 &&
+                 route->len == reply->route.prefix.len &&
+                 route->face_id == ~0) {
+        _fill_face_with_info(&(route->face), &reply->route.paths[j], rs->s);
+        found = true;
       }
     }
   }
@@ -885,14 +917,10 @@ static vapi_error_e parse_route_list( vapi_ctx_t ctx,
   return rv;
 }
 
-static vapi_error_e parse_hicn_route_list( vapi_ctx_t ctx,
-			      void *callback_ctx,
-			      vapi_error_e rv,
-			      bool is_last,
-			      vapi_payload_hicn_api_routes_details *reply) {
-
-  if (reply == NULL || rv != VAPI_OK)
-    return rv;
+static vapi_error_e parse_hicn_route_list(
+    vapi_ctx_t ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_hicn_api_routes_details *reply) {
+  if (reply == NULL || rv != VAPI_OK) return rv;
 
   hc_data_t *data = (hc_data_t *)callback_ctx;
 
@@ -900,43 +928,41 @@ static vapi_error_e parse_hicn_route_list( vapi_ctx_t ctx,
   if (empty_spots < reply->nfaces) {
     int new_size = data->size + (reply->nfaces - empty_spots);
     data->buffer = realloc(data->buffer, sizeof(hc_route_t) * (new_size));
-    if (!data->buffer)
-      return VAPI_ENOMEM;
+    if (!data->buffer) return VAPI_ENOMEM;
 
-    data->size =new_size;
+    data->size = new_size;
   }
 
   for (int i = 0; i < reply->nfaces; i++) {
-    hc_route_t * route = &((hc_route_t*)(data->buffer))[data->current];
+    hc_route_t *route = &((hc_route_t *)(data->buffer))[data->current];
     route->face_id = ~0;
     route->cost = 1;
     route->len = reply->prefix.len;
-    if (reply->prefix.address.af == ADDRESS_IP6)
-      {
-        memcpy(route->remote_addr.v6.as_u8, reply->prefix.address.un.ip6, 16);
-      }
-      else
-      {
-        memcpy(route->remote_addr.v4.as_u8, reply->prefix.address.un.ip4, 4);
-      }
-    route->family = reply->prefix.address.af == ADDRESS_IP6? AF_INET6 : AF_INET;
+    if (reply->prefix.address.af == ADDRESS_IP6) {
+      memcpy(route->remote_addr.v6.as_u8, reply->prefix.address.un.ip6, 16);
+    } else {
+      memcpy(route->remote_addr.v4.as_u8, reply->prefix.address.un.ip4, 4);
+    }
+    route->family =
+        reply->prefix.address.af == ADDRESS_IP6 ? AF_INET6 : AF_INET;
     data->current++;
   }
 
   return rv;
 }
 
-static int _hc_route_list_internal(hc_sock_t *socket, hc_data_t **pdata, bool async) {
+static int _hc_route_list_internal(hc_sock_t *socket, hc_data_t **pdata,
+                                   bool async) {
   hc_sock_vpp_t *s = TO_HC_SOCK_VPP(socket);
   vapi_lock();
 
   vapi_msg_hicn_api_routes_dump *msg;
   msg = vapi_alloc_hicn_api_routes_dump(s->g_vapi_ctx_instance);
 
-  hc_data_t *data = hc_data_create(0, sizeof(hc_route_t),NULL);
+  hc_data_t *data = hc_data_create(0, sizeof(hc_route_t), NULL);
   int ret = VAPI_OK;
 
-  if (!data){
+  if (!data) {
     ret = -1;
     goto err;
   }
@@ -949,10 +975,10 @@ static int _hc_route_list_internal(hc_sock_t *socket, hc_data_t **pdata, bool as
     goto err_free;
   }
 
-  ret = vapi_hicn_api_routes_dump(s->g_vapi_ctx_instance, msg, parse_hicn_route_list, data);
+  ret = vapi_hicn_api_routes_dump(s->g_vapi_ctx_instance, msg,
+                                  parse_hicn_route_list, data);
 
-  if (ret != VAPI_OK)
-    goto err_free;
+  if (ret != VAPI_OK) goto err_free;
 
   vapi_msg_ip_route_dump *hicnp_msg;
   hicnp_msg = vapi_alloc_ip_route_dump(s->g_vapi_ctx_instance);
@@ -960,29 +986,30 @@ static int _hc_route_list_internal(hc_sock_t *socket, hc_data_t **pdata, bool as
   hicnp_msg->payload.table.is_ip6 = 1;
 
   hicn_route_socket_t ctx = {
-    .data = data,
-    .s = socket,
+      .data = data,
+      .s = socket,
   };
 
-  ret = vapi_ip_route_dump(s->g_vapi_ctx_instance, hicnp_msg, parse_route_list, &ctx);
+  ret = vapi_ip_route_dump(s->g_vapi_ctx_instance, hicnp_msg, parse_route_list,
+                           &ctx);
 
   hicnp_msg = vapi_alloc_ip_route_dump(s->g_vapi_ctx_instance);
   hicnp_msg->payload.table.table_id = 0;
   hicnp_msg->payload.table.is_ip6 = 0;
 
-  ret = vapi_ip_route_dump(s->g_vapi_ctx_instance, hicnp_msg, parse_route_list, &ctx);
+  ret = vapi_ip_route_dump(s->g_vapi_ctx_instance, hicnp_msg, parse_route_list,
+                           &ctx);
 
-  if (ret != VAPI_OK)
-    goto err_free;
+  if (ret != VAPI_OK) goto err_free;
 
   *pdata = data;
 
   vapi_unlock();
   return ret;
 
- err_free:
+err_free:
   free(data);
- err:
+err:
   vapi_unlock();
   return ret;
 }
@@ -1008,17 +1035,19 @@ static int _hc_route_list_async(hc_sock_t *s) {
  *
  *----------------------------------------------------------------------------*/
 
-static int _hc_face_create(hc_sock_t *s, hc_face_t *face) {
-  ERROR("Face creation implemented.");
+static int _hc_face_create(hc_sock_t *socket, hc_face_t *face) {
+  ERROR("Face creation not implemented.");
   return -1;
 }
 
-static int _hc_face_get(hc_sock_t * socket, hc_face_t * face, hc_face_t ** face_found) {
+static int _hc_face_get(hc_sock_t *socket, hc_face_t *face,
+                        hc_face_t **face_found) {
   ERROR("Face deletion not implemented.");
   return -1;
 }
 
-static int _hc_face_delete(hc_sock_t *s, hc_face_t *face) {
+static int _hc_face_delete(hc_sock_t *s, hc_face_t *face,
+                           uint8_t delete_listener) {
   ERROR("Face deletion not implemented.");
   return -1;
 }
@@ -1030,9 +1059,7 @@ static int _hc_face_list(hc_sock_t *s, hc_data_t **pdata) {
   return -1;
 }
 
-static int _hc_face_list_async(hc_sock_t *s) {
-  return 0;
-}
+static int _hc_face_list_async(hc_sock_t *s) { return 0; }
 
 static int _hc_face_set_admin_state(
     hc_sock_t *s, const char *conn_id_or_name,  // XXX wrong identifier
@@ -1041,22 +1068,25 @@ static int _hc_face_set_admin_state(
 }
 
 #ifdef WITH_POLICY
-static int _hc_face_set_priority(hc_sock_t * s, const char * conn_id_or_name, uint32_t priority) {
+static int _hc_face_set_priority(hc_sock_t *s, const char *conn_id_or_name,
+                                 uint32_t priority) {
   ERROR("Face set priority not implemented.");
   return -1;
 }
 
-static int _hc_face_set_tags(hc_sock_t * s, const char * conn_id_or_name, policy_tags_t tags) {
+static int _hc_face_set_tags(hc_sock_t *s, const char *conn_id_or_name,
+                             policy_tags_t tags) {
   ERROR("Face set tags not implemented.");
   return -1;
 }
-#endif // WITH_POLICY
+#endif  // WITH_POLICY
 
 /*----------------------------------------------------------------------------*
  * Punting
  *----------------------------------------------------------------------------*/
 
-static int _hc_punting_create_internal(hc_sock_t *s, hc_punting_t *punting, bool async) {
+static int _hc_punting_create_internal(hc_sock_t *s, hc_punting_t *punting,
+                                       bool async) {
   return -1;
 }
 
@@ -1069,7 +1099,7 @@ static int _hc_punting_create_async(hc_sock_t *s, hc_punting_t *punting) {
 }
 
 static int _hc_punting_get(hc_sock_t *s, hc_punting_t *punting,
-                   hc_punting_t **punting_found) {
+                           hc_punting_t **punting_found) {
   ERROR("hc_punting_get not (yet) implemented.");
   return -1;
 }
@@ -1088,28 +1118,30 @@ static int _hc_punting_list(hc_sock_t *s, hc_data_t **pdata) {
  * Cache
  *----------------------------------------------------------------------------*/
 
-static int _hc_cache_set_store_internal(hc_sock_t *s, int enabled, bool async) {
+static int _hc_cache_set_store_internal(hc_sock_t *s, hc_cache_t *cache,
+                                        bool async) {
   return 0;
 }
 
-static int _hc_cache_set_store(hc_sock_t *s, int enabled) {
-  return _hc_cache_set_store_internal(s, enabled, false);
+static int _hc_cache_set_store(hc_sock_t *s, hc_cache_t *cache) {
+  return _hc_cache_set_store_internal(s, cache, false);
 }
 
-static int _hc_cache_set_store_async(hc_sock_t *s, int enabled) {
-  return _hc_cache_set_store_internal(s, enabled, true);
+static int _hc_cache_set_store_async(hc_sock_t *s, hc_cache_t *cache) {
+  return _hc_cache_set_store_internal(s, cache, true);
 }
 
-static int _hc_cache_set_serve_internal(hc_sock_t *s, int enabled, bool async) {
+static int _hc_cache_set_serve_internal(hc_sock_t *s, hc_cache_t *cache,
+                                        bool async) {
   return 0;
 }
 
-static int _hc_cache_set_serve(hc_sock_t *s, int enabled) {
-  return _hc_cache_set_serve_internal(s, enabled, false);
+static int _hc_cache_set_serve(hc_sock_t *s, hc_cache_t *cache) {
+  return _hc_cache_set_serve_internal(s, cache, false);
 }
 
-static int _hc_cache_set_serve_async(hc_sock_t *s, int enabled) {
-  return _hc_cache_set_serve_internal(s, enabled, true);
+static int _hc_cache_set_serve_async(hc_sock_t *s, hc_cache_t *cache) {
+  return _hc_cache_set_serve_internal(s, cache, true);
 }
 
 /*----------------------------------------------------------------------------*
@@ -1117,12 +1149,15 @@ static int _hc_cache_set_serve_async(hc_sock_t *s, int enabled) {
  *----------------------------------------------------------------------------*/
 
 // per prefix
-static int _hc_strategy_set(hc_sock_t *s /* XXX */) { return 0; }
+static int _hc_strategy_set(hc_sock_t *s, hc_strategy_t *strategy) { return 0; }
 
-static int _hc_strategy_list(hc_sock_t *s, hc_data_t **data) {
+static int _hc_strategy_add_local_prefix(hc_sock_t *s,
+                                         hc_strategy_t *strategy) {
   return 0;
 }
 
+static int _hc_strategy_list(hc_sock_t *s, hc_data_t **data) { return 0; }
+
 /*----------------------------------------------------------------------------*
  * WLDR
  *----------------------------------------------------------------------------*/
@@ -1138,9 +1173,11 @@ static int _hc_mapme_set(hc_sock_t *s, int enabled) { return 0; }
 
 static int _hc_mapme_set_discovery(hc_sock_t *s, int enabled) { return 0; }
 
-static int _hc_mapme_set_timescale(hc_sock_t *s, double timescale) { return 0; }
+static int _hc_mapme_set_timescale(hc_sock_t *s, uint32_t timescale) {
+  return 0;
+}
 
-static int _hc_mapme_set_retx(hc_sock_t *s, double timescale) { return 0; }
+static int _hc_mapme_set_retx(hc_sock_t *s, uint32_t timescale) { return 0; }
 
 /*----------------------------------------------------------------------------*
  * Policy
@@ -1150,51 +1187,99 @@ static int _hc_mapme_set_retx(hc_sock_t *s, double timescale) { return 0; }
 
 /* POLICY CREATE */
 
-static int _hc_policy_create_internal(hc_sock_t * socket, hc_policy_t * policy, bool async) {
+static int _hc_policy_create_internal(hc_sock_t *socket, hc_policy_t *policy,
+                                      bool async) {
   return -1;
 }
 
-static int
-_hc_policy_create(hc_sock_t * s, hc_policy_t * policy) {
+static int _hc_policy_create(hc_sock_t *s, hc_policy_t *policy) {
   return _hc_policy_create_internal(s, policy, false);
 }
 
-static int _hc_policy_create_async(hc_sock_t * s, hc_policy_t * policy) {
+static int _hc_policy_create_async(hc_sock_t *s, hc_policy_t *policy) {
   return _hc_policy_create_internal(s, policy, true);
 }
 
 /* POLICY DELETE */
 
-static int _hc_policy_delete_internal(hc_sock_t * socket, hc_policy_t * policy, bool async) {
+static int _hc_policy_delete_internal(hc_sock_t *socket, hc_policy_t *policy,
+                                      bool async) {
   return -1;
 }
 
-static int _hc_policy_delete(hc_sock_t * s, hc_policy_t * policy) {
+static int _hc_policy_delete(hc_sock_t *s, hc_policy_t *policy) {
   return _hc_policy_delete_internal(s, policy, false);
 }
 
-static int _hc_policy_delete_async(hc_sock_t * s, hc_policy_t * policy) {
+static int _hc_policy_delete_async(hc_sock_t *s, hc_policy_t *policy) {
   return _hc_policy_delete_internal(s, policy, true);
 }
 
 /* POLICY LIST */
 
-static int
-_hc_policy_list_internal(hc_sock_t * socket, hc_data_t ** pdata, bool async) {
+static int _hc_policy_list_internal(hc_sock_t *socket, hc_data_t **pdata,
+                                    bool async) {
   return -1;
 }
 
-static int _hc_policy_list(hc_sock_t * s, hc_data_t ** pdata) {
+static int _hc_policy_list(hc_sock_t *s, hc_data_t **pdata) {
   return _hc_policy_list_internal(s, pdata, false);
 }
 
-static int _hc_policy_list_async(hc_sock_t * s, hc_data_t ** pdata) {
+static int _hc_policy_list_async(hc_sock_t *s, hc_data_t **pdata) {
   return _hc_policy_list_internal(s, pdata, true);
 }
 
 #endif /* WITH_POLICY */
 
-static hc_sock_t hc_sock_vpp_interface = (hc_sock_t) {
+/*----------------------------------------------------------------------------*
+ * Configuration
+ *----------------------------------------------------------------------------*/
+
+typedef struct hc_result_s {
+  void *_;
+} hc_result_t;
+
+static hc_result_t *_hc_listener_create_conf(hc_sock_t *s,
+                                             hc_listener_t *listener) {
+  ERROR("Not implemented.");
+  return NULL;
+}
+static hc_result_t *_hc_connection_create_conf(hc_sock_t *s,
+                                               hc_connection_t *connection) {
+  ERROR("Not implemented.");
+  return NULL;
+}
+static hc_result_t *_hc_route_create_conf(hc_sock_t *s, hc_route_t *route) {
+  ERROR("Not implemented.");
+  return NULL;
+}
+static hc_result_t *_hc_strategy_set_conf(hc_sock_t *s,
+                                          hc_strategy_t *strategy) {
+  ERROR("Not implemented.");
+  return NULL;
+}
+static hc_result_t *_hc_strategy_add_local_prefix_conf(
+    hc_sock_t *s, hc_strategy_t *strategy) {
+  ERROR("Not implemented.");
+  return NULL;
+}
+
+hc_msg_t *_hc_result_get_msg(hc_result_t *result) {
+  ERROR("Not implemented.");
+  return NULL;
+}
+int _hc_result_get_cmd_id(hc_result_t *result) {
+  ERROR("Not implemented.");
+  return -1;
+}
+bool _hc_result_get_success(hc_result_t *result) {
+  ERROR("Not implemented.");
+  return false;
+}
+void _hc_result_free(hc_result_t *result) { free(result); }
+
+static hc_sock_t hc_sock_vpp_interface = (hc_sock_t){
     .hc_sock_get_next_seq = _hc_sock_vpp_get_next_seq,
     .hc_sock_set_nonblocking = _hc_sock_vpp_set_nonblocking,
     .hc_sock_get_fd = _hc_sock_vpp_get_fd,
@@ -1230,7 +1315,7 @@ static hc_sock_t hc_sock_vpp_interface = (hc_sock_t) {
     .hc_connection_set_priority_async = _hc_connection_set_priority_async,
     .hc_connection_set_tags = _hc_connection_set_tags,
     .hc_connection_set_tags_async = _hc_connection_set_tags_async,
-#endif // WITH_POLICY
+#endif  // WITH_POLICY
 
     .hc_face_create = _hc_face_create,
     .hc_face_get = _hc_face_get,
@@ -1242,7 +1327,7 @@ static hc_sock_t hc_sock_vpp_interface = (hc_sock_t) {
 #ifdef WITH_POLICY
     .hc_face_set_priority = _hc_face_set_priority,
     .hc_face_set_tags = _hc_face_set_tags,
-#endif // WITH_POLICY
+#endif  // WITH_POLICY
 
     .hc_route_create = _hc_route_create,
     .hc_route_create_async = _hc_route_create_async,
@@ -1264,6 +1349,7 @@ static hc_sock_t hc_sock_vpp_interface = (hc_sock_t) {
 
     .hc_strategy_list = _hc_strategy_list,
     .hc_strategy_set = _hc_strategy_set,
+    .hc_strategy_add_local_prefix = _hc_strategy_add_local_prefix,
     .hc_wldr_set = _hc_wldr_set,
 
     .hc_mapme_set = _hc_mapme_set,
@@ -1277,16 +1363,27 @@ static hc_sock_t hc_sock_vpp_interface = (hc_sock_t) {
     .hc_policy_delete = _hc_policy_delete,
     .hc_policy_delete_async = _hc_policy_delete_async,
     .hc_policy_list = _hc_policy_list,
-    .hc_policy_list_async = _hc_policy_list_async
-#endif // WITH_POLICY
+    .hc_policy_list_async = _hc_policy_list_async,
+#endif  // WITH_POLICY
+
+    .hc_listener_create_conf = _hc_listener_create_conf,
+    .hc_connection_create_conf = _hc_connection_create_conf,
+    .hc_route_create_conf = _hc_route_create_conf,
+    .hc_strategy_set_conf = _hc_strategy_set_conf,
+    .hc_strategy_add_local_prefix_conf = _hc_strategy_add_local_prefix_conf,
+
+    .hc_result_get_msg = _hc_result_get_msg,
+    .hc_result_get_cmd_id = _hc_result_get_cmd_id,
+    .hc_result_get_success = _hc_result_get_success,
+    .hc_result_free = _hc_result_free,
 };
 
 hc_sock_t *_hc_sock_create_url(const char *url) {
-  // NOT IMPLEMENTED
-  return NULL;
-}
+  if (url) {
+    // NOT IMPLEMENTED
+    return NULL;
+  }
 
-hc_sock_t *_hc_sock_create(void) {
   hc_sock_vpp_t *s = malloc(sizeof(hc_sock_vpp_t));
 
   if (!s) goto ERR_SOCK;
@@ -1302,4 +1399,4 @@ hc_sock_t *_hc_sock_create(void) {
 
 ERR_SOCK:
   return NULL;
-}
\ No newline at end of file
+}
diff --git a/ctrl/libhicnctrl/src/route.c b/ctrl/libhicnctrl/src/route.c
index 703b4763f..f59dbce7c 100644
--- a/ctrl/libhicnctrl/src/route.c
+++ b/ctrl/libhicnctrl/src/route.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,84 +25,64 @@
 #define DEFAULT_HICN_ROUTE_COST 1
 
 struct hicn_route_s {
-    ip_prefix_t prefix;
-    face_id_t face_id;
-    route_cost_t cost; /* Optional, 0 means no value, defaults to 1 */
+  ip_prefix_t prefix;
+  face_id_t face_id;
+  route_cost_t cost; /* Optional, 0 means no value, defaults to 1 */
 };
 
-hicn_route_t *
-hicn_route_create(ip_prefix_t * prefix, face_id_t face_id, route_cost_t cost)
-{
-    hicn_route_t * route = malloc(sizeof(hicn_route_t));
-    if (!route)
-        return NULL;
-    route->prefix = *prefix;
-    route->face_id = face_id;
-    route->cost = cost != 0 ? cost : DEFAULT_HICN_ROUTE_COST;
+hicn_route_t* hicn_route_create(ip_prefix_t* prefix, face_id_t face_id,
+                                route_cost_t cost) {
+  hicn_route_t* route = malloc(sizeof(hicn_route_t));
+  if (!route) return NULL;
+  route->prefix = *prefix;
+  route->face_id = face_id;
+  route->cost = cost != 0 ? cost : DEFAULT_HICN_ROUTE_COST;
 
-    return route;
+  return route;
 }
 
-hicn_route_t *
-hicn_route_dup(const hicn_route_t * route)
-{
-    hicn_route_t * new_route = malloc(sizeof(hicn_route_t));
-    if (!route)
-        return NULL;
-    memcpy(new_route, route, sizeof(hicn_route_t));
-    return new_route;
+hicn_route_t* hicn_route_dup(const hicn_route_t* route) {
+  hicn_route_t* new_route = malloc(sizeof(hicn_route_t));
+  if (!route) return NULL;
+  memcpy(new_route, route, sizeof(hicn_route_t));
+  return new_route;
 }
 
-void hicn_route_free(hicn_route_t * route)
-{
-    free(route);
-}
+void hicn_route_free(hicn_route_t* route) { free(route); }
 
-int
-hicn_route_cmp(const hicn_route_t * route1, const hicn_route_t * route2)
-{
-    int rc;
-    rc = ip_prefix_cmp(&route1->prefix, &route2->prefix);
-    if (rc != 0)
-        return rc;
+int hicn_route_cmp(const hicn_route_t* route1, const hicn_route_t* route2) {
+  int rc;
+  rc = ip_prefix_cmp(&route1->prefix, &route2->prefix);
+  if (rc != 0) return rc;
 
-    return (route1->face_id > route2->face_id) ?  1 :
-           (route1->face_id < route2->face_id) ? -1 : 0;
+  return (route1->face_id > route2->face_id)   ? 1
+         : (route1->face_id < route2->face_id) ? -1
+                                               : 0;
 }
 
-int
-hicn_route_get_prefix(const hicn_route_t * route, ip_prefix_t * prefix)
-{
-    *prefix = route->prefix;
-    return 0;
+int hicn_route_get_prefix(const hicn_route_t* route, ip_prefix_t* prefix) {
+  *prefix = route->prefix;
+  return 0;
 }
 
-int
-hicn_route_set_prefix(hicn_route_t * route, const ip_prefix_t prefix)
-{
-    route->prefix = prefix;
-    return 0;
+int hicn_route_set_prefix(hicn_route_t* route, const ip_prefix_t prefix) {
+  route->prefix = prefix;
+  return 0;
 }
 
-int
-hicn_route_get_cost(const hicn_route_t * route, int * cost)
-{
-    *cost = route->cost;
-    return 0;
+int hicn_route_get_cost(const hicn_route_t* route, int* cost) {
+  *cost = route->cost;
+  return 0;
 }
 
-int
-hicn_route_set_cost(hicn_route_t * route, const int cost)
-{
-    route->cost = cost;
-    return 0;
+int hicn_route_set_cost(hicn_route_t* route, const int cost) {
+  route->cost = cost;
+  return 0;
 }
 
 /* /!\ Please update constants in header file upon changes */
-size_t
-hicn_route_snprintf(char * s, size_t size, const hicn_route_t * route)
-{
-    char prefix_s[MAXSZ_PREFIX];
-    ip_prefix_ntop(&route->prefix, prefix_s, MAXSZ_PREFIX);
-    return snprintf(s, size, "%s [%d]", prefix_s, route->cost);
+size_t hicn_route_snprintf(char* s, size_t size, const hicn_route_t* route) {
+  char prefix_s[MAXSZ_IP_PREFIX];
+  ip_prefix_ntop(&route->prefix, prefix_s, MAXSZ_IP_PREFIX);
+  return snprintf(s, size, "%s [%d]", prefix_s, route->cost);
 }
diff --git a/ctrl/libhicnctrl/src/util/hash.h b/ctrl/libhicnctrl/src/util/hash.h
index 7c7bb1e3a..f3a1eedcc 100644
--- a/ctrl/libhicnctrl/src/util/hash.h
+++ b/ctrl/libhicnctrl/src/util/hash.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -27,67 +27,88 @@
 #ifndef UTIL_HASH_H
 #define UTIL_HASH_H
 
-#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && \
-     __BYTE_ORDER == __LITTLE_ENDIAN) || \
+#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
+     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
+       __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
+#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 hashsize(n) ((uint32_t)1 << (n))
+#define hashmask(n) (hashsize(n) - 1)
+#define rot(x, k) (((x) << (k)) | ((x) >> (32 - (k))))
 
-#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); \
-}
+#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;          \
+  }
 
-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 */
+#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 */
+    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)
-    {
+    while (length > 12) {
       a += k[0];
       b += k[1];
       c += k[2];
-      mix(a,b,c);
+      mix(a, b, c);
       length -= 12;
       k += 3;
     }
@@ -104,136 +125,214 @@ uint32_t hashlittle( const void *key, size_t length, uint32_t initval)
      */
 #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 */
+    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;
+    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;
+    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);
+    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 */
+    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 */
+  } 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)
-    {
+    while (length > 12) {
       a += k[0];
-      a += ((uint32_t)k[1])<<8;
-      a += ((uint32_t)k[2])<<16;
-      a += ((uint32_t)k[3])<<24;
+      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;
+      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);
+      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 */
+    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;
+      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);
+  final(a, b, c);
   return c;
 }
 
@@ -241,7 +340,7 @@ uint32_t hashlittle( const void *key, size_t length, uint32_t initval)
 
 #define HASH_INITVAL 1
 //#define hash(buf, len)  (hash_t)hashlittle(buf, len, HASH_INITVAL)
-#define hash(buf, len)  hashlittle(buf, len, HASH_INITVAL)
+#define hash(buf, len) hashlittle(buf, len, HASH_INITVAL)
 #define hash_struct(buf) hash(buf, sizeof(buf))
 
 #endif /* UTIL_JENKINS_HASH_H */
diff --git a/ctrl/sysrepo-plugins/CMakeLists.txt b/ctrl/sysrepo-plugins/CMakeLists.txt
index 2412d5688..0765f75d8 100644
--- a/ctrl/sysrepo-plugins/CMakeLists.txt
+++ b/ctrl/sysrepo-plugins/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -41,13 +41,13 @@ if (NOT SRPD_PLUGINS_PATH)
   message(FATAL_ERROR "Cannot get sysrepo plugins directory due to missing pkg-config, set SRPD_PLUGINS_PATH manually.")
 endif()
 
-find_package(Vpp REQUIRED)
+find_package(Vpp ${VPP_DEFAULT_VERSION} REQUIRED)
 
 if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-  find_package(HicnPlugin REQUIRED)
+  find_package(HicnPlugin ${CURRENT_VERSION} REQUIRED)
 else()
   list(APPEND DEPENDENCIES
-    hicn_plugin
+    ${HICNPLUGIN_SHARED}
   )
 endif()
 
diff --git a/ctrl/sysrepo-plugins/cmake/Modules/Packaging.cmake b/ctrl/sysrepo-plugins/cmake/Modules/Packaging.cmake
index 323c9d01a..cba9adf1f 100644
--- a/ctrl/sysrepo-plugins/cmake/Modules/Packaging.cmake
+++ b/ctrl/sysrepo-plugins/cmake/Modules/Packaging.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -15,17 +15,22 @@
 # Packages section
 ######################
 
+##############################################################
+# Get VPP version
+##############################################################
+list(GET VPP_DEFAULT_VERSION 0 VPP_VERSION)
+
 set(hicn-sysrepo-plugin_DESCRIPTION
   "A Plugin to enable hICN VPP in sysrepo."
   CACHE STRING "Description for deb/rpm package."
 )
 
 set(hicn-sysrepo-plugin_DEB_DEPENDENCIES
-  "hicn-plugin (>= stable_version-release), sysrepo (>= 1.0)"
+  "hicn-plugin (= ${VPP_VERSION}-release), sysrepo (>= 1.0)"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(hicn-sysrepo-plugin_RPM_DEPENDENCIES
-  "hicn-plugin >= stable_version-release, sysrepo >= 1.0"
+  "hicn-plugin = ${VPP_VERSION}-release, sysrepo >= 1.0"
   CACHE STRING "Dependencies for deb/rpm package."
 )
diff --git a/ctrl/sysrepo-plugins/hicn-light/CMakeLists.txt b/ctrl/sysrepo-plugins/hicn-light/CMakeLists.txt
index 5ba7045c1..f8a1e64aa 100644
--- a/ctrl/sysrepo-plugins/hicn-light/CMakeLists.txt
+++ b/ctrl/sysrepo-plugins/hicn-light/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/ctrl/sysrepo-plugins/hicn-light/plugin/CMakeLists.txt b/ctrl/sysrepo-plugins/hicn-light/plugin/CMakeLists.txt
index 85da0d3e9..b5faab705 100644
--- a/ctrl/sysrepo-plugins/hicn-light/plugin/CMakeLists.txt
+++ b/ctrl/sysrepo-plugins/hicn-light/plugin/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light.c b/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light.c
index 6cfc0b52b..b2495f730 100644
--- a/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light.c
+++ b/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,8 +21,6 @@
 #include "hicn_light.h"
 #include "model/hicn_model.h"
 
-
-
 sr_subscription_ctx_t *subscription = NULL;
 volatile int exit_application = 0;
 
@@ -37,7 +35,6 @@ int sr_plugin_init_cb(sr_session_ctx_t *session, void **private_ctx) {
 
   hicn_subscribe_events(session, &subscription);
 
-
   /* set subscription as our private context */
   *private_ctx = subscription;
   return SR_ERR_OK;
diff --git a/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light.h b/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light.h
index 16f65e5c4..cea2851c9 100644
--- a/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light.h
+++ b/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light_comm.c b/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light_comm.c
index 6c4f938ce..08551b470 100644
--- a/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light_comm.c
+++ b/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light_comm.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,20 +14,17 @@
  */
 #include "hicn_light_comm.h"
 
-hc_sock_t * hsocket;
+hc_sock_t* hsocket;
 
 int hicn_connect_light() {
-
-    hsocket = hc_sock_create();
-    if (!hsocket)
-      HICN_LOG_ERR_MSG("Error creating socket\n");
-    if (hc_sock_connect(hsocket) < 0)
-      HICN_LOG_ERR_MSG("Error connecting to the forwarder\n");
-    return 0;
-
+  hsocket = hc_sock_create();
+  if (!hsocket) HICN_LOG_ERR_MSG("Error creating socket\n");
+  if (hc_sock_connect(hsocket) < 0)
+    HICN_LOG_ERR_MSG("Error connecting to the forwarder\n");
+  return 0;
 }
 
 int hicn_disconnect_light() {
-     hc_sock_free(hsocket);
+  hc_sock_free(hsocket);
   return 0;
 }
\ No newline at end of file
diff --git a/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light_comm.h b/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light_comm.h
index ca67cf0b7..c03d59c30 100644
--- a/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light_comm.h
+++ b/ctrl/sysrepo-plugins/hicn-light/plugin/hicn_light_comm.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -18,7 +18,6 @@
 #include <sysrepo.h>
 #include <sysrepo/values.h>
 
-
 #include <hicn/ctrl/api.h>
 
 #ifndef HICN_THIS_FUNC
@@ -37,23 +36,20 @@
     }                                                 \
   } while (0)
 
-
-
 #define ARG_CHECK2(retval, arg1, arg2) \
-    ARG_CHECK(retval, arg1); \
-    ARG_CHECK(retval, arg2)
+  ARG_CHECK(retval, arg1);             \
+  ARG_CHECK(retval, arg2)
 
 #define ARG_CHECK5(retval, arg1, arg2, arg3, arg4, arg5) \
-    ARG_CHECK(retval, arg1); \
-    ARG_CHECK(retval, arg2); \
-    ARG_CHECK(retval, arg3); \
-    ARG_CHECK(retval, arg4); \
-    ARG_CHECK(retval, arg5)
-
+  ARG_CHECK(retval, arg1);                               \
+  ARG_CHECK(retval, arg2);                               \
+  ARG_CHECK(retval, arg3);                               \
+  ARG_CHECK(retval, arg4);                               \
+  ARG_CHECK(retval, arg5)
 
 #define MEM_ALIGN 4096
 
 int hicn_connect_light();
 int hicn_disconnect_light();
-extern hc_sock_t * hsocket;
+extern hc_sock_t* hsocket;
 #endif  //__HICN_LIGHT_COMMM_H__
diff --git a/ctrl/sysrepo-plugins/hicn-light/plugin/model/hicn_model.c b/ctrl/sysrepo-plugins/hicn-light/plugin/model/hicn_model.c
index 47e07d196..d32fd55ef 100644
--- a/ctrl/sysrepo-plugins/hicn-light/plugin/model/hicn_model.c
+++ b/ctrl/sysrepo-plugins/hicn-light/plugin/model/hicn_model.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -22,72 +22,67 @@
 #include "tlock.h"
 #include "../hicn_light.h"
 #include "../hicn_light_comm.h"
-
-
+#include <hicn/util/sstrncpy.h>
 
 /**
  * @brief API to add hicn face ip in hicn-light.
  */
-static int hicn_face_ip_add_cb(sr_session_ctx_t *session, const char *path, const sr_val_t *input, const size_t input_cnt,
-        sr_event_t event, uint32_t request_id, sr_val_t **output, size_t *output_cnt, void *private_data) {
-
+static int hicn_face_ip_add_cb(sr_session_ctx_t *session, const char *path,
+                               const sr_val_t *input, const size_t input_cnt,
+                               sr_event_t event, uint32_t request_id,
+                               sr_val_t **output, size_t *output_cnt,
+                               void *private_data) {
   SRP_LOG_DBGMSG("hicn face ip add received successfully");
   hc_face_t face;
-  if(strcmp(input[0].data.string_val,"-1")){
-
-  struct sockaddr_in sa;
-  // store this IP address in sa:
-  inet_pton(AF_INET,  input[0].data.string_val, &(sa.sin_addr));
-  face.face.family=AF_INET;
-  face.face.local_addr.v4.as_inaddr=sa.sin_addr;
-
-
-  }else if(strcmp(input[1].data.string_val,"-1")){
-
+  if (strcmp(input[0].data.string_val, "-1")) {
+    struct sockaddr_in sa;
+    // store this IP address in sa:
+    inet_pton(AF_INET, input[0].data.string_val, &(sa.sin_addr));
+    face.face.family = AF_INET;
+    face.face.local_addr.v4.as_inaddr = sa.sin_addr;
+
+  } else if (strcmp(input[1].data.string_val, "-1")) {
     struct in6_addr *dst = malloc(sizeof(struct in6_addr));
     inet_pton(AF_INET6, input[1].data.string_val, dst);
-    face.face.family=AF_INET6;
+    face.face.family = AF_INET6;
     face.face.local_addr.v6.as_in6addr = *dst;
 
-  }else{
-      SRP_LOG_DBGMSG("Invalid local IP address");
-      return SR_ERR_OPERATION_FAILED;
+  } else {
+    SRP_LOG_DBGMSG("Invalid local IP address");
+    return SR_ERR_OPERATION_FAILED;
   }
 
-  if(strcmp(input[2].data.string_val,"-1")){
-
-  struct sockaddr_in sa;
-  // store this IP address in sa:
-  inet_pton(AF_INET,  input[2].data.string_val, &(sa.sin_addr));
-  face.face.family=AF_INET;
-  face.face.remote_addr.v4.as_inaddr=sa.sin_addr;
-
-
-  }else if(strcmp(input[3].data.string_val,"-1")){
+  if (strcmp(input[2].data.string_val, "-1")) {
+    struct sockaddr_in sa;
+    // store this IP address in sa:
+    inet_pton(AF_INET, input[2].data.string_val, &(sa.sin_addr));
+    face.face.family = AF_INET;
+    face.face.remote_addr.v4.as_inaddr = sa.sin_addr;
 
+  } else if (strcmp(input[3].data.string_val, "-1")) {
     struct in6_addr *dst = malloc(sizeof(struct in6_addr));
     inet_pton(AF_INET6, input[3].data.string_val, dst);
-    face.face.family=AF_INET6;
+    face.face.family = AF_INET6;
     face.face.remote_addr.v6.as_in6addr = *dst;
 
-  }else{
-      SRP_LOG_DBGMSG("Invalid local IP address");
-      return SR_ERR_OPERATION_FAILED;
+  } else {
+    SRP_LOG_DBGMSG("Invalid local IP address");
+    return SR_ERR_OPERATION_FAILED;
   }
 
-
-  face.face.netdevice.index = input[4].data.uint32_val;  // This is the idx number of interface
-
-
-  face.id=0;//can be empty
-  strcpy(face.name,"hicn_face");
-  face.face.type=1;
+  face.face.netdevice.index =
+      input[4].data.uint32_val;  // This is the idx number of interface
 
   int rc;
+  face.id = 0;  // can be empty
+  rc = strcpy_s(face.name, sizeof(face.name), "hicn_face");
+  if (rc != EOK) return SR_ERR_OPERATION_FAILED;
+  face.face.type = 1;
+
   rc = hc_face_create(hsocket, &face);
   if (rc > 0) {
-       SRP_LOG_DBGMSG("Face added successfully");
-       return SR_ERR_OK;
+    SRP_LOG_DBGMSG("Face added successfully");
+    return SR_ERR_OK;
   }
 
   SRP_LOG_DBGMSG("Operation Failed");
@@ -97,92 +92,84 @@ static int hicn_face_ip_add_cb(sr_session_ctx_t *session, const char *path, cons
 /**
  * @brief API to del hicn face ip in vpp.
  */
-static int hicn_face_ip_del_cb(sr_session_ctx_t *session, const char *path, const sr_val_t *input, const size_t input_cnt,
-        sr_event_t event, uint32_t request_id, sr_val_t **output, size_t *output_cnt, void *private_data) {
-
+static int hicn_face_ip_del_cb(sr_session_ctx_t *session, const char *path,
+                               const sr_val_t *input, const size_t input_cnt,
+                               sr_event_t event, uint32_t request_id,
+                               sr_val_t **output, size_t *output_cnt,
+                               void *private_data) {
   SRP_LOG_DBGMSG("hicn face ip del received successfully");
-  face_t * face=NULL;
-
+  face_t *face = NULL;
 
   face_free(face);
 
-
-
   SRP_LOG_DBGMSG("Operation Failed");
   return SR_ERR_OPERATION_FAILED;
-
 }
 
-
 /**
  * @brief API to del hicn face ip in vpp.
  */
-static int hicn_route_add_cb(sr_session_ctx_t *session, const char *path, const sr_val_t *input, const size_t input_cnt,
-        sr_event_t event, uint32_t request_id, sr_val_t **output, size_t *output_cnt, void *private_data) {
+static int hicn_route_add_cb(sr_session_ctx_t *session, const char *path,
+                             const sr_val_t *input, const size_t input_cnt,
+                             sr_event_t event, uint32_t request_id,
+                             sr_val_t **output, size_t *output_cnt,
+                             void *private_data) {
+  /*
 
-/*
+    SRP_LOG_DBG_MSG("hicn route add received successfully");
 
-  SRP_LOG_DBG_MSG("hicn route add received successfully");
+    hc_route_t * route;
 
-  hc_route_t * route;
+    if(strcmp(input[0].data.string_val,"-1")){
 
-  if(strcmp(input[0].data.string_val,"-1")){
+    struct sockaddr_in sa;
+    // store this IP address in sa:
+    inet_pton(AF_INET,  input[0].data.string_val, &(sa.sin_addr));
+    route.family=AF_INET;
+    route.face.hicn.local_addr.v4.as_inaddr=sa.sin_addr;
 
-  struct sockaddr_in sa;
-  // store this IP address in sa:
-  inet_pton(AF_INET,  input[0].data.string_val, &(sa.sin_addr));
-  route.family=AF_INET;
-  route.face.hicn.local_addr.v4.as_inaddr=sa.sin_addr;
 
+    }else if(strcmp(input[1].data.string_val,"-1")){
 
-  }else if(strcmp(input[1].data.string_val,"-1")){
+      struct in6_addr *dst = malloc(sizeof(struct in6_addr));
+      inet_pton(AF_INET6, input[1].data.string_val, dst);
+      face.face.hicn.family=AF_INET6;
+      face.face.hicn.local_addr.v6.as_in6addr = *dst;
 
-    struct in6_addr *dst = malloc(sizeof(struct in6_addr));
-    inet_pton(AF_INET6, input[1].data.string_val, dst);
-    face.face.hicn.family=AF_INET6;
-    face.face.hicn.local_addr.v6.as_in6addr = *dst;
-
-  }else{
-      SRP_LOG_DBG_MSG("Invalid local IP address");
-      return SR_ERR_OPERATION_FAILED;
-  }
+    }else{
+        SRP_LOG_DBG_MSG("Invalid local IP address");
+        return SR_ERR_OPERATION_FAILED;
+    }
 
 
-hc_route_create(hsocket, route);
-*/
- return SR_ERR_OK;
+  hc_route_create(hsocket, route);
+  */
+  return SR_ERR_OK;
 }
 
-
-
 int hicn_subscribe_events(sr_session_ctx_t *session,
                           sr_subscription_ctx_t **subscription) {
-
-
   int rc;
-    rc = sr_rpc_subscribe(session, "/hicn:face-ip-add", hicn_face_ip_add_cb,
-    session, 100,SR_SUBSCR_CTX_REUSE, subscription);
-     if (rc != SR_ERR_OK) {
-      SRP_LOG_DBGMSG("Problem in subscription stat-get\n");
-      goto error;
-    }
-
-
-    rc = sr_rpc_subscribe(session, "/hicn:face-ip-del", hicn_face_ip_del_cb,
-    session, 100,SR_SUBSCR_CTX_REUSE, subscription);
-    if (rc != SR_ERR_OK) {
-      SRP_LOG_DBGMSG("Problem in subscription face-ip-del\n");
-      goto error;
-    }
-
+  rc = sr_rpc_subscribe(session, "/hicn:face-ip-add", hicn_face_ip_add_cb,
+                        session, 100, SR_SUBSCR_CTX_REUSE, subscription);
+  if (rc != SR_ERR_OK) {
+    SRP_LOG_DBGMSG("Problem in subscription stat-get\n");
+    goto error;
+  }
 
-    rc = sr_rpc_subscribe(session, "/hicn:route-nhops-add",
-    hicn_route_add_cb, session, 100,SR_SUBSCR_CTX_REUSE, subscription);
-     if (rc!= SR_ERR_OK) {
-      SRP_LOG_DBGMSG("Problem in subscription route-nhops-add\n");
-      goto error;
-    }
+  rc = sr_rpc_subscribe(session, "/hicn:face-ip-del", hicn_face_ip_del_cb,
+                        session, 100, SR_SUBSCR_CTX_REUSE, subscription);
+  if (rc != SR_ERR_OK) {
+    SRP_LOG_DBGMSG("Problem in subscription face-ip-del\n");
+    goto error;
+  }
 
+  rc = sr_rpc_subscribe(session, "/hicn:route-nhops-add", hicn_route_add_cb,
+                        session, 100, SR_SUBSCR_CTX_REUSE, subscription);
+  if (rc != SR_ERR_OK) {
+    SRP_LOG_DBGMSG("Problem in subscription route-nhops-add\n");
+    goto error;
+  }
 
   SRP_LOG_DBGMSG("hicn light initialized successfully.");
   return SR_ERR_OK;
@@ -191,5 +178,4 @@ error:
   SRP_LOG_ERRMSG("Error by initialization of the hicn plugin.");
   sr_plugin_cleanup_cb(session, hsocket);
   return rc;
-
 }
diff --git a/ctrl/sysrepo-plugins/hicn-light/plugin/model/hicn_model.h b/ctrl/sysrepo-plugins/hicn-light/plugin/model/hicn_model.h
index e6e857bff..be70bc711 100644
--- a/ctrl/sysrepo-plugins/hicn-light/plugin/model/hicn_model.h
+++ b/ctrl/sysrepo-plugins/hicn-light/plugin/model/hicn_model.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -18,7 +18,6 @@
 
 #include "../hicn_light_comm.h"
 
-
 #define MEM_ALIGN 4096
 
 // Number of locks is equal to number of nodes in hicn-state
@@ -27,8 +26,7 @@
 #define NLOCKS 5
 #define LOCK_INIT 0
 
-
-enum locks_name {lstate, lstrategy, lstrategies, lroute, lface_ip_params};
+enum locks_name { lstate, lstrategy, lstrategies, lroute, lface_ip_params };
 
 #define NSTATE_LEAVES 15
 #define NSTRATEGY_LEAVES 1
diff --git a/ctrl/sysrepo-plugins/hicn-light/plugin/model/tlock.c b/ctrl/sysrepo-plugins/hicn-light/plugin/model/tlock.c
index 2f7b11efa..ba788d3a0 100644
--- a/ctrl/sysrepo-plugins/hicn-light/plugin/model/tlock.c
+++ b/ctrl/sysrepo-plugins/hicn-light/plugin/model/tlock.c
@@ -1,21 +1,16 @@
-#include"tlock.h"
+#include "tlock.h"
 
-
-void Ticket_init ( int Lock_Number , long int init ){
-
-__atomic_store( &En[Lock_Number] , &init , __ATOMIC_SEQ_CST );
-__atomic_store( &De[Lock_Number] , &init , __ATOMIC_SEQ_CST );
-//En[Lock_Number]=init;
-//De[Lock_Number]=init;
+void Ticket_init(int Lock_Number, long int init) {
+  __atomic_store(&En[Lock_Number], &init, __ATOMIC_SEQ_CST);
+  __atomic_store(&De[Lock_Number], &init, __ATOMIC_SEQ_CST);
+  // En[Lock_Number]=init;
+  // De[Lock_Number]=init;
 }
 
-void Ticket_Lock(int Lock_Number ){
-
- int my_ticket =   __sync_fetch_and_add(&En[Lock_Number] , 1  );
- while (    my_ticket != De[ Lock_Number ]  ) {};
-
+void Ticket_Lock(int Lock_Number) {
+  int my_ticket = __sync_fetch_and_add(&En[Lock_Number], 1);
+  while (my_ticket != De[Lock_Number]) {
+  };
 }
 
-void Ticket_Unlock(int Lock_Number ){
-De[Lock_Number]++;
-}
+void Ticket_Unlock(int Lock_Number) { De[Lock_Number]++; }
diff --git a/ctrl/sysrepo-plugins/hicn-light/plugin/model/tlock.h b/ctrl/sysrepo-plugins/hicn-light/plugin/model/tlock.h
index 36698115a..6840be1c0 100644
--- a/ctrl/sysrepo-plugins/hicn-light/plugin/model/tlock.h
+++ b/ctrl/sysrepo-plugins/hicn-light/plugin/model/tlock.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,19 +13,17 @@
  * limitations under the License.
  */
 
-
 #ifndef __TLOCK_H__
 #define __TLOCK_H__
 
+// limit on the number of locks: it shoud be matched with the  number of
+// hicn-state leaves
+#define MAX_LOCK_SIZE 5
 
-// limit on the number of locks: it shoud be matched with the  number of hicn-state leaves
-#define MAX_LOCK_SIZE  5
-
-volatile long int  En[MAX_LOCK_SIZE] , De[MAX_LOCK_SIZE] ;   // For Ticket Algorithm
-
+volatile long int En[MAX_LOCK_SIZE], De[MAX_LOCK_SIZE];  // For Ticket Algorithm
 
-void Ticket_init ( int Lock_Number , long int init );
-void Ticket_Lock(int Lock_Number );
-void Ticket_Unlock(int Lock_Number );
+void Ticket_init(int Lock_Number, long int init);
+void Ticket_Lock(int Lock_Number);
+void Ticket_Unlock(int Lock_Number);
 
 #endif /* __IETF_HICN_H__ */
\ No newline at end of file
diff --git a/ctrl/sysrepo-plugins/hicn-plugin/CMakeLists.txt b/ctrl/sysrepo-plugins/hicn-plugin/CMakeLists.txt
index 10e106f51..9204e2766 100644
--- a/ctrl/sysrepo-plugins/hicn-plugin/CMakeLists.txt
+++ b/ctrl/sysrepo-plugins/hicn-plugin/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_plugin.c b/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_plugin.c
index bbcc2e9bf..fe2e6350f 100644
--- a/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_plugin.c
+++ b/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_plugin.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -22,12 +22,10 @@
 #include "model/hicn_model.h"
 #include "ietf/ietf_interface.h"
 
-
 sr_subscription_ctx_t *subscription = NULL;
 volatile int exit_application = 0;
 
 int sr_plugin_init_cb(sr_session_ctx_t *session, void **private_ctx) {
-
   sr_subscription_ctx_t *subscription = NULL;
   int rc = SR_ERR_OK;
   rc = hicn_connect_vpp();
@@ -38,11 +36,10 @@ int sr_plugin_init_cb(sr_session_ctx_t *session, void **private_ctx) {
   // HICN subscribe
   hicn_subscribe_events(session, &subscription);
 
-  //sr_subscription_ctx_t *subscription2 = NULL;
+  // sr_subscription_ctx_t *subscription2 = NULL;
 
   // IETF subscribe
-  //ietf_subscribe_events(session, &subscription2);
-
+  // ietf_subscribe_events(session, &subscription2);
 
   /* set subscription as our private context */
   *private_ctx = subscription;
@@ -51,7 +48,6 @@ int sr_plugin_init_cb(sr_session_ctx_t *session, void **private_ctx) {
 }
 
 void sr_plugin_cleanup_cb(sr_session_ctx_t *session, void *private_ctx) {
-
   /* subscription was set as our private context */
   sr_unsubscribe(private_ctx);
   hicn_disconnect_vpp();
diff --git a/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_plugin.h b/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_plugin.h
index 0890c3f03..15aea72d6 100644
--- a/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_plugin.h
+++ b/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_plugin.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -23,7 +23,6 @@
 
 #include "hicn_vpp_comm.h"
 
-
 /**
  * @brief initialize function for sysrepo plugin,
  *  In this function we connect to vpp from one side
diff --git a/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_vpp_comm.c b/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_vpp_comm.c
index 73eab66ea..41ab3d057 100644
--- a/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_vpp_comm.c
+++ b/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_vpp_comm.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -19,15 +19,9 @@
 #define MAX_OUTSTANDING_REQUESTS 4
 #define RESPONSE_QUEUE_SIZE 2
 
-
-vapi_ctx_t g_vapi_ctx_instance=NULL;
-
-
-
-
+vapi_ctx_t g_vapi_ctx_instance = NULL;
 
 int hicn_connect_vpp() {
-
   if (g_vapi_ctx_instance == NULL) {
     vapi_error_e rv = vapi_ctx_alloc(&g_vapi_ctx_instance);
     rv = vapi_connect(g_vapi_ctx_instance, APP_NAME, NULL,
diff --git a/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_vpp_comm.h b/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_vpp_comm.h
index 9abe4e5d4..cb5eefcbe 100644
--- a/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_vpp_comm.h
+++ b/ctrl/sysrepo-plugins/hicn-plugin/plugin/hicn_vpp_comm.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,13 +13,11 @@
  * limitations under the License.
  */
 
-
 /**
  * @file hicn_vpp_comm.h
  * @brief This file contains binary api to connect to the VPP.
  */
 
-
 #ifndef __HICN_VPP_COMMM_H__
 #define __HICN_VPP_COMMM_H__
 #include <sysrepo.h>
@@ -40,7 +38,6 @@
 
 extern vapi_ctx_t g_vapi_ctx_instance;
 
-
 /**
  * @brief This macro is interface.c to communicate with vpp
  */
@@ -48,36 +45,34 @@ extern vapi_ctx_t g_vapi_ctx_instance;
 #define VPP_MAC_ADDRESS_LEN 8
 #define VPP_IP6_ADDRESS_LEN 16
 
-
-
 /**
- * @brief This macro checks the arg is NULL or not, if the arg is NULL it returns retval
+ * @brief This macro checks the arg is NULL or not, if the arg is NULL it
+ * returns retval
  */
-#define ARG_CHECK(retval, arg)                        \
-  do {                                                \
-    if (NULL == (arg)) {                              \
-      SRP_LOG_DBGMSG("NULL pointer passed.");         \
-      return (retval);                                \
-    }                                                 \
+#define ARG_CHECK(retval, arg)                \
+  do {                                        \
+    if (NULL == (arg)) {                      \
+      SRP_LOG_DBGMSG("NULL pointer passed."); \
+      return (retval);                        \
+    }                                         \
   } while (0)
 
-
 /**
  * @brief Please check ARG_CHECK
  */
 #define ARG_CHECK2(retval, arg1, arg2) \
-    ARG_CHECK(retval, arg1); \
-    ARG_CHECK(retval, arg2)
+  ARG_CHECK(retval, arg1);             \
+  ARG_CHECK(retval, arg2)
 
 /**
  * @brief This Macro is the multiple check of ARG_CHECK
  */
 #define ARG_CHECK5(retval, arg1, arg2, arg3, arg4, arg5) \
-    ARG_CHECK(retval, arg1); \
-    ARG_CHECK(retval, arg2); \
-    ARG_CHECK(retval, arg3); \
-    ARG_CHECK(retval, arg4); \
-    ARG_CHECK(retval, arg5)
+  ARG_CHECK(retval, arg1);                               \
+  ARG_CHECK(retval, arg2);                               \
+  ARG_CHECK(retval, arg3);                               \
+  ARG_CHECK(retval, arg4);                               \
+  ARG_CHECK(retval, arg5)
 
 /**
  * @brief This function is used to connect to the vpp
diff --git a/ctrl/sysrepo-plugins/hicn-plugin/plugin/ietf/ietf_interface.c b/ctrl/sysrepo-plugins/hicn-plugin/plugin/ietf/ietf_interface.c
index 3e0c90cf9..9a74e6280 100644
--- a/ctrl/sysrepo-plugins/hicn-plugin/plugin/ietf/ietf_interface.c
+++ b/ctrl/sysrepo-plugins/hicn-plugin/plugin/ietf/ietf_interface.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -29,11 +29,9 @@
 #include "ietf_interface.h"
 #include "../hicn_vpp_comm.h"
 
-
 DEFINE_VAPI_MSG_IDS_INTERFACE_API_JSON;
 
-typedef struct hicn_interface_
-{
+typedef struct hicn_interface_ {
   u32 sw_if_index;
   char interface_name[VPP_INTFC_NAME_LEN];
   u8 l2_address[VPP_MAC_ADDRESS_LEN];
@@ -44,207 +42,202 @@ typedef struct hicn_interface_
   u8 link_up_down;
 } hicnIntfc;
 
-typedef struct _ietf_sw_interface_dump_ctx
-{
+typedef struct _ietf_sw_interface_dump_ctx {
   u8 last_called;
   int num_ifs;
   int capacity;
-  hicnIntfc * intfcArray;
+  hicnIntfc *intfcArray;
 } ietf_sw_interface_dump_ctx;
 
 static i32 ietf_setInterfaceFlags(u32 sw_if_index, u8 admin_up_down);
-static i32 ietf_interface_name2index(const char *name, u32* if_index);
+static i32 ietf_interface_name2index(const char *name, u32 *if_index);
 static i32 ietf_interface_add_del_addr(u32 sw_if_index, u8 is_add, u8 is_ipv6,
                                        u8 del_all, u8 address_length,
                                        u8 address[VPP_IP6_ADDRESS_LEN]);
-static int ietf_initSwInterfaceDumpCTX(ietf_sw_interface_dump_ctx * dctx);
-static int ietf_freeSwInterfaceDumpCTX(ietf_sw_interface_dump_ctx * dctx);
+static int ietf_initSwInterfaceDumpCTX(ietf_sw_interface_dump_ctx *dctx);
+static int ietf_freeSwInterfaceDumpCTX(ietf_sw_interface_dump_ctx *dctx);
 
 /**
  * @brief Helper function for converting netmask into prefix length.
  */
-static uint8_t
-netmask_to_prefix(const char *netmask)
-{
-    in_addr_t n = 0;
-    uint8_t i = 0;
+static uint8_t netmask_to_prefix(const char *netmask) {
+  in_addr_t n = 0;
+  uint8_t i = 0;
 
-    inet_pton(AF_INET, netmask, &n);
+  inet_pton(AF_INET, netmask, &n);
 
-    while (n > 0) {
-        n = n >> 1;
-        i++;
-    }
+  while (n > 0) {
+    n = n >> 1;
+    i++;
+  }
 
-    return i;
+  return i;
 }
 
 /**
- * @brief Helper function for converting IPv4/IPv6 address string into binary representation.
+ * @brief Helper function for converting IPv4/IPv6 address string into binary
+ * representation.
  */
-static int
-ip_addr_str_to_binary(const char *ip_address_str, uint8_t *ip_address_bin, bool is_ipv6)
-{
-    struct in6_addr addr6 = { 0, };
-    struct in_addr addr4 = { 0, };
-    int ret = 0;
-
-    if (is_ipv6) {
-        ret = inet_pton(AF_INET6, ip_address_str, &(addr6));
-        if (1 == ret)
-        {
-            memcpy(ip_address_bin, &addr6, sizeof(addr6));
-        }
-    } else {
-        ret = inet_pton(AF_INET, ip_address_str, &(addr4));
-        if (1 == ret)
-        {
-            memcpy(ip_address_bin, &addr4, sizeof(addr4));
-        }
+static int ip_addr_str_to_binary(const char *ip_address_str,
+                                 uint8_t *ip_address_bin, bool is_ipv6) {
+  struct in6_addr addr6 = {
+      0,
+  };
+  struct in_addr addr4 = {
+      0,
+  };
+  int ret = 0;
+
+  if (is_ipv6) {
+    ret = inet_pton(AF_INET6, ip_address_str, &(addr6));
+    if (1 == ret) {
+      memcpy(ip_address_bin, &addr6, sizeof(addr6));
+    }
+  } else {
+    ret = inet_pton(AF_INET, ip_address_str, &(addr4));
+    if (1 == ret) {
+      memcpy(ip_address_bin, &addr4, sizeof(addr4));
     }
+  }
 
-    return ret;
+  return ret;
 }
 
 /**
  * @brief Enable or disable given interface.
  */
-static int
-interface_enable_disable(const char *if_name, bool enable)
-{
-    uint32_t if_index = ~0;
-    int rc = 0;
-
-
-    /* get interface index */
-    rc = ietf_interface_name2index(if_name, &if_index);
-    if (0 != rc) {
-        SRP_LOG_ERRMSG("Invalid interface name");
-        return SR_ERR_INVAL_ARG;
-    }
+static int interface_enable_disable(const char *if_name, bool enable) {
+  uint32_t if_index = ~0;
+  int rc = 0;
+
+  /* get interface index */
+  rc = ietf_interface_name2index(if_name, &if_index);
+  if (0 != rc) {
+    SRP_LOG_ERRMSG("Invalid interface name");
+    return SR_ERR_INVAL_ARG;
+  }
 
-    /* enable/disable interface */
-    rc = ietf_setInterfaceFlags(if_index, (uint8_t)enable);
-    if (0 != rc) {
-       SRP_LOG_ERRMSG("Error by processing of the sw_interface_set_flags request");
-        return SR_ERR_OPERATION_FAILED;
-    } else {
-        return SR_ERR_OK;
-    }
+  /* enable/disable interface */
+  rc = ietf_setInterfaceFlags(if_index, (uint8_t)enable);
+  if (0 != rc) {
+    SRP_LOG_ERRMSG("Error by processing of the sw_interface_set_flags request");
+    return SR_ERR_OPERATION_FAILED;
+  } else {
+    return SR_ERR_OK;
+  }
 }
 
-
-vapi_error_e call_sw_interface_add_del_address(struct vapi_ctx_s *ctx,
-                           void *callback_ctx,
-                           vapi_error_e rv,
-                           bool is_last,
-                           vapi_payload_sw_interface_add_del_address_reply *reply){
-if(!reply->retval){
-  SRP_LOG_DBGMSG("Successfully done");
-  return VAPI_OK;
- }else
-  return VAPI_EUSER;
+vapi_error_e call_sw_interface_add_del_address(
+    struct vapi_ctx_s *ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_sw_interface_add_del_address_reply *reply) {
+  if (!reply->retval) {
+    SRP_LOG_DBGMSG("Successfully done");
+    return VAPI_OK;
+  } else
+    return VAPI_EUSER;
 }
 
-vapi_error_e call_sw_interface_set_flags(struct vapi_ctx_s *ctx,
-                           void *callback_ctx,
-                           vapi_error_e rv,
-                           bool is_last,
-                           vapi_payload_sw_interface_set_flags_reply *reply){
-if(!reply->retval){
-  SRP_LOG_DBGMSG("Successfully done");
-  return VAPI_OK;
- }else
-  return VAPI_EUSER;
+vapi_error_e call_sw_interface_set_flags(
+    struct vapi_ctx_s *ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_sw_interface_set_flags_reply *reply) {
+  if (!reply->retval) {
+    SRP_LOG_DBGMSG("Successfully done");
+    return VAPI_OK;
+  } else
+    return VAPI_EUSER;
 }
 
-
-
 /**
- * @brief Callback to be called by any config change of "/ietf-interfaces:interfaces/interface/enabled" leaf.
+ * @brief Callback to be called by any config change of
+ * "/ietf-interfaces:interfaces/interface/enabled" leaf.
  */
-static int
-ietf_interface_enable_disable_cb(sr_session_ctx_t *session, const char *module_name, const char *xpath, sr_event_t event,
-        uint32_t request_id, void *private_data)
-{
-    char *if_name = NULL;
-    sr_change_iter_t *iter = NULL;
-    sr_change_oper_t op = SR_OP_CREATED;
-    sr_val_t *old_val = NULL;
-    sr_val_t *new_val = NULL;
-    sr_xpath_ctx_t xpath_ctx = { 0, };
-    int rc = SR_ERR_OK, op_rc = SR_ERR_OK;
-
-    /* no-op for apply, we only care about SR_EV_ENABLED, SR_EV_VERIFY, SR_EV_ABORT */
-    if (SR_EV_DONE == event) {
-        return SR_ERR_OK;
-    }
+static int ietf_interface_enable_disable_cb(sr_session_ctx_t *session,
+                                            const char *module_name,
+                                            const char *xpath, sr_event_t event,
+                                            uint32_t request_id,
+                                            void *private_data) {
+  char *if_name = NULL;
+  sr_change_iter_t *iter = NULL;
+  sr_change_oper_t op = SR_OP_CREATED;
+  sr_val_t *old_val = NULL;
+  sr_val_t *new_val = NULL;
+  sr_xpath_ctx_t xpath_ctx = {
+      0,
+  };
+  int rc = SR_ERR_OK, op_rc = SR_ERR_OK;
+
+  /* no-op for apply, we only care about SR_EV_ENABLED, SR_EV_VERIFY,
+   * SR_EV_ABORT */
+  if (SR_EV_DONE == event) {
+    return SR_ERR_OK;
+  }
 
-    /* get changes iterator */
-    rc = sr_get_changes_iter(session, xpath, &iter);
-    if (SR_ERR_OK != rc) {
-        SRP_LOG_ERRMSG("Unable to retrieve change iterator");
-        return rc;
-    }
+  /* get changes iterator */
+  rc = sr_get_changes_iter(session, xpath, &iter);
+  if (SR_ERR_OK != rc) {
+    SRP_LOG_ERRMSG("Unable to retrieve change iterator");
+    return rc;
+  }
 
-    /* iterate over all changes */
-    while ((SR_ERR_OK == op_rc || event == SR_EV_ABORT) &&
-            (SR_ERR_OK == (rc = sr_get_change_next(session, iter, &op, &old_val, &new_val)))) {
-
-        SRP_LOG_DBGMSG("A change detected");
-        if_name = sr_xpath_key_value(new_val ? new_val->xpath : old_val->xpath, "interface", "name", &xpath_ctx);
-        switch (op) {
-            case SR_OP_CREATED:
-            case SR_OP_MODIFIED:
-                op_rc = interface_enable_disable(if_name, new_val->data.bool_val);
-                break;
-            case SR_OP_DELETED:
-                op_rc = interface_enable_disable(if_name, false /* !enable */);
-                break;
-            default:
-                break;
-        }
-        sr_xpath_recover(&xpath_ctx);
-        if (SR_ERR_INVAL_ARG == op_rc) {
-            sr_set_error(session, "Invalid interface name.", new_val ? new_val->xpath : old_val->xpath);
-        }
-        sr_free_val(old_val);
-        sr_free_val(new_val);
+  /* iterate over all changes */
+  while ((SR_ERR_OK == op_rc || event == SR_EV_ABORT) &&
+         (SR_ERR_OK ==
+          (rc = sr_get_change_next(session, iter, &op, &old_val, &new_val)))) {
+    SRP_LOG_DBGMSG("A change detected");
+    if_name = sr_xpath_key_value(new_val ? new_val->xpath : old_val->xpath,
+                                 "interface", "name", &xpath_ctx);
+    switch (op) {
+      case SR_OP_CREATED:
+      case SR_OP_MODIFIED:
+        op_rc = interface_enable_disable(if_name, new_val->data.bool_val);
+        break;
+      case SR_OP_DELETED:
+        op_rc = interface_enable_disable(if_name, false /* !enable */);
+        break;
+      default:
+        break;
     }
-    sr_free_change_iter(iter);
+    sr_xpath_recover(&xpath_ctx);
+    if (SR_ERR_INVAL_ARG == op_rc) {
+      sr_set_error(session, "Invalid interface name.",
+                   new_val ? new_val->xpath : old_val->xpath);
+    }
+    sr_free_val(old_val);
+    sr_free_val(new_val);
+  }
+  sr_free_change_iter(iter);
 
-    return op_rc;
+  return op_rc;
 }
 
 /**
  * @brief Add or remove IPv4/IPv6 address to/from an interface.
  */
-static int
-interface_ipv46_config_add_remove(const char *if_name, uint8_t *addr, uint8_t prefix, bool is_ipv6, bool add)
-{
-    uint32_t if_index = ~0;
-    int rc = 0;
-
-    /* get interface index */
-    rc = ietf_interface_name2index(if_name, &if_index);
-    if (0 != rc) {
-       SRP_LOG_ERRMSG("Invalid interface name");
-        return SR_ERR_INVAL_ARG;
-    }
+static int interface_ipv46_config_add_remove(const char *if_name, uint8_t *addr,
+                                             uint8_t prefix, bool is_ipv6,
+                                             bool add) {
+  uint32_t if_index = ~0;
+  int rc = 0;
+
+  /* get interface index */
+  rc = ietf_interface_name2index(if_name, &if_index);
+  if (0 != rc) {
+    SRP_LOG_ERRMSG("Invalid interface name");
+    return SR_ERR_INVAL_ARG;
+  }
 
-    /* add del addr */
-    rc = ietf_interface_add_del_addr(if_index, (uint8_t)add, (uint8_t)is_ipv6, 0, prefix, addr);
-    if (0 != rc) {
-        SRP_LOG_ERRMSG("Error by processing of the sw_interface_set_flags request");
-        return SR_ERR_OPERATION_FAILED;
-    } else {
-        return SR_ERR_OK;
-    }
+  /* add del addr */
+  rc = ietf_interface_add_del_addr(if_index, (uint8_t)add, (uint8_t)is_ipv6, 0,
+                                   prefix, addr);
+  if (0 != rc) {
+    SRP_LOG_ERRMSG("Error by processing of the sw_interface_set_flags request");
+    return SR_ERR_OPERATION_FAILED;
+  } else {
+    return SR_ERR_OK;
+  }
 }
-int ietf_initSwInterfaceDumpCTX(ietf_sw_interface_dump_ctx * dctx)
-{
-  if(dctx == NULL)
-    return -1;
+int ietf_initSwInterfaceDumpCTX(ietf_sw_interface_dump_ctx *dctx) {
+  if (dctx == NULL) return -1;
 
   dctx->intfcArray = NULL;
   dctx->last_called = false;
@@ -252,66 +245,56 @@ int ietf_initSwInterfaceDumpCTX(ietf_sw_interface_dump_ctx * dctx)
   dctx->num_ifs = 0;
   return 0;
 }
-int ietf_freeSwInterfaceDumpCTX(ietf_sw_interface_dump_ctx * dctx)
-{
-  if(dctx == NULL)
-    return -1;
-
-  if(dctx->intfcArray != NULL)
-    {
-      free(dctx->intfcArray);
-    }
+int ietf_freeSwInterfaceDumpCTX(ietf_sw_interface_dump_ctx *dctx) {
+  if (dctx == NULL) return -1;
+
+  if (dctx->intfcArray != NULL) {
+    free(dctx->intfcArray);
+  }
 
   return ietf_initSwInterfaceDumpCTX(dctx);
 }
-vapi_error_e
-ietf_sw_interface_dump_cb (struct vapi_ctx_s *ctx, void *callback_ctx,
-                      vapi_error_e rv, bool is_last,
-                      vapi_payload_sw_interface_details * reply)
-{
+vapi_error_e ietf_sw_interface_dump_cb(
+    struct vapi_ctx_s *ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_sw_interface_details *reply) {
   ietf_sw_interface_dump_ctx *dctx = callback_ctx;
-  if (is_last)
-    {
-      dctx->last_called = true;
+  if (is_last) {
+    dctx->last_called = true;
+  } else {
+    if (dctx->capacity == 0 && dctx->intfcArray == NULL) {
+      dctx->capacity = 10;
+      dctx->intfcArray =
+          (hicnIntfc *)malloc(sizeof(hicnIntfc) * dctx->capacity);
+    }
+    if (dctx->num_ifs >= dctx->capacity - 1) {
+      dctx->capacity += 10;
+      dctx->intfcArray = (hicnIntfc *)realloc(
+          dctx->intfcArray, sizeof(hicnIntfc) * dctx->capacity);
     }
-  else
-    {
-      if(dctx->capacity == 0 && dctx->intfcArray == NULL)
-        {
-          dctx->capacity = 10;
-          dctx->intfcArray = (hicnIntfc*)malloc( sizeof(hicnIntfc)*dctx->capacity );
-        }
-      if(dctx->num_ifs >= dctx->capacity-1)
-        {
-
-          dctx->capacity += 10;
-          dctx->intfcArray = (hicnIntfc*)realloc(dctx->intfcArray, sizeof(hicnIntfc)*dctx->capacity );
-        }
 
-      hicnIntfc * thisIntfc = &dctx->intfcArray[dctx->num_ifs];
+    hicnIntfc *thisIntfc = &dctx->intfcArray[dctx->num_ifs];
 
-      thisIntfc->sw_if_index = reply->sw_if_index;
-      memcpy(thisIntfc->interface_name, reply->interface_name, VPP_INTFC_NAME_LEN);
-      memcpy(thisIntfc->l2_address, reply->l2_address, VPP_MAC_ADDRESS_LEN );
-     //thisIntfc->link_speed = reply->link_speed;
+    thisIntfc->sw_if_index = reply->sw_if_index;
+    memcpy(thisIntfc->interface_name, reply->interface_name,
+           VPP_INTFC_NAME_LEN);
+    memcpy(thisIntfc->l2_address, reply->l2_address, VPP_MAC_ADDRESS_LEN);
+    // thisIntfc->link_speed = reply->link_speed;
 #define ONE_MEGABIT (uint64_t)1000000
-      switch (reply->link_speed << VNET_HW_INTERFACE_FLAG_SPEED_SHIFT)
-        {
-        default:
-          thisIntfc->link_speed = 0;
-          break;
-        }
+    switch (reply->link_speed << VNET_HW_INTERFACE_FLAG_SPEED_SHIFT) {
+      default:
+        thisIntfc->link_speed = 0;
+        break;
+    }
 
-        thisIntfc->link_mtu = reply->link_mtu;
-        thisIntfc->flags = reply->flags;
+    thisIntfc->link_mtu = reply->link_mtu;
+    thisIntfc->flags = reply->flags;
 
-      dctx->num_ifs += 1;
-    }
+    dctx->num_ifs += 1;
+  }
   return VAPI_OK;
 }
 
-static i32 ietf_interface_name2index(const char *name, u32* if_index)
-{
+static i32 ietf_interface_name2index(const char *name, u32 *if_index) {
   ARG_CHECK2(-1, name, if_index);
 
   i32 ret = -1;
@@ -324,14 +307,14 @@ static i32 ietf_interface_name2index(const char *name, u32* if_index)
   dump->payload.name_filter_valid = true;
   memcpy(&dump->payload.name_filter, name, sizeof(dump->payload.name_filter));
 
-  while (VAPI_EAGAIN == (rv = vapi_sw_interface_dump(g_vapi_ctx_instance, dump, ietf_sw_interface_dump_cb, &dctx)))
+  while (VAPI_EAGAIN ==
+         (rv = vapi_sw_interface_dump(g_vapi_ctx_instance, dump,
+                                      ietf_sw_interface_dump_cb, &dctx)))
     ;
 
   int i = 0;
-  for (; i < dctx.num_ifs; ++i)
-  {
-    if (strcmp(dctx.intfcArray[i].interface_name, name) == 0)
-    {
+  for (; i < dctx.num_ifs; ++i) {
+    if (strcmp(dctx.intfcArray[i].interface_name, name) == 0) {
       *if_index = dctx.intfcArray[i].sw_if_index;
       ret = 0;
       break;
@@ -342,11 +325,12 @@ static i32 ietf_interface_name2index(const char *name, u32* if_index)
   return ret;
 }
 
-i32 ietf_interface_add_del_addr( u32 sw_if_index, u8 is_add, u8 is_ipv6, u8 del_all,
-			       u8 address_length, u8 address[VPP_IP6_ADDRESS_LEN] )
-{
+i32 ietf_interface_add_del_addr(u32 sw_if_index, u8 is_add, u8 is_ipv6,
+                                u8 del_all, u8 address_length,
+                                u8 address[VPP_IP6_ADDRESS_LEN]) {
   i32 ret = -1;
-  vapi_msg_sw_interface_add_del_address *msg = vapi_alloc_sw_interface_add_del_address(g_vapi_ctx_instance);
+  vapi_msg_sw_interface_add_del_address *msg =
+      vapi_alloc_sw_interface_add_del_address(g_vapi_ctx_instance);
   msg->payload.sw_if_index = sw_if_index;
   msg->payload.is_add = is_add;
   msg->payload.prefix.address.af = is_ipv6 ? ADDRESS_IP6 : ADDRESS_IP4;
@@ -354,7 +338,9 @@ i32 ietf_interface_add_del_addr( u32 sw_if_index, u8 is_add, u8 is_ipv6, u8 del_
   msg->payload.prefix.len = address_length;
   memcpy(msg->payload.prefix.address.un.ip6, address, VPP_IP6_ADDRESS_LEN);
 
-  if(vapi_sw_interface_add_del_address(g_vapi_ctx_instance,msg,call_sw_interface_add_del_address,NULL)!=VAPI_OK){
+  if (vapi_sw_interface_add_del_address(g_vapi_ctx_instance, msg,
+                                        call_sw_interface_add_del_address,
+                                        NULL) != VAPI_OK) {
     SRP_LOG_DBGMSG("Operation failed");
     return SR_ERR_OPERATION_FAILED;
   }
@@ -362,246 +348,274 @@ i32 ietf_interface_add_del_addr( u32 sw_if_index, u8 is_add, u8 is_ipv6, u8 del_
   return ret;
 }
 
-i32 ietf_setInterfaceFlags(u32 sw_if_index, u8 admin_up_down)
-{
+i32 ietf_setInterfaceFlags(u32 sw_if_index, u8 admin_up_down) {
   i32 ret = -1;
-  vapi_msg_sw_interface_set_flags *msg = vapi_alloc_sw_interface_set_flags(g_vapi_ctx_instance);
+  vapi_msg_sw_interface_set_flags *msg =
+      vapi_alloc_sw_interface_set_flags(g_vapi_ctx_instance);
   msg->payload.sw_if_index = sw_if_index;
-  msg->payload.flags = admin_up_down? IF_STATUS_API_FLAG_ADMIN_UP : 0;
+  msg->payload.flags = admin_up_down ? IF_STATUS_API_FLAG_ADMIN_UP : 0;
 
- if(vapi_sw_interface_set_flags(g_vapi_ctx_instance,msg,call_sw_interface_set_flags,NULL)!=VAPI_OK){
+  if (vapi_sw_interface_set_flags(g_vapi_ctx_instance, msg,
+                                  call_sw_interface_set_flags,
+                                  NULL) != VAPI_OK) {
     SRP_LOG_DBGMSG("Operation failed");
     return SR_ERR_OPERATION_FAILED;
   }
 
-
   return ret;
 }
 
-
 /**
  * @brief Modify existing IPv4/IPv6 config on an interface.
  */
-static int
-interface_ipv46_config_modify(sr_session_ctx_t *session, const char *if_name,
-        sr_val_t *old_val, sr_val_t *new_val, bool is_ipv6)
-{
-    sr_xpath_ctx_t xpath_ctx = { 0, };
-    char *addr_str = NULL;
-    uint8_t addr[16] = { 0, };
-    uint8_t prefix = 0;
-    int rc = SR_ERR_OK;
-
-    SRP_LOG_DBGMSG("Updating IP config on interface");
-
-    /* get old config to be deleted */
-    if (SR_UINT8_T == old_val->type) {
-        prefix = old_val->data.uint8_val;
-    } else if (SR_STRING_T == old_val->type) {
-        prefix = netmask_to_prefix(old_val->data.string_val);
-    } else {
-        return SR_ERR_INVAL_ARG;
-    }
-    addr_str = sr_xpath_key_value((char*)old_val->xpath, "address", "ip", &xpath_ctx);
-    ip_addr_str_to_binary(addr_str, addr, is_ipv6);
-    sr_xpath_recover(&xpath_ctx);
-
-    /* delete old IP config */
-    rc = interface_ipv46_config_add_remove(if_name, addr, prefix, is_ipv6, false /* remove */);
-    if (SR_ERR_OK != rc) {
-        SRP_LOG_ERRMSG("Unable to remove old IP address config");
-        return rc;
-    }
-
-    /* update the config with the new value */
-    if (sr_xpath_node_name_eq(new_val->xpath, "prefix-length")) {
-        prefix = new_val->data.uint8_val;
-    } else if (sr_xpath_node_name_eq(new_val->xpath, "netmask")) {
-        prefix = netmask_to_prefix(new_val->data.string_val);
-    }
+static int interface_ipv46_config_modify(sr_session_ctx_t *session,
+                                         const char *if_name, sr_val_t *old_val,
+                                         sr_val_t *new_val, bool is_ipv6) {
+  sr_xpath_ctx_t xpath_ctx = {
+      0,
+  };
+  char *addr_str = NULL;
+  uint8_t addr[16] = {
+      0,
+  };
+  uint8_t prefix = 0;
+  int rc = SR_ERR_OK;
+
+  SRP_LOG_DBGMSG("Updating IP config on interface");
+
+  /* get old config to be deleted */
+  if (SR_UINT8_T == old_val->type) {
+    prefix = old_val->data.uint8_val;
+  } else if (SR_STRING_T == old_val->type) {
+    prefix = netmask_to_prefix(old_val->data.string_val);
+  } else {
+    return SR_ERR_INVAL_ARG;
+  }
+  addr_str =
+      sr_xpath_key_value((char *)old_val->xpath, "address", "ip", &xpath_ctx);
+  ip_addr_str_to_binary(addr_str, addr, is_ipv6);
+  sr_xpath_recover(&xpath_ctx);
+
+  /* delete old IP config */
+  rc = interface_ipv46_config_add_remove(if_name, addr, prefix, is_ipv6,
+                                         false /* remove */);
+  if (SR_ERR_OK != rc) {
+    SRP_LOG_ERRMSG("Unable to remove old IP address config");
+    return rc;
+  }
 
-    /* set new IP config */
-    rc = interface_ipv46_config_add_remove(if_name, addr, prefix, is_ipv6, true /* add */);
-    if (SR_ERR_OK != rc) {
-        SRP_LOG_ERRMSG("Unable to remove old IP address config");
-        return rc;
-    }
+  /* update the config with the new value */
+  if (sr_xpath_node_name_eq(new_val->xpath, "prefix-length")) {
+    prefix = new_val->data.uint8_val;
+  } else if (sr_xpath_node_name_eq(new_val->xpath, "netmask")) {
+    prefix = netmask_to_prefix(new_val->data.string_val);
+  }
 
+  /* set new IP config */
+  rc = interface_ipv46_config_add_remove(if_name, addr, prefix, is_ipv6,
+                                         true /* add */);
+  if (SR_ERR_OK != rc) {
+    SRP_LOG_ERRMSG("Unable to remove old IP address config");
     return rc;
+  }
+
+  return rc;
 }
 
 /**
- * @brief Callback to be called by any config change in subtrees "/ietf-interfaces:interfaces/interface/ietf-ip:ipv4/address"
- * or "/ietf-interfaces:interfaces/interface/ietf-ip:ipv6/address".
+ * @brief Callback to be called by any config change in subtrees
+ * "/ietf-interfaces:interfaces/interface/ietf-ip:ipv4/address" or
+ * "/ietf-interfaces:interfaces/interface/ietf-ip:ipv6/address".
  */
-static int
-ietf_interface_ipv46_address_change_cb(sr_session_ctx_t *session, const char *module_name, const char *xpath, sr_event_t event,
-        uint32_t request_id, void *private_data)
-{
-    sr_change_iter_t *iter = NULL;
-    sr_change_oper_t op = SR_OP_CREATED;
-    sr_val_t *old_val = NULL;
-    sr_val_t *new_val = NULL;
-    sr_xpath_ctx_t xpath_ctx = { 0 };
-    bool is_ipv6 = false, has_addr = false, has_prefix = false;
-    uint8_t addr[16] = { 0, };
-    uint8_t prefix = 0;
-    char *node_name = NULL, *if_name = NULL;
-    int rc = SR_ERR_OK, op_rc = SR_ERR_OK;
-
-    /* no-op for apply, we only care about SR_EV_ENABLED, SR_EV_VERIFY, SR_EV_ABORT */
-    if (SR_EV_DONE == event) {
-        return SR_ERR_OK;
-    }
+static int ietf_interface_ipv46_address_change_cb(
+    sr_session_ctx_t *session, const char *module_name, const char *xpath,
+    sr_event_t event, uint32_t request_id, void *private_data) {
+  sr_change_iter_t *iter = NULL;
+  sr_change_oper_t op = SR_OP_CREATED;
+  sr_val_t *old_val = NULL;
+  sr_val_t *new_val = NULL;
+  sr_xpath_ctx_t xpath_ctx = {0};
+  bool is_ipv6 = false, has_addr = false, has_prefix = false;
+  uint8_t addr[16] = {
+      0,
+  };
+  uint8_t prefix = 0;
+  char *node_name = NULL, *if_name = NULL;
+  int rc = SR_ERR_OK, op_rc = SR_ERR_OK;
+
+  /* no-op for apply, we only care about SR_EV_ENABLED, SR_EV_VERIFY,
+   * SR_EV_ABORT */
+  if (SR_EV_DONE == event) {
+    return SR_ERR_OK;
+  }
 
-    /* check whether we are handling ipv4 or ipv6 config */
-    node_name = sr_xpath_node_idx((char*)xpath, 2, &xpath_ctx);
-    if (NULL != node_name && 0 == strcmp(node_name, "ipv6")) {
-        is_ipv6 = true;
-    }
-    sr_xpath_recover(&xpath_ctx);
+  /* check whether we are handling ipv4 or ipv6 config */
+  node_name = sr_xpath_node_idx((char *)xpath, 2, &xpath_ctx);
+  if (NULL != node_name && 0 == strcmp(node_name, "ipv6")) {
+    is_ipv6 = true;
+  }
+  sr_xpath_recover(&xpath_ctx);
 
-    /* get changes iterator */
-    rc = sr_get_changes_iter(session, xpath, &iter);
-    if (SR_ERR_OK != rc) {
-       // SRP_LOG_ERR("Unable to retrieve change iterator: %s", sr_strerror(rc));
-        return rc;
-    }
+  /* get changes iterator */
+  rc = sr_get_changes_iter(session, xpath, &iter);
+  if (SR_ERR_OK != rc) {
+    // SRP_LOG_ERR("Unable to retrieve change iterator: %s", sr_strerror(rc));
+    return rc;
+  }
 
-    /* iterate over all changes */
-    while ((SR_ERR_OK == op_rc || event == SR_EV_ABORT) &&
-            (SR_ERR_OK == (rc = sr_get_change_next(session, iter, &op, &old_val, &new_val)))) {
-
-        if_name = strdup(sr_xpath_key_value(new_val ? new_val->xpath : old_val->xpath, "interface", "name", &xpath_ctx));
-        sr_xpath_recover(&xpath_ctx);
-
-        switch (op) {
-            case SR_OP_CREATED:
-                if (SR_LIST_T == new_val->type) {
-                    /* create on list item - reset state vars */
-                    has_addr = has_prefix = false;
-                } else {
-                    if (sr_xpath_node_name_eq(new_val->xpath, "ip")) {
-                        ip_addr_str_to_binary(new_val->data.string_val, addr, is_ipv6);
-                        has_addr = true;
-                    } else if (sr_xpath_node_name_eq(new_val->xpath, "prefix-length")) {
-                        prefix = new_val->data.uint8_val;
-                        has_prefix = true;
-                    } else if (sr_xpath_node_name_eq(new_val->xpath, "netmask")) {
-                        prefix = netmask_to_prefix(new_val->data.string_val);
-                        has_prefix = true;
-                    }
-                    if (has_addr && has_prefix) {
-                        op_rc = interface_ipv46_config_add_remove(if_name, addr, prefix, is_ipv6, true /* add */);
-                    }
-                }
-                break;
-            case SR_OP_MODIFIED:
-                op_rc = interface_ipv46_config_modify(session, if_name, old_val, new_val, is_ipv6);
-                break;
-            case SR_OP_DELETED:
-                if (SR_LIST_T == old_val->type) {
-                    /* delete on list item - reset state vars */
-                    has_addr = has_prefix = false;
-                } else {
-                    if (sr_xpath_node_name_eq(old_val->xpath, "ip")) {
-                        ip_addr_str_to_binary(old_val->data.string_val, addr, is_ipv6);
-                        has_addr = true;
-                    } else if (sr_xpath_node_name_eq(old_val->xpath, "prefix-length")) {
-                        prefix = old_val->data.uint8_val;
-                        has_prefix = true;
-                    } else if (sr_xpath_node_name_eq(old_val->xpath, "netmask")) {
-                        prefix = netmask_to_prefix(old_val->data.string_val);
-                        has_prefix = true;
-                    }
-                    if (has_addr && has_prefix) {
-                        op_rc = interface_ipv46_config_add_remove(if_name, addr, prefix, is_ipv6, false /* !add */);
-                    }
-                }
-                break;
-            default:
-                break;
+  /* iterate over all changes */
+  while ((SR_ERR_OK == op_rc || event == SR_EV_ABORT) &&
+         (SR_ERR_OK ==
+          (rc = sr_get_change_next(session, iter, &op, &old_val, &new_val)))) {
+    if_name =
+        strdup(sr_xpath_key_value(new_val ? new_val->xpath : old_val->xpath,
+                                  "interface", "name", &xpath_ctx));
+    sr_xpath_recover(&xpath_ctx);
+
+    switch (op) {
+      case SR_OP_CREATED:
+        if (SR_LIST_T == new_val->type) {
+          /* create on list item - reset state vars */
+          has_addr = has_prefix = false;
+        } else {
+          if (sr_xpath_node_name_eq(new_val->xpath, "ip")) {
+            ip_addr_str_to_binary(new_val->data.string_val, addr, is_ipv6);
+            has_addr = true;
+          } else if (sr_xpath_node_name_eq(new_val->xpath, "prefix-length")) {
+            prefix = new_val->data.uint8_val;
+            has_prefix = true;
+          } else if (sr_xpath_node_name_eq(new_val->xpath, "netmask")) {
+            prefix = netmask_to_prefix(new_val->data.string_val);
+            has_prefix = true;
+          }
+          if (has_addr && has_prefix) {
+            op_rc = interface_ipv46_config_add_remove(if_name, addr, prefix,
+                                                      is_ipv6, true /* add */);
+          }
         }
-        if (SR_ERR_INVAL_ARG == op_rc) {
-            sr_set_error(session, "Invalid interface name.", new_val ? new_val->xpath : old_val->xpath);
+        break;
+      case SR_OP_MODIFIED:
+        op_rc = interface_ipv46_config_modify(session, if_name, old_val,
+                                              new_val, is_ipv6);
+        break;
+      case SR_OP_DELETED:
+        if (SR_LIST_T == old_val->type) {
+          /* delete on list item - reset state vars */
+          has_addr = has_prefix = false;
+        } else {
+          if (sr_xpath_node_name_eq(old_val->xpath, "ip")) {
+            ip_addr_str_to_binary(old_val->data.string_val, addr, is_ipv6);
+            has_addr = true;
+          } else if (sr_xpath_node_name_eq(old_val->xpath, "prefix-length")) {
+            prefix = old_val->data.uint8_val;
+            has_prefix = true;
+          } else if (sr_xpath_node_name_eq(old_val->xpath, "netmask")) {
+            prefix = netmask_to_prefix(old_val->data.string_val);
+            has_prefix = true;
+          }
+          if (has_addr && has_prefix) {
+            op_rc = interface_ipv46_config_add_remove(
+                if_name, addr, prefix, is_ipv6, false /* !add */);
+          }
         }
-        free(if_name);
-        sr_free_val(old_val);
-        sr_free_val(new_val);
+        break;
+      default:
+        break;
+    }
+    if (SR_ERR_INVAL_ARG == op_rc) {
+      sr_set_error(session, "Invalid interface name.",
+                   new_val ? new_val->xpath : old_val->xpath);
     }
-    sr_free_change_iter(iter);
+    free(if_name);
+    sr_free_val(old_val);
+    sr_free_val(new_val);
+  }
+  sr_free_change_iter(iter);
 
-    return op_rc;
+  return op_rc;
 }
 
 /**
- * @brief Callback to be called by any config change under "/ietf-interfaces:interfaces-state/interface" path.
- * Does not provide any functionality, needed just to cover not supported config leaves.
+ * @brief Callback to be called by any config change under
+ * "/ietf-interfaces:interfaces-state/interface" path. Does not provide any
+ * functionality, needed just to cover not supported config leaves.
  */
-static int
-ietf_interface_change_cb(sr_session_ctx_t *session, const char *module_name, const char *xpath, sr_event_t event,
-        uint32_t request_id, void *private_data)
-{
-    return SR_ERR_OK;
+static int ietf_interface_change_cb(sr_session_ctx_t *session,
+                                    const char *module_name, const char *xpath,
+                                    sr_event_t event, uint32_t request_id,
+                                    void *private_data) {
+  return SR_ERR_OK;
 }
 
-
 int ietf_subscribe_events(sr_session_ctx_t *session,
-                          sr_subscription_ctx_t **subscription){
-
-    int rc = SR_ERR_OK;
-    SRP_LOG_DBGMSG("Subscriging ietf.");
-
-    //
-    rc = sr_module_change_subscribe(session, "ietf-interfaces","/ietf-interfaces:interfaces/interface", ietf_interface_change_cb,
-                                             NULL,
-                                             0, SR_SUBSCR_CTX_REUSE | SR_SUBSCR_ENABLED, subscription);
-
-    if (rc != SR_ERR_OK) {
-        SRP_LOG_DBGMSG("Problem in subscription /ietf-interfaces:interfaces/interface\n");
-        goto error;
-    }
-
-    rc = sr_module_change_subscribe(session, "ietf-interfaces","/ietf-interfaces:interfaces/interface/enabled", ietf_interface_enable_disable_cb,
-                                             NULL,
-                                             100, SR_SUBSCR_CTX_REUSE | SR_SUBSCR_ENABLED, subscription);
-    if (rc != SR_ERR_OK) {
-        SRP_LOG_DBGMSG("Problem in subscription /ietf-interfaces:interfaces/interface/enabled\n");
-        goto error;
-    }
-
-    //rc = sr_module_change_subscribe(session, "ietf-interfaces","/ietf-interfaces:interfaces/interface/ietf-ip:ipv4/address", ietf_interface_ipv46_address_change_cb,
-    rc = sr_module_change_subscribe(session, "ietf-interfaces","/ietf-interfaces:interfaces", ietf_interface_ipv46_address_change_cb,
-                                             NULL,
-                                          99, SR_SUBSCR_CTX_REUSE | SR_SUBSCR_ENABLED, subscription);
-
-    if (rc != SR_ERR_OK) {
-        SRP_LOG_DBGMSG("Problem in subscription /ietf-interfaces:interfaces/interface/ietf-ip:ipv4/address\n");
-        goto error;
-    }
+                          sr_subscription_ctx_t **subscription) {
+  int rc = SR_ERR_OK;
+  SRP_LOG_DBGMSG("Subscriging ietf.");
+
+  //
+  rc = sr_module_change_subscribe(
+      session, "ietf-interfaces", "/ietf-interfaces:interfaces/interface",
+      ietf_interface_change_cb, NULL, 0,
+      SR_SUBSCR_CTX_REUSE | SR_SUBSCR_ENABLED, subscription);
+
+  if (rc != SR_ERR_OK) {
+    SRP_LOG_DBGMSG(
+        "Problem in subscription /ietf-interfaces:interfaces/interface\n");
+    goto error;
+  }
 
-    //rc = sr_module_change_subscribe(session, "ietf-interfaces","/ietf-interfaces:interfaces/interface/ietf-ip:ipv6/address", ietf_interface_ipv46_address_change_cb,
-    //                                         NULL,
-    //                                         98, SR_SUBSCR_CTX_REUSE | SR_SUBSCR_ENABLED, subscription);
+  rc = sr_module_change_subscribe(
+      session, "ietf-interfaces",
+      "/ietf-interfaces:interfaces/interface/enabled",
+      ietf_interface_enable_disable_cb, NULL, 100,
+      SR_SUBSCR_CTX_REUSE | SR_SUBSCR_ENABLED, subscription);
+  if (rc != SR_ERR_OK) {
+    SRP_LOG_DBGMSG(
+        "Problem in subscription "
+        "/ietf-interfaces:interfaces/interface/enabled\n");
+    goto error;
+  }
 
-    if (rc != SR_ERR_OK) {
-        SRP_LOG_DBGMSG("Problem in subscription /ietf-interfaces:interfaces/interface/ietf-ip:ipv6/address\n");
-        goto error;
-    }
+  // rc = sr_module_change_subscribe(session,
+  // "ietf-interfaces","/ietf-interfaces:interfaces/interface/ietf-ip:ipv4/address",
+  // ietf_interface_ipv46_address_change_cb,
+  rc = sr_module_change_subscribe(
+      session, "ietf-interfaces", "/ietf-interfaces:interfaces",
+      ietf_interface_ipv46_address_change_cb, NULL, 99,
+      SR_SUBSCR_CTX_REUSE | SR_SUBSCR_ENABLED, subscription);
+
+  if (rc != SR_ERR_OK) {
+    SRP_LOG_DBGMSG(
+        "Problem in subscription "
+        "/ietf-interfaces:interfaces/interface/ietf-ip:ipv4/address\n");
+    goto error;
+  }
 
- /*   rc = sr_dp_get_items_subscribe(session, "/ietf-interfaces:interfaces-state", ietf_interface_state_cb,
-                                           NULL, SR_SUBSCR_CTX_REUSE,
-                                           subscription);
-    if (rc != SR_ERR_OK) {
-    SRP_LOG_DBG_MSG("Problem in subscription /ietf-interfaces:interfaces-state\n");
+  // rc = sr_module_change_subscribe(session,
+  // "ietf-interfaces","/ietf-interfaces:interfaces/interface/ietf-ip:ipv6/address",
+  // ietf_interface_ipv46_address_change_cb,
+  //                                         NULL,
+  //                                         98, SR_SUBSCR_CTX_REUSE |
+  //                                         SR_SUBSCR_ENABLED, subscription);
+
+  if (rc != SR_ERR_OK) {
+    SRP_LOG_DBGMSG(
+        "Problem in subscription "
+        "/ietf-interfaces:interfaces/interface/ietf-ip:ipv6/address\n");
     goto error;
-    }*/
+  }
 
+  /*   rc = sr_dp_get_items_subscribe(session,
+     "/ietf-interfaces:interfaces-state", ietf_interface_state_cb, NULL,
+     SR_SUBSCR_CTX_REUSE, subscription); if (rc != SR_ERR_OK) {
+     SRP_LOG_DBG_MSG("Problem in subscription
+     /ietf-interfaces:interfaces-state\n"); goto error;
+     }*/
 
   SRP_LOG_INFMSG("ietf initialized successfully.");
   return SR_ERR_OK;
 
-  error:
+error:
   SRP_LOG_ERRMSG("Error by initialization of the ietf.");
   return rc;
 }
diff --git a/ctrl/sysrepo-plugins/hicn-plugin/plugin/ietf/ietf_interface.h b/ctrl/sysrepo-plugins/hicn-plugin/plugin/ietf/ietf_interface.h
index 0f6c7f8b4..cf5430464 100644
--- a/ctrl/sysrepo-plugins/hicn-plugin/plugin/ietf/ietf_interface.h
+++ b/ctrl/sysrepo-plugins/hicn-plugin/plugin/ietf/ietf_interface.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 HUACHENTEL and/or its affiliates.
+ * Copyright (c) 2021 HUACHENTEL 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:
@@ -19,5 +19,4 @@
 int ietf_subscribe_events(sr_session_ctx_t *session,
                           sr_subscription_ctx_t **subscription);
 
-
 #endif /* __IETF_INTERFACE_H__ */
diff --git a/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/hicn_model.c b/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/hicn_model.c
index 63685e10a..f1b804267 100644
--- a/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/hicn_model.c
+++ b/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/hicn_model.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/hicn_model.h b/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/hicn_model.h
index 62fb15340..866eafd5e 100644
--- a/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/hicn_model.h
+++ b/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/hicn_model.h
@@ -1,21 +1,22 @@
 /*
-* Copyright (c) 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.
-*/
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 /**
  * @file hicn_model.h
- * @brief This file contains main calls for hICN events coresponding to the hICN yang models
+ * @brief This file contains main calls for hICN events coresponding to the hICN
+ * yang models
  */
 
 #ifndef __IETF_HICN_H__
@@ -55,12 +56,10 @@
 /**
  * @brief enumeration for the locks
  */
-enum locks_name {lstate, lstrategy, lstrategies, lroute, lfaces};
-
+enum locks_name { lstate, lstrategy, lstrategies, lroute, lfaces };
 
 // It is a coarse grain approach later can be changed to fine grained
 
-
 /**
  * @brief This indicates the number of leaves for the hICN state
  */
@@ -78,61 +77,60 @@ enum locks_name {lstate, lstrategy, lstrategies, lroute, lfaces};
  */
 #define MAX_FACE_POOL 100
 /**
- * @brief This indicates the  maximum routes which can be read as operational data
+ * @brief This indicates the  maximum routes which can be read as operational
+ * data
  */
 #define MAX_ROUTE_POOL 100
 /**
  * @brief This indicates the number of leaves for faces
  */
-#define FACES_CHILDREN 9 /*this is the number of children of each leave in face except the key*/
+#define FACES_CHILDREN \
+  9 /*this is the number of children of each leave in face except the key*/
 /**
  * @brief This indicates the number of leaves for routes
  */
-#define ROUTES_CHILDREN  2 /*this is the number of children of each leave in face except the key*/
-
-typedef struct __attribute__ ((__packed__)) {
- int32_t retval;
- uint64_t pkts_processed;
- uint64_t pkts_interest_count;
- uint64_t pkts_data_count;
- uint64_t pkts_from_cache_count;
- uint64_t pkts_no_pit_count;
- uint64_t pit_expired_count;
- uint64_t cs_expired_count;
- uint64_t cs_lru_count;
- uint64_t pkts_drop_no_buf;
- uint64_t interests_aggregated;
- uint64_t interests_retx;
- uint64_t interests_hash_collision;
- uint64_t pit_entries_count;
- uint64_t cs_entries_count;
- uint64_t cs_entries_ntw_count;
+#define ROUTES_CHILDREN \
+  2 /*this is the number of children of each leave in face except the key*/
+
+typedef struct __attribute__((__packed__)) {
+  int32_t retval;
+  uint64_t pkts_processed;
+  uint64_t pkts_interest_count;
+  uint64_t pkts_data_count;
+  uint64_t pkts_from_cache_count;
+  uint64_t pkts_no_pit_count;
+  uint64_t pit_expired_count;
+  uint64_t cs_expired_count;
+  uint64_t cs_lru_count;
+  uint64_t pkts_drop_no_buf;
+  uint64_t interests_aggregated;
+  uint64_t interests_retx;
+  uint64_t interests_hash_collision;
+  uint64_t pit_entries_count;
+  uint64_t cs_entries_count;
+  uint64_t cs_entries_ntw_count;
 } hicn_state_t;
 
-
-typedef struct __attribute__ ((__packed__)) {
-
- uint8_t n_strategies;
- uint32_t strategy_id[256];
- int32_t retval;
+typedef struct __attribute__((__packed__)) {
+  uint8_t n_strategies;
+  uint32_t strategy_id[256];
+  int32_t retval;
 } hicn_strategies_t;
 
-
-typedef struct __attribute__ ((__packed__)) {
- uint32_t faceid;
- uint32_t intfc;
- uint64_t irx_packets;
- uint64_t irx_bytes;
- uint64_t itx_packets;
- uint64_t itx_bytes;
- uint64_t drx_packets;
- uint64_t drx_bytes;
- uint64_t dtx_packets;
- uint64_t dtx_bytes;
+typedef struct __attribute__((__packed__)) {
+  uint32_t faceid;
+  uint32_t intfc;
+  uint64_t irx_packets;
+  uint64_t irx_bytes;
+  uint64_t itx_packets;
+  uint64_t itx_bytes;
+  uint64_t drx_packets;
+  uint64_t drx_bytes;
+  uint64_t dtx_packets;
+  uint64_t dtx_bytes;
 } hicn_face_inf_t;
 
-
-typedef struct __attribute__ ((__packed__)) {
+typedef struct __attribute__((__packed__)) {
   u32 route_id;
   vapi_type_prefix prefix;
   u32 faceids[5];
@@ -143,29 +141,27 @@ typedef struct __attribute__ ((__packed__)) {
 /**
  * @brief This is the link list to maintain the statistics of the faces
  */
-struct  hicn_faces_s{
- hicn_face_inf_t face;
- struct hicn_faces_s * next;
+struct hicn_faces_s {
+  hicn_face_inf_t face;
+  struct hicn_faces_s *next;
 };
 
-
-typedef struct  __attribute__ ((__packed__)) {
- uint32_t nface;
- struct hicn_faces_s * next;
+typedef struct __attribute__((__packed__)) {
+  uint32_t nface;
+  struct hicn_faces_s *next;
 } hicn_faces_t;
 
 /**
  * @brief This is the link list to maintain the route informations
  */
-struct hicn_routes_s{
- hicn_route_inf_t route;
- struct hicn_routes_s * next;
+struct hicn_routes_s {
+  hicn_route_inf_t route;
+  struct hicn_routes_s *next;
 };
 
-
-typedef struct  __attribute__ ((__packed__)) {
- uint32_t nroute;
- struct hicn_routes_s * next;
+typedef struct __attribute__((__packed__)) {
+  uint32_t nroute;
+  struct hicn_routes_s *next;
 } hicn_routes_t;
 
 /**
@@ -173,6 +169,6 @@ typedef struct  __attribute__ ((__packed__)) {
  * as well as operational data
  */
 int hicn_subscribe_events(sr_session_ctx_t *session,
-                         sr_subscription_ctx_t **subscription);
+                          sr_subscription_ctx_t **subscription);
 
 #endif /* __IETF_HICN_H__ */
diff --git a/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/tlock.c b/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/tlock.c
index d27ae6492..c3c225ef7 100644
--- a/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/tlock.c
+++ b/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/tlock.c
@@ -1,21 +1,16 @@
-#include"tlock.h"
+#include "tlock.h"
 
-
-void ticket_init ( int Lock_Number , long int init ){
-
-//__atomic_store( &En[Lock_Number] , &init , __ATOMIC_SEQ_CST );
-//__atomic_store( &De[Lock_Number] , &init , __ATOMIC_SEQ_CST );
-En[Lock_Number]=init;
-De[Lock_Number]=init;
+void ticket_init(int Lock_Number, long int init) {
+  //__atomic_store( &En[Lock_Number] , &init , __ATOMIC_SEQ_CST );
+  //__atomic_store( &De[Lock_Number] , &init , __ATOMIC_SEQ_CST );
+  En[Lock_Number] = init;
+  De[Lock_Number] = init;
 }
 
-void tlock(int Lock_Number ){
-
- int my_ticket =   __sync_fetch_and_add(&En[Lock_Number] , 1  );
- while (    my_ticket != De[ Lock_Number ]  ) {};
-
+void tlock(int Lock_Number) {
+  int my_ticket = __sync_fetch_and_add(&En[Lock_Number], 1);
+  while (my_ticket != De[Lock_Number]) {
+  };
 }
 
-void tunlock(int Lock_Number ){
-De[Lock_Number]++;
-}
+void tunlock(int Lock_Number) { De[Lock_Number]++; }
diff --git a/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/tlock.h b/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/tlock.h
index a871705a3..be3342d3f 100644
--- a/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/tlock.h
+++ b/ctrl/sysrepo-plugins/hicn-plugin/plugin/model/tlock.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,8 +13,6 @@
  * limitations under the License.
  */
 
-
-
 /**
  * @file tlock.h
  * @brief This file contains ticket lock APIs.
@@ -23,42 +21,40 @@
 #ifndef __TLOCK_H__
 #define __TLOCK_H__
 
-
 /**
 
  * @brief limit the number of locks: it shoud be matched with the
  * number of hicn-state leaves
  */
-#define MAX_LOCK_SIZE  5
+#define MAX_LOCK_SIZE 5
 
 /**
  * @brief Ticket lock counters
  */
-volatile long int  En[MAX_LOCK_SIZE] ;
+volatile long int En[MAX_LOCK_SIZE];
 
 /**
  * @brief Ticket lock counters
  */
-volatile long int De[MAX_LOCK_SIZE] ;
-
+volatile long int De[MAX_LOCK_SIZE];
 
 /**
  * @brief This function initialize the ticket lock
  * @param Lock_Number describes the number of locks need to be initialized
  * @param init describes the init number
  */
-void ticket_init ( int Lock_Number , long int init );
+void ticket_init(int Lock_Number, long int init);
 /**
  * @brief this function acquire the lock
  * Description of what the function does. This part may refer to the parameters
  * @param Lock_Number pass the lock
  */
-void tlock(int Lock_Number );
+void tlock(int Lock_Number);
 /**
  * @briefthis function release the lock
  * @param Lock_Number lock number
 
  */
-void tunlock(int Lock_Number );
+void tunlock(int Lock_Number);
 
 #endif /* __IETF_HICN_H__ */
\ No newline at end of file
diff --git a/ctrl/sysrepo-plugins/hicn-plugin/test/vapi-test/test.c b/ctrl/sysrepo-plugins/hicn-plugin/test/vapi-test/test.c
index f7b92c3c5..d3e47c970 100755..100644
--- a/ctrl/sysrepo-plugins/hicn-plugin/test/vapi-test/test.c
+++ b/ctrl/sysrepo-plugins/hicn-plugin/test/vapi-test/test.c
@@ -5,177 +5,149 @@
 #include <signal.h>
 #include <inttypes.h>
 
-#include<vapi/hicn.api.vapi.h>
-
+#include <vapi/hicn.api.vapi.h>
 
 DEFINE_VAPI_MSG_IDS_HICN_API_JSON;
 
 vapi_ctx_t g_vapi_ctx_instance;
 
-
 #define APP_NAME "test_hicn_plugin"
 #define MAX_OUTSTANDING_REQUESTS 4
 #define RESPONSE_QUEUE_SIZE 2
 
 vapi_ctx_t g_vapi_ctx_instance = NULL;
 
-
-void usage(){
- printf("choose the test [route_add [4|6], punt_add [4|6], face_add [4|6], route_dump, face_dump]\n");
+void usage() {
+  printf(
+      "choose the test [route_add [4|6], punt_add [4|6], face_add [4|6], "
+      "route_dump, face_dump]\n");
 }
 
-static vapi_error_e call_hicn_api_punting_add(struct vapi_ctx_s *ctx,
-                           void *callback_ctx,
-                           vapi_error_e rv,
-                           bool is_last,
-                           vapi_payload_hicn_api_punting_add_reply *reply){
-if(!reply->retval){
-  printf("Successfully done");
-  return VAPI_OK;
- }else
-  return VAPI_EUSER;
+static vapi_error_e call_hicn_api_punting_add(
+    struct vapi_ctx_s *ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_hicn_api_punting_add_reply *reply) {
+  if (!reply->retval) {
+    printf("Successfully done");
+    return VAPI_OK;
+  } else
+    return VAPI_EUSER;
 }
 
-static vapi_error_e call_hicn_api_face_ip_add(struct vapi_ctx_s *ctx,
-                           void *callback_ctx,
-                           vapi_error_e rv,
-                           bool is_last,
-                           vapi_payload_hicn_api_face_ip_add_reply *reply){
-if(!reply->retval){
-  printf("Successfully done");
-  return VAPI_OK;
- }else
-  return VAPI_EUSER;
-
+static vapi_error_e call_hicn_api_face_ip_add(
+    struct vapi_ctx_s *ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_hicn_api_face_ip_add_reply *reply) {
+  if (!reply->retval) {
+    printf("Successfully done");
+    return VAPI_OK;
+  } else
+    return VAPI_EUSER;
 }
 
-static vapi_error_e call_hicn_api_route_nhops_add(struct vapi_ctx_s *ctx,
-                           void *callback_ctx,
-                           vapi_error_e rv,
-                           bool is_last,
-                           vapi_payload_hicn_api_route_nhops_add_reply *reply){
-if(!reply->retval){
-  printf("Successfully done");
-  return VAPI_OK;
- }else
-  return VAPI_EUSER;
+static vapi_error_e call_hicn_api_route_nhops_add(
+    struct vapi_ctx_s *ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_hicn_api_route_nhops_add_reply *reply) {
+  if (!reply->retval) {
+    printf("Successfully done");
+    return VAPI_OK;
+  } else
+    return VAPI_EUSER;
 }
 
-static vapi_error_e
-hicn_api_routes_dump_cb(struct vapi_ctx_s *ctx, void *callback_ctx,
-                    vapi_error_e rv, bool is_last,
-                    vapi_payload_hicn_api_routes_details *reply)
-{
-
-   char buf[20];
-   if (reply!=NULL){
-	   memset(buf, 0x00, 20);
-	   if (reply->prefix.address.af==ADDRESS_IP4){
-	     struct sockaddr_in sa;
-	     memcpy(&sa.sin_addr.s_addr, reply->prefix.address.un.ip4, 4);
-	     inet_ntop(AF_INET, &(sa.sin_addr.s_addr), buf, INET_ADDRSTRLEN);
-	     printf("Prefix:%s\n",buf);
-	   }else{
-	     struct sockaddr_in6 sa;
-	     memcpy(&sa.sin6_addr,reply->prefix.address.un.ip6,6);
-	     inet_ntop(AF_INET6, &(sa.sin6_addr), buf, INET6_ADDRSTRLEN);
-	     printf("Prefix:%s\n",buf);
-	   }
-   }else
-   {
-     printf("---------Routes------- \n");
-   }
-   return 0;
-
+static vapi_error_e hicn_api_routes_dump_cb(
+    struct vapi_ctx_s *ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_hicn_api_routes_details *reply) {
+  char buf[20];
+  if (reply != NULL) {
+    memset(buf, 0x00, 20);
+    if (reply->prefix.address.af == ADDRESS_IP4) {
+      struct sockaddr_in sa;
+      memcpy(&sa.sin_addr.s_addr, reply->prefix.address.un.ip4, 4);
+      inet_ntop(AF_INET, &(sa.sin_addr.s_addr), buf, INET_ADDRSTRLEN);
+      printf("Prefix:%s\n", buf);
+    } else {
+      struct sockaddr_in6 sa;
+      memcpy(&sa.sin6_addr, reply->prefix.address.un.ip6, 6);
+      inet_ntop(AF_INET6, &(sa.sin6_addr), buf, INET6_ADDRSTRLEN);
+      printf("Prefix:%s\n", buf);
+    }
+  } else {
+    printf("---------Routes------- \n");
+  }
+  return 0;
 }
 
-
-
-static vapi_error_e
-hicn_api_face_stats_dump_cb(struct vapi_ctx_s *ctx, void *callback_ctx,
-                    vapi_error_e rv, bool is_last,
-                    vapi_payload_hicn_api_face_stats_details *reply)
-{
-   if (reply!=NULL){
-
-     printf("face_id:%d \n", reply->faceid);
-     printf("irx_packets:%" PRId64 "\n", reply->irx_packets);
-     printf("irx_bytes:%" PRId64 "\n", reply->irx_bytes);
-     printf("itx_packets:%" PRId64 "\n", reply->itx_packets);
-     printf("itx_bytes:%" PRId64 "\n", reply->itx_bytes);
-     printf("drx_packets:%" PRId64 "\n", reply->drx_packets);
-     printf("drx_bytes:%" PRId64 "\n", reply->drx_bytes);
-     printf("dtx_packets:%" PRId64 "\n", reply->dtx_packets);
-     printf("dtx_bytes:%" PRId64 "\n", reply->dtx_bytes);
-
-   }else
-   {
-        printf("---------Facees------- \n");
-   }
-   return 0;
+static vapi_error_e hicn_api_face_stats_dump_cb(
+    struct vapi_ctx_s *ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
+    vapi_payload_hicn_api_face_stats_details *reply) {
+  if (reply != NULL) {
+    printf("face_id:%d \n", reply->faceid);
+    printf("irx_packets:%" PRId64 "\n", reply->irx_packets);
+    printf("irx_bytes:%" PRId64 "\n", reply->irx_bytes);
+    printf("itx_packets:%" PRId64 "\n", reply->itx_packets);
+    printf("itx_bytes:%" PRId64 "\n", reply->itx_bytes);
+    printf("drx_packets:%" PRId64 "\n", reply->drx_packets);
+    printf("drx_bytes:%" PRId64 "\n", reply->drx_bytes);
+    printf("dtx_packets:%" PRId64 "\n", reply->dtx_packets);
+    printf("dtx_bytes:%" PRId64 "\n", reply->dtx_bytes);
+
+  } else {
+    printf("---------Facees------- \n");
+  }
+  return 0;
 }
 
-
-int hicn_connect_vpp()
-{
-
-	if (g_vapi_ctx_instance == NULL)
-	{
-		vapi_error_e rv = vapi_ctx_alloc(&g_vapi_ctx_instance);
-		rv = vapi_connect(g_vapi_ctx_instance, APP_NAME, NULL, MAX_OUTSTANDING_REQUESTS, RESPONSE_QUEUE_SIZE, VAPI_MODE_BLOCKING, true);
-		if (rv != VAPI_OK)
-		{
-			vapi_ctx_free(g_vapi_ctx_instance);
-			return -1;
-		}
-	}
-	else
-	{
-	}
-	return 0;
+int hicn_connect_vpp() {
+  if (g_vapi_ctx_instance == NULL) {
+    vapi_error_e rv = vapi_ctx_alloc(&g_vapi_ctx_instance);
+    rv = vapi_connect(g_vapi_ctx_instance, APP_NAME, NULL,
+                      MAX_OUTSTANDING_REQUESTS, RESPONSE_QUEUE_SIZE,
+                      VAPI_MODE_BLOCKING, true);
+    if (rv != VAPI_OK) {
+      vapi_ctx_free(g_vapi_ctx_instance);
+      return -1;
+    }
+  } else {
+  }
+  return 0;
 }
 
-int hicn_disconnect_vpp()
-{
-	if (NULL != g_vapi_ctx_instance)
-	{
-		vapi_disconnect(g_vapi_ctx_instance);
-		vapi_ctx_free(g_vapi_ctx_instance);
-		g_vapi_ctx_instance = NULL;
-	}
-	return 0;
+int hicn_disconnect_vpp() {
+  if (NULL != g_vapi_ctx_instance) {
+    vapi_disconnect(g_vapi_ctx_instance);
+    vapi_ctx_free(g_vapi_ctx_instance);
+    g_vapi_ctx_instance = NULL;
+  }
+  return 0;
 }
 
-int main(int argc, char **argv)
-{
-
-  if (argc<2){
+int main(int argc, char **argv) {
+  if (argc < 2) {
     usage();
     return 1;
   }
 
-   /* connect to vpp */
+  /* connect to vpp */
   int rc = hicn_connect_vpp();
-  if (-1 == rc){
+  if (-1 == rc) {
     perror("vpp connect error");
     return -1;
   }
 
-  if (!strcmp(argv[1],"route_add")){
+  if (!strcmp(argv[1], "route_add")) {
     vapi_msg_hicn_api_route_nhops_add *msg;
     msg = vapi_alloc_hicn_api_route_nhops_add(g_vapi_ctx_instance);
 
-    if (!strcmp(argv[2],"4")){
+    if (!strcmp(argv[2], "4")) {
       struct sockaddr_in sa;
-      inet_pton(AF_INET,  "192.168.10.10", &(sa.sin_addr));
-      unsigned char * tmp = (unsigned char *) &sa.sin_addr.s_addr;
-      memcpy(&msg->payload.prefix.address.un.ip4[0],tmp,4);
+      inet_pton(AF_INET, "192.168.10.10", &(sa.sin_addr));
+      unsigned char *tmp = (unsigned char *)&sa.sin_addr.s_addr;
+      memcpy(&msg->payload.prefix.address.un.ip4[0], tmp, 4);
       msg->payload.prefix.address.af = ADDRESS_IP4;
-    }else{
+    } else {
       void *dst = malloc(sizeof(struct in6_addr));
       inet_pton(AF_INET6, "2001::1", dst);
-      unsigned char * tmp = (unsigned char *) ((struct in6_addr *)dst)->s6_addr;
-      memcpy(&msg->payload.prefix.address.un.ip6[0],tmp,16);
+      unsigned char *tmp = (unsigned char *)((struct in6_addr *)dst)->s6_addr;
+      memcpy(&msg->payload.prefix.address.un.ip6[0], tmp, 16);
       msg->payload.prefix.address.af = ADDRESS_IP6;
     }
 
@@ -189,97 +161,93 @@ int main(int argc, char **argv)
     msg->payload.face_ids[6] = 0;
     msg->payload.n_faces = 1;
 
-    if(vapi_hicn_api_route_nhops_add(g_vapi_ctx_instance,msg,call_hicn_api_route_nhops_add,NULL)!=VAPI_OK){
+    if (vapi_hicn_api_route_nhops_add(g_vapi_ctx_instance, msg,
+                                      call_hicn_api_route_nhops_add,
+                                      NULL) != VAPI_OK) {
       perror("Operation failed");
       return -1;
     }
-  }else if (!strcmp(argv[1],"face_add")){
-
+  } else if (!strcmp(argv[1], "face_add")) {
     vapi_msg_hicn_api_face_ip_add *fmsg;
     fmsg = vapi_alloc_hicn_api_face_ip_add(g_vapi_ctx_instance);
 
-
-    if (!strcmp(argv[2],"4")){
+    if (!strcmp(argv[2], "4")) {
       struct sockaddr_in sa;
-      inet_pton(AF_INET,  "192.168.50.19", &(sa.sin_addr));
-      unsigned char * tmp = (unsigned char *) &sa.sin_addr.s_addr;
-      memcpy(&fmsg->payload.face.local_addr.un.ip4[0],tmp,4);
+      inet_pton(AF_INET, "192.168.50.19", &(sa.sin_addr));
+      unsigned char *tmp = (unsigned char *)&sa.sin_addr.s_addr;
+      memcpy(&fmsg->payload.face.local_addr.un.ip4[0], tmp, 4);
       fmsg->payload.face.local_addr.af = ADDRESS_IP4;
 
-
-      inet_pton(AF_INET,  "192.168.60.10", &(sa.sin_addr));
+      inet_pton(AF_INET, "192.168.60.10", &(sa.sin_addr));
       tmp = (unsigned char *)&sa.sin_addr.s_addr;
-      memcpy(&fmsg->payload.face.remote_addr.un.ip4[0],tmp,4);
+      memcpy(&fmsg->payload.face.remote_addr.un.ip4[0], tmp, 4);
       fmsg->payload.face.remote_addr.af = ADDRESS_IP4;
 
-    }else{
-
+    } else {
       void *dst = malloc(sizeof(struct in6_addr));
       inet_pton(AF_INET6, "2001::1", dst);
-      unsigned char * tmp = (unsigned char *) ((struct in6_addr *)dst)->s6_addr;
-      memcpy(&fmsg->payload.face.local_addr.un.ip6[0],tmp,16);
+      unsigned char *tmp = (unsigned char *)((struct in6_addr *)dst)->s6_addr;
+      memcpy(&fmsg->payload.face.local_addr.un.ip6[0], tmp, 16);
       fmsg->payload.face.local_addr.af = ADDRESS_IP6;
 
-
       inet_pton(AF_INET6, "3001::1", dst);
-      tmp =(unsigned char *) ((struct in6_addr *)dst)->s6_addr;
-      memcpy(&fmsg->payload.face.remote_addr.un.ip6[0],tmp,16);
+      tmp = (unsigned char *)((struct in6_addr *)dst)->s6_addr;
+      memcpy(&fmsg->payload.face.remote_addr.un.ip6[0], tmp, 16);
       fmsg->payload.face.remote_addr.af = ADDRESS_IP6;
     }
 
-      fmsg->payload.face.swif = 0;  // This is the idx number of interface
+    fmsg->payload.face.swif = 0;  // This is the idx number of interface
 
-    if(vapi_hicn_api_face_ip_add(g_vapi_ctx_instance,fmsg,call_hicn_api_face_ip_add,NULL)!=VAPI_OK){
-    perror("Operation failed");
-    return -1;
+    if (vapi_hicn_api_face_ip_add(g_vapi_ctx_instance, fmsg,
+                                  call_hicn_api_face_ip_add, NULL) != VAPI_OK) {
+      perror("Operation failed");
+      return -1;
     }
-  }else if (!strcmp(argv[1],"route_dump")){
-  // routes dump
+  } else if (!strcmp(argv[1], "route_dump")) {
+    // routes dump
     vapi_msg_hicn_api_routes_dump *rmsg;
     rmsg = vapi_alloc_hicn_api_routes_dump(g_vapi_ctx_instance);
-    vapi_hicn_api_routes_dump(g_vapi_ctx_instance, rmsg, hicn_api_routes_dump_cb, NULL);
+    vapi_hicn_api_routes_dump(g_vapi_ctx_instance, rmsg,
+                              hicn_api_routes_dump_cb, NULL);
 
-  }else if (!strcmp(argv[1],"face_dump")){
-  // faces dump
+  } else if (!strcmp(argv[1], "face_dump")) {
+    // faces dump
     vapi_msg_hicn_api_face_stats_dump *fmsg;
     fmsg = vapi_alloc_hicn_api_face_stats_dump(g_vapi_ctx_instance);
-    vapi_hicn_api_face_stats_dump(g_vapi_ctx_instance, fmsg, hicn_api_face_stats_dump_cb, NULL);
-  }else if (!strcmp(argv[1],"punt_add")){
-
+    vapi_hicn_api_face_stats_dump(g_vapi_ctx_instance, fmsg,
+                                  hicn_api_face_stats_dump_cb, NULL);
+  } else if (!strcmp(argv[1], "punt_add")) {
     vapi_msg_hicn_api_punting_add *pmsg;
 
     pmsg = vapi_alloc_hicn_api_punting_add(g_vapi_ctx_instance);
 
-    pmsg->payload.type=IP_PUNT;
-
-    if(!strcmp(argv[2],"4")){
+    pmsg->payload.type = IP_PUNT;
 
+    if (!strcmp(argv[2], "4")) {
       struct sockaddr_in sa;
       // store this IP address in sa:
-      inet_pton(AF_INET,  "192.168.10.20", &(sa.sin_addr));
-      unsigned char * tmp =  (unsigned char *) &sa.sin_addr.s_addr;
-      memcpy(&pmsg->payload.rule.ip.prefix.address.un.ip4[0],tmp,4);
+      inet_pton(AF_INET, "192.168.10.20", &(sa.sin_addr));
+      unsigned char *tmp = (unsigned char *)&sa.sin_addr.s_addr;
+      memcpy(&pmsg->payload.rule.ip.prefix.address.un.ip4[0], tmp, 4);
       pmsg->payload.rule.ip.prefix.address.af = ADDRESS_IP4;
 
-
-    }else{
-
+    } else {
       void *dst = malloc(sizeof(struct in6_addr));
       inet_pton(AF_INET6, "3001::1", dst);
-      unsigned char * tmp =(unsigned char *) ((struct in6_addr *)dst)->s6_addr;
-      memcpy(&pmsg->payload.rule.ip.prefix.address.un.ip6[0],tmp,16);
+      unsigned char *tmp = (unsigned char *)((struct in6_addr *)dst)->s6_addr;
+      memcpy(&pmsg->payload.rule.ip.prefix.address.un.ip6[0], tmp, 16);
       pmsg->payload.rule.ip.prefix.address.af = ADDRESS_IP6;
     }
 
     pmsg->payload.rule.ip.prefix.len = 24;
     pmsg->payload.rule.ip.swif = 0;
 
-    if (vapi_hicn_api_punting_add(g_vapi_ctx_instance, pmsg, call_hicn_api_punting_add, NULL)!=VAPI_OK){
-    perror("Operation failed");
-    return -1;
+    if (vapi_hicn_api_punting_add(g_vapi_ctx_instance, pmsg,
+                                  call_hicn_api_punting_add, NULL) != VAPI_OK) {
+      perror("Operation failed");
+      return -1;
     }
-  }else
-  {
+  } else {
     usage();
     return 1;
   }
diff --git a/ctrl/sysrepo-plugins/yang/ietf/ietf-interfaces.yang b/ctrl/sysrepo-plugins/yang/ietf/ietf-interfaces.yang
index f66c205ce..a9251d14d 100644
--- a/ctrl/sysrepo-plugins/yang/ietf/ietf-interfaces.yang
+++ b/ctrl/sysrepo-plugins/yang/ietf/ietf-interfaces.yang
@@ -21,7 +21,7 @@ module ietf-interfaces {
     "This module contains a collection of YANG definitions for
      managing network interfaces.
 
-     Copyright (c) 2018 IETF Trust and the persons identified as
+     Copyright (c) 2021 IETF Trust and the persons identified as
      authors of the code.  All rights reserved.
 
      Redistribution and use in source and binary forms, with or
diff --git a/docs/etc/requirements.txt b/docs/etc/requirements.txt
index 5b037c693..3ce3a7e00 100644
--- a/docs/etc/requirements.txt
+++ b/docs/etc/requirements.txt
@@ -1,27 +1,5 @@
-alabaster==0.7.12
-Babel==2.8.0
-certifi==2019.11.28
-chardet==3.0.4
-commonmark==0.9.1
-docutils==0.16
-idna==2.8
-imagesize==1.2.0
-Jinja2==2.10.3
-MarkupSafe==1.1.1
-packaging==20.0
-Pygments==2.5.2
-pyparsing==2.4.6
-pytz==2019.3
-recommonmark==0.6.0
-requests==2.22.0
-six==1.14.0
-snowballstemmer==2.0.0
-Sphinx==2.3.1
-sphinx-rtd-theme==0.4.3
-sphinxcontrib-applehelp==1.0.1
-sphinxcontrib-devhelp==1.0.1
-sphinxcontrib-htmlhelp==1.0.2
-sphinxcontrib-jsmath==1.0.1
-sphinxcontrib-qthelp==1.0.2
-sphinxcontrib-serializinghtml==1.1.3
-urllib3==1.25.8
+pip-tools==6.5.0                        # BSD
+sphinx                                  # BSD
+sphinx-rtd-theme                        # MIT
+sphinx-markdown-tables                  # GPLv3
+recommonmark                            # MIT
\ No newline at end of file
diff --git a/docs/source/1-architecture.md b/docs/source/1-architecture.md
new file mode 100644
index 000000000..8f3cfc78a
--- /dev/null
+++ b/docs/source/1-architecture.md
@@ -0,0 +1,42 @@
+# Data identifiers and locators
+
+Hybrid ICN makes use of data identifiers to name the data produced by an end
+host. Data identifiers are encoded using a routable name prefix and a non
+routable name suffix to provide the ability to index a single IP packet in an
+prefix is unambigous manner. A full data name is composed of 160 bits. A
+routable name prefix in IPv4 network is 32 bits long while in IPv6 is 128 bits
+long. A name prefix is a valid IPv4 or IPv6 address. The 32 rightmost bits are
+used by the applications to index data within the same stream.
+
+A data source that is using the hicn stack is reacheable through IP routing
+where a producer socket is listening as the producer name prefix is IP routable.
+
+Locators are IP interface identifiers and are IPv4 or IPv6 addresses. Data
+consumers are reacheable through IP routing over their locators.
+
+For requests, the name prefix is stored in the destination address field of the
+IP header while the source address field stored the locator of the consumer.
+
+
+# Producer/Consumer Architecture
+Applications make use of the hicn network architecture by using a Prod/Cons API.
+Each communication socket is connection-less as a data producer makes data
+available to data consumer by pushing data into a named buffer. Consumers are
+responsible for pulling data from data producers by sending requests indexing
+the full data name which index a single MTU sized data packet. The core
+
+# Packet forwarding
+Packet forwarding leverages IP routing as requests are forwarded using name
+prefixes and replies using locators.
+
+# Relay nodes
+A relay node is implemented by using a packet cache which is used to temporarily
+store requests and replies. The relay node acts as a virtual proxy for the data
+producers as it caches data packets which can be sent back to data consumer by
+using the full name as an index. Requests must be cached and forwarded upstream
+towards data producers which will be able reach back the relay nodes by using
+the IP locators of the relays. Cached requests store all locators as currently
+written in the source address field of the request while requests forwarded
+upstream will get the source address rewritten with the relay node locator. Data
+packets can reach the original consumers via the relay nodes by using the
+requence of cached locators.
diff --git a/docs/source/apps.md b/docs/source/apps.md
index 64c3d9a68..4131eba82 100644
--- a/docs/source/apps.md
+++ b/docs/source/apps.md
@@ -18,7 +18,6 @@ Basic dependencies:
 - OpenSSL
 - pthreads
 - libevent
-- libparc
 - libcurl
 - libhicntransport
 
diff --git a/docs/source/conf.py b/docs/source/conf.py
index bb6715564..d00e821ab 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -19,13 +19,13 @@
 # -- Project information -----------------------------------------------------
 
 project = u'Hybrid ICN'
-copyright = u'(c) 2017-2020 Cisco and/or its affiliates.'
-author = u'Luca Muscariello'
+copyright = u'(c) 2018-2022 Cisco and/or its affiliates.'
+author = u'HICN Team Members'
 
 # The short X.Y version
 version = u''
 # The full version, including alpha/beta/rc tags
-release = u'20.01'
+release = u'22.02'
 
 
 # -- General configuration ---------------------------------------------------
@@ -37,7 +37,7 @@ release = u'20.01'
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
-extensions = ['recommonmark']
+extensions = ['recommonmark', 'sphinx_markdown_tables']
 
 # Prefix document path to section labels, otherwise autogenerated labels would look like 'heading'
 # rather than 'path/to/file:heading'
@@ -88,7 +88,7 @@ html_theme = "sphinx_rtd_theme"
 html_static_path = ['_static']
 
 def setup(app):
-    app.add_stylesheet('css/rules.css')
+    app.add_css_file('css/rules.css')
 
 # Custom sidebar templates, must be a dictionary that maps document names
 # to template names.
diff --git a/docs/source/control.md b/docs/source/control.md
index 9564a23af..f4dc4f22b 100644
--- a/docs/source/control.md
+++ b/docs/source/control.md
@@ -23,26 +23,12 @@ The YANG model for the VPP based hICN vSwitch is based the full hICN C API
 exported by the VPP plugin with the addition of some VPP APIs such as
 interface and FIB management which are required by the hICN plugin.
 
-To install libyang, sysrepo, libnetconf and netopeer2 for Ubuntu18 amd64/arm64
-or CentOS 7 and ad-hoc repository is available and maintained in bintray
-at <https://dl.bintray.com/icn-team/apt-hicn-extras>.
+The dependencies libyang, sysrepo, libnetconf and netopeer2 for Ubuntu20.04
+amd64/arm64 are built from sources. See the following Dockerfile for
+reference:
 
-For instance in Ubuntu 18 LTS:
+<https://github.com/icn-team/vSwitch/blob/master/Dockerfile>
 
-Install the sysrepo YANG data store and a NETCONF server:
-
-```bash
-echo "deb [trusted=yes] https://dl.bintray.com/icn-team/apt-hicn-extras bionic main" \
-                                            | tee -a /etc/apt/sources.list
-apt-get update && apt-get install -y libyang sysrepo libnetconf2 netopeer2-server
-```
-
-Install the VPP based hICN virtual switch:
-
-```bash
-curl -s https://packagecloud.io/install/repositories/fdio/release/script.deb.sh | bash
-apt-get update && apt-get install -y hicn-plugin vpp-plugin-dpdk hicn-sysrepo-plugin
-```
 
 The hICN YANG models are installed under `/usr/lib/$(uname -m)-linux-gnu/modules_yang`.
 
diff --git a/docs/source/hicn-light.md b/docs/source/hicn-light.md
index 90e0afc91..f5012f8e9 100644
--- a/docs/source/hicn-light.md
+++ b/docs/source/hicn-light.md
@@ -11,15 +11,14 @@ to communicate.
 
 Build dependencies:
 
-- C99 ( clang / gcc )
-- CMake 3.4
+- C11 ( clang / gcc )
+- CMake 3.10
 
 Basic dependencies:
 
 - OpenSSL
 - pthreads
 - libevent
-- libparc
 
 ## hicn-light executables
 
@@ -37,31 +36,27 @@ The command `hicn-light-daemon` runs the hicn-light forwarder. The forwarder can
 with the following options:
 
 ```bash
-hicn-light-daemon [--port port] [--daemon] [--capacity objectStoreSize] [--log facility=level]
+hicn-light-daemon [--port port] [--daemon] [--capacity objectStoreSize] [--log level]
                 [--log-file filename] [--config file]
 
 Options:
---port <tcp_port>           = tcp port for local in-bound connections
---daemon                    = start as daemon process
---capacity <capacity>       = maximum number of content objects to cache. To disable the cache
-                              objectStoreSize must be 0.
-                              Default vaule for objectStoreSize is 100000
---log <log_granularity>     = sets a facility to a given log level. You can have multiple of these.
-                              facilities: all, config, core, io, message, processor
-                              levels: debug, info, notice, warning, error, critical, alert, off
-                              example: hicn-light-daemon --log io=debug --log core=off
---log-file <output_logfile> = file to write log messages to (required in daemon mode)
---config <config_path>      = configuration filename
+--port <tcp_port>               = tcp port for local in-bound connections
+--daemon                        = start as daemon process
+--capacity <objectStoreSize>    = maximum number of content objects to cache. To disable the cache
+                                  objectStoreSize must be 0.
+                                  Default vaule for objectStoreSize is 100000
+--log <log_granularity>         = sets the log level. Available levels: trace, debug, info, warn, error, fatal
+--log-file <output_logfile>     = file to write log messages to (required in daemon mode)
+--config <config_path>          = configuration filename
 ```
 
 The configuration file contains configuration lines as per hicn-light-control (see below for all
 the available commands). If logging level or content store capacity is set in the configuration
-file, it overrides the command_line. When a configuration file is specified, no default listeners
-are setup.  Only 'add listener' lines in the configuration file matter.
+file, it overrides the command_line.
 
-If no configuration file is specified, hicn-light-daemon will listen on TCP and UDP ports specified
-by the --port flag (or default port).  It will listen on both IPv4 and IPv6 if available. The
-default port for hicn-light is 9695. Commands are expected on port 2001.
+In addition to the listeners setup in the configuration file, hicn-light-daemon will listen
+on TCP and UDP ports specified by the --port flag (or default port).
+It will listen on both IPv4 and IPv6 if available. The default port for hicn-light is 9695.
 
 ### hicn-light-control
 
@@ -82,28 +77,20 @@ This is the full list of available commands in `hicn-light-control`. This comman
 from the command line running `hicn-light-control` as explained before, or listing them in a
 configuration file.
 
-Information about the commands are also available in the `hicn-light-control` help message.
+The list of commands can be navigated using `hicn-light-control help`, `hicn-light-control help <object>`, `hicn-light-control help <object> <action>`.
 
 `add listener`: creates a TCP or UDP listener with the specified options on the local forwarder.
 For local connections (application to hicn-light) we expect a TCP listener. The default port for
 the local listener is 9695.
 
 ```bash
-add listener <protocol> <symbolic> <local_adress> <local_port>
+add listener <protocol> <symbolic> <local_address> <local_port> <interface>
 
   <symbolic>        :User defined name for listener, must start with alpha and bealphanum
   <protocol>        :tcp | udp
   <localAddress>    :IPv4 or IPv6 address
   <local_port>      :TCP/UDP port
-```
-
-`add listener hicn`: creates a hicn listener with the specified options on the local forwarder.
-
-```bash
-add listener hicn <symbolic> <local_adress>
-
-  <symbolic>        :User defined name for listener, must start with alpha and be alphanum
-  <localAddress>    :IPv4 or IPv6 address
+  <interface>       :interface on which to bind
 ```
 
 `add connection`: creates a TCP or UDP connection on the local forwarder with the specified options.
@@ -119,17 +106,6 @@ add connection <protocol> <symbolic> <remote_ip> <remote_port> <local_ip> <local
   <local_port>            : local TCP/UDP port
 ```
 
-`add connection hicn`: creates an hicn connection on the local forwarder with the specified options.
-
-```bash
-add connection hicn <symbolic> <remote_ip> <local_ip>
-
-  <symbolic>            : symbolic name, e.g. 'conn1' (must be unique, start with alpha)
-  <remote_ip>           : the IPv4 or IPv6 of the remote system
-  <local_ip>            : local IP address to bind to
-
-```
-
 `list`: lists the connections, routes or listeners available on the local hicn-light forwarder.
 
 ```bash
@@ -142,7 +118,7 @@ list <connections | routes | listeners>
 add route <symbolic | connid> <prefix> <cost>
 
   <symbolic>   :The symbolic name for an exgress (must be unique, start with alpha)
-  <connid>:    :The egress connection id (see 'help list connections')
+  <connid>:    :The egress connection id (see 'list connection' command)
   <prefix>:    :ipAddress/netmask
   <cost>:      :positive integer representing cost
 ```
@@ -151,11 +127,10 @@ add route <symbolic | connid> <prefix> <cost>
 only for UDP connections, TCP is ignored.
 
 ```bash
-remove connection <protocol> <symbolic | connid>
+remove connection <symbolic | connid>
 
-  <protocol>   : tcp | upd. This is the protocol used to create the connection.
   <symbolic>   :The symbolic name for an exgress (must be unique, start with alpha)
-  <connid>:    :The egress connection id (see 'help list connections')
+  <connid>:    :The egress connection id (see 'list connection' command)
 
 ```
 
@@ -168,24 +143,24 @@ remove route <symbolic | connid> <prefix>
   <prefix>    : the prefix (ipAddress/netmask) to remove
 ```
 
-`cache serve`: enables/disables replies from local content store (if available).
+`serve cache`: enables/disables replies from local content store (if available).
 
 ```bash
-cache serve <on|off>
+serve cache <on|off>
 ```
 
-`cache store`:  enables/disables the storage of incoming data packets in the local content store
+`store cache`:  enables/disables the storage of incoming data packets in the local content store
 (if available).
 
 ```bash
-cache store <on|off>
+store cache <on|off>
 
 ```
 
-`cache clear`: removes all the cached data form the local content store (if available).
+`clear cache`: removes all the cached data form the local content store (if available).
 
 ```bash
-cache clear
+clear cache
 ```
 
 `set strategy`: sets the forwarding strategy for a give prefix. There are 4 different strategies
@@ -200,12 +175,14 @@ implemented in hicn-light:
   ICNP 2013.
 - **low_latency**: uses the face with the lowest latency. In case more faces have similar
   latency the  strategy uses them in parallel.
+- **replication**
+- **bastpath**
 
 ```bash
 set strategy <prefix> <strategy>
 
   <preifx>    : the prefix to which apply the forwarding strategy
-  <strategy>  : random | loadbalancer | low_latency
+  <strategy>  : random | loadbalancer | low_latency | replication | bestpath
 ```
 
 `set wldr`: turns on/off WLDR on the specified connection. WLDR (Wireless Loss Detiection and
@@ -224,36 +201,13 @@ set wldr <on|off> <symbolic | connid>
 
 ```
 
-`add punting`: add punting rules to the forwarders.
-
-```bash
-add punting <symbolic> <prefix>
-
- <symbolic> : listener symbolic name
- <address>  : prefix to add as a punting rule. (example 1234::0/64)
-```
-
-`mapme enable`: enables/disables mapme.
-
-```bash
-mapme enable <on|off>
-```
-`mapme discovery`: enables/disables mapme discovery.
-
-```bash
-mapme discovery <on|off>
-```
-
-`mapme timescale`: set the timescale value expressed in milliseconds.
-
-```bash
-mapme timescale <milliseconds>
-```
-
-`mapme retx`: set the retransmission time value expressed in millisecond.
+`set mapme`: enables/disables mapme, enables/disables mapme discovery, set the timescale value (expressed in milliseconds), set the retransmission time value (expressed in milliseconds).
 
 ```bash
-mapme retx <milliseconds>
+mapme set enable <on|off>
+mapme set discovery <on|off>
+mapme set timescale <milliseconds>
+mapme set retx <milliseconds>
 ```
 
 `quit`: exits the interactive bash.
@@ -264,13 +218,12 @@ This is an example of a simple configuration file for hicn-light. It can be load
 the command `hicn-light-daemon --config configFile.cfg`, assuming the file name is `configFile.cfg`.
 
 ```bash
-#create a local listener on port 9199. This will be used by the applications to talk
-with the forwarder
-add listener udp local0 192.168.0.1 9199
+# Create a local listener on port 9199. This will be used by the applications to talk with the forwarder
+add listener udp local0 192.168.0.1 9199 eth0
 
-#create a connection with a remote hicn-light-daemon, with a listener on 192.168.0.20 12345
-add connection udp conn0 192.168.0.20 12345 192.168.0.1 9199
+# Create a connection with a remote hicn-light-daemon, with a listener on 192.168.0.20 12345
+add connection udp conn0 192.168.0.20 12345 192.168.0.1 9199 eth0
 
-#add a route toward the remote node
+# Add a route toward the remote node
 add route conn0 c001::/64 1
 ```
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 99ea39afa..c41df95ca 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -1,27 +1,76 @@
 Hybrid Information-Centric Networking
 =====================================
 
-Hybrid Information-Centric Networking (hICN) is a network architecture that makes
-use of IPv6 or IPv4 to realize location-independent communications. It is largely
-inspired by the pioneer work of Van Jacobson on Content-Centric Networking, that was
-a clean-slate architecture whereas hICN is based on the Internet protocol and easy to
-deploy in today networks and applications. hICN brings many-to-many communications,
-multi-homing, multi-path, multi-source, group communications to the Internet protocol
-without replicated unicast. The project implements novel transport protocols, with a socket API,
-for real-time and capacity seeking applications. A scalable stack is available based
-on VPP and a client stack is provided to support any mobile and desktop operating system.
+Hybrid Information-Centric Networking (hICN) is a network architecture that
+makes use of IPv6 or IPv4 to implement location-independent communications. It
+is largely inspired by the pioneer work of Van Jacobson on Content-Centric
+Networking (RFC 8569, RFC 8609) that is a clean-slate architecture. hICN is
+based on the Internet protocol and easyier to deploy in today networks and
+applications. hICN brings many-to-many communications, multi-homing, multi-path,
+multi-source, group communications to the Internet protocol. The current code
+implements also transport protocols, with a socket API, for real-time and
+capacity seeking applications. A scalable stack is available based on VPP and a
+client stack is provided to support  mobile and desktop operating systems.
+
+A detailed description of the architecture is described in the paper
+
+Giovanna Carofiglio, Luca Muscariello, Jordan Augé, Michele Papalini, Mauro
+Sardara, and Alberto Compagno. 2019. Enabling ICN in the Internet Protocol:
+Analysis and Evaluation of the Hybrid-ICN Architecture. In Proceedings of the
+6th ACM SIGCOMM Conference on Information-Centric Networking (ICN '19).
+Association for Computing Machinery, New York, NY, USA, 55–66. DOI:
+https://doi.org/10.1145/3357150.3357394
+
+The project wiki page is full of resources  https://wiki.fd.io/view/HICN
+
+.. toctree::
+   :caption: Architecture
+
+   1-architecture
+
 
 .. toctree::
+   :caption: Getting started
+   :maxdepth: 1
 
    started
+
+.. toctree::
+   :caption: Core library
+   :maxdepth: 1
+
    lib
+
+.. toctree::
+   :caption: The VPP Plugin
+   :maxdepth: 1
+
    vpp-plugin
+
+.. toctree::
+   :caption: The Transport Library
+   :maxdepth: 1
+
    transport
+
+.. toctree::
+   :caption: The Portable Forwarder
+   :maxdepth: 1
+
    hicn-light
+
+.. toctree::
+   :caption: Network Control and Management
+   :maxdepth: 1
+
    interface
    control
    telemetry
-   utils
-   apps
 
+.. toctree::
+   :caption: Applications and Tools
+   :maxdepth: 1
 
+   utils
+   apps
+   packethicn
\ No newline at end of file
diff --git a/docs/source/interface.md b/docs/source/interface.md
index cf05a5c7b..909f60bfa 100644
--- a/docs/source/interface.md
+++ b/docs/source/interface.md
@@ -45,35 +45,6 @@ interfaces:
     link and address information, interface types, and bonjour service
     discovery.
 
-### Architectural overview
-
-#### Facelets
-
-TODO:
-
-```text
-- Key attributes (netdevice and protocol family)
-- Facelet API
-```
-
-#### Events
-
-TODO
-
-#### Facelet cache & event scheduling
-
-TODO:
-
-```text
- - Facelet cache
- - Joins
- - How synchronization work
-```
-
-### Interface API
-
-TODO
-
 ## Developing a new interface
 
 ### Dummy template
@@ -261,7 +232,7 @@ error.
 ```
 
 While support for multiple file descriptors might be added in the future, an
-alternative short-term implementation might consider the instanciation of
+alternative short-term implementation might consider the instantiation of
 multiple interface, as is done for Bonjour in the current codebase, in
 `src/api.c`.
 
@@ -304,8 +275,6 @@ The build system is based on CMake. Each interface should declare its source
 files, private and public header files, as well as link dependencies in the
 local `CMakeLists.txt` file.
 
-TODO: detail the structure of the file
-
 ### Hands-on
 
 #### Architecture
diff --git a/docs/source/packethicn.md b/docs/source/packethicn.md
index cf4976837..acf2d7cc9 100644
--- a/docs/source/packethicn.md
+++ b/docs/source/packethicn.md
@@ -1,11 +1,13 @@
 HICN Plugin for Wireshark
 ===================
 
-The `packethicn` plugin adds support to Wireshark to parse and dissect HICN traffic.
+The `packethicn` plugin adds support to Wireshark to parse and dissect HICN
+traffic.
 
 `packethicn` can be compiled and installed in two ways:
 
-1. Alongside HICN, from the HICN root dir (see [Build with HICN](#Build-with-HICN))
+1. Alongside HICN, from the HICN root dir (see [Build with
+   HICN](#Build-with-HICN))
 
 2. As a standalone component (see [Standalone build](#Standalone-build))
 
@@ -14,13 +16,12 @@ The second one is preferred if HICN is already installed in the system.
 # Supported platforms
 `packethicn` has been tested in
 
-- Ubuntu 18.04
 - Ubuntu 20.04
-- macOS 11.2
+- macOS 12.3
 
 Other platforms and architectures may work.
 
-# Installation 
+# Installation
 ## Build with HICN
 
 ### Dependencies
@@ -38,15 +39,10 @@ From the root HICN dir add the `-DBUILD_WSPLUGIN` flag to cmake.
 
 ```bash
 $ cd hicn
-
 $ mkdir build; cd build
-
-$ cmake -DOPENSSL_ROOT_DIR=/usr/local/opt/openssl\@1.1 -DBUILD_APPS=ON -DBUILD_WSPLUGIN=ON ..
-
+$ cmake -DBUILD_APPS=ON -DBUILD_WSPLUGIN=ON ..
 $ make -j`nproc`
-
 $ sudo make install
-
 ```
 
 ## Standalone build
@@ -55,22 +51,16 @@ $ sudo make install
 #### Install dependencies
 ```bash
 $ sudo add-apt-repository ppa:wireshark-dev/stable
-
 $ curl -s https://packagecloud.io/install/repositories/fdio/release/script.deb.sh | sudo bash
-
 $ sudo apt install -y build-essential cmake libhicn-dev wireshark wireshark-dev libgcrypt-dev libgnutls28-dev
 
 ```
-#### Compile and install HICN plugin
+#### Compile and install HICN wireshark plugin
 ```bash
 $ cd packethicn
-
 $ mkdir build; cd build
-
 $ cmake ..
-
 $ make
-
 $ sudo make install
 ```
 
@@ -80,15 +70,10 @@ If installing wireshark via brew use the `./install_macos.sh` script as shown be
 
 ```bash
 $ brew tap icn-team/hicn-tap
-
 $ brew install hicn
-
 $ brew install wireshark
-
 $ brew install cask wireshark
-
 $ cd packethicn
-
 $ ./install_macos.sh
 ```
 
@@ -96,13 +81,9 @@ Otherwise (if wireshark was compiled from sources) you can follow the setup for
 
 ```bash
 $ cd packethicn
-
 $ mkdir build; cd build
-
 $ cmake ..
-
 $ make
-
 $ sudo make install
 ```
 
@@ -110,6 +91,7 @@ $ sudo make install
 
 ## Filters
 
+
 | Filter | Description | Example |
 | --- | --- | --- |
 | `hicn`  | HICN traffic only  | *hicn* |
diff --git a/docs/source/started.md b/docs/source/started.md
index ef3763366..dd2f83bab 100644
--- a/docs/source/started.md
+++ b/docs/source/started.md
@@ -1,15 +1,16 @@
-# Getting started
+# Code structure
 
 ## Introduction
 
-hicn is an open source implementation of Cisco's hICN. It includes a network stack, that implements
-ICN forwarding path in IPv6, and a transport stack that implements two main transport protocols and
-a socket API. The transport protocols provide one reliable transport service implementation and a
-real-time transport service for audio/video media.
+hicn is an open source implementation of Cisco's hICN. It includes a network
+stack, that implements ICN forwarding path in IPv6, and a transport stack that
+implements two main transport protocols and a socket API. The transport
+protocols provide one reliable transport service implementation and a real-time
+transport service for audio/video media.
 
 ## Directory layout
 
-```text
+
 | Directory name | Description                                               |
 | -------------- | --------------------------------------------------------- |
 | lib            | Core support library                                      |
@@ -19,39 +20,36 @@ real-time transport service for audio/video media.
 | utils          | Tools for testing                                         |
 | apps           | Application examples using hicn stack                     |
 | ctrl           | Tools and libraries for network management and control    |
-```
 
-hicn plugin is a VPP plugin that implement hicn packet processing as specified in
-<https://datatracker.ietf.org/doc/draft-muscariello-intarea-hicn/.> The transport library is used to
-implement the hicn host stack and makes use of libmemif as high performance connector between
-transport and the network stack. The transport library makes use of VPP binary API to configure the
-local namespace (local face management).
+hicn plugin is a VPP plugin that implement hicn packet processing as specified
+in [1] The transport library is used to implement the hicn host stack and makes
+use of libmemif as high performance connector between transport and the network
+stack. The transport library makes use of VPP binary API to configure the local
+namespace (local face management).
 
 ## Release note
 
-The current master branch provides the latest release which is compatible with the latest VPP stable.
-No other VPP releases are supported nor maintained. At every new VPP release distribution hicn
-master branch is updated to work with the latest stable release. All previous stable releases
-are discontinued and not maintained. The user who is interested in a specific release can always
-checkout the right code tree by searching the latest commit under a given git tag carrying the
-release version.
+The current master branch provides the latest release which is compatible with
+the latest VPP stable. No other VPP releases are supported nor maintained. At
+every new VPP release distribution hicn master branch is updated to work with
+the latest stable release. All previous stable releases are discontinued and not
+maintained. The user who is interested in a specific release can always checkout
+the right code tree by searching the latest commit under a given git tag
+carrying the release version.
 
-The Hybrid ICN software distribution can be installed for several platforms.
-The network stack comes in two different implementations: one scalable based
-on VPP and one portable based on IPC and sockets.
+The Hybrid ICN software distribution can be installed for several platforms. The
+network stack comes in two different implementations: one scalable based on VPP
+and one portable based on IPC and sockets.
 
-The transport stack is a unique library that is used for both the scalable
-and portable network stacks.
+The transport stack is a unique library that is used for both the scalable and
+portable network stacks.
 
 ## Supported platforms
 
-- Ubuntu 18.04 LTS (amd64, arm64)
-- Debian Stable/Testing
-- Red Hat Enterprise Linux 7
-- CentOS 7
+- Ubuntu 20.04 LTS (amd64, arm64)
 - Android 10 (amd64, arm64)
-- iOS 13
-- macOS 10.15
+- iOS 15
+- macOS 12.3
 - Windows 10
 
 Other platforms and architectures may work.
@@ -63,35 +61,97 @@ You can either use released packages, or compile hicn from sources.
 curl -s https://packagecloud.io/install/repositories/fdio/release/script.deb.sh | sudo bash
 ```
 
-### CentOS
+The following debian packages for Ubuntu are available dor amd64 and arm64
 
 ```bash
-curl -s https://packagecloud.io/install/repositories/fdio/release/script.rpm.sh | sudo bash
+facemgr-dev
+facemgr
+hicn-apps-dev
+hicn-apps
+hicn-light
+hicn-plugin-dev
+hicn-plugin
+libhicn-dev
+libhicn
+libhicnctrl-dev
+libhicnctrl-modules
+libhicnctrl
+libhicntransport-dev
+libhicntransport-io-modules
+libhicntransport
 ```
 
 ### macOS
 
 ```bash
+brew tap icn-team/hicn-tap
 brew install hicn
 ```
 
+or
+
+```bash
+git clone https://github.com/FDio/hicn.git
+$ cd hicn
+$ OPENSSL_ROOT_DIR=/usr/local/opt/openssl\@1.1 make build-release
+```
+
 ### Android
+hICN is built as a native library for the Android NDK which are packaged
+as Android archives AAR and made available in a Maven repository in
+Github Packages in
+
+<https://github.com/orgs/icn-team/packages>
+
+To build from sources, refer to the Android SDK in
+
+<https://github.com/icn-team/android-sdk>
 
 Install the applications via the Google Play Store
+
 <https://play.google.com/store/apps/developer?id=ICN+Team>
 
 ### iOS
 
-Coming soon.
+Clone this distro
+
+```bash
+git clone https://github.com/icn-team/ios-sdk.git
+cd ios-sdk
+```
+Compile everything (dependencies and hICN modules)
+
+```bash
+make update
+make all
+```
+Compile everything with Qt (dependencies, hICN modules and Viper dependencies)
+
+```bash
+make update
+make all_qt
+```
 
 ### Windows
 
-Coming soon.
+Install vcpkg
+
+```bash
+git clone https://github.com/icn-team/windows-sdk
+.\windows-sdk\scripts\init.bat
+```
+
+
+```bash
+cd windows-sdk
+make all
+```
 
 ### Docker
 
-Several docker images are nightly built with the latest software  for Ubuntu 18 LTS (amd64/arm64),
-and available on docker hub at  <https://hub.docker.com/u/icnteam>.
+Several docker images are nightly built with the latest software  for Ubuntu 18
+LTS (amd64/arm64), and available on docker hub at
+<https://hub.docker.com/u/icnteam>.
 
 The following images are nightly built and maintained.
 
@@ -106,6 +166,8 @@ docker pull icnteam/vhttpproxy:amd64
 docker pull icnteam/vhttpproxy:arm64
 ```
 
+Other Dockerfiles are included in the main git repo for development.
+
 ### Vagrant
 
 Vagrant boxes for a virtual switch are available at
@@ -117,12 +179,21 @@ vagrant box add icnteam/vswitch
 
 Supported providers are libvirt, vmware and virtualbox.
 
+## References
+
+Giovanna Carofiglio, Luca Muscariello, Jordan Augé, Michele Papalini, Mauro
+Sardara, and Alberto Compagno. 2019. Enabling ICN in the Internet Protocol:
+Analysis and Evaluation of the Hybrid-ICN Architecture. In Proceedings of the
+6th ACM Conference on Information-Centric Networking (ICN '19). Association for
+Computing Machinery, New York, NY, USA, 55–66.
+DOI: https://doi.org/10.1145/3357150.3357394
+
 ## License
 
 This software is distributed under the following license:
 
 ```bash
-Copyright (c) 2017-2020 Cisco and/or its affiliates.
+Copyright (c) 2019-2022 Cisco and/or its affiliates.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at:
diff --git a/docs/source/telemetry.md b/docs/source/telemetry.md
index 8887b8f1f..f81d21ee1 100644
--- a/docs/source/telemetry.md
+++ b/docs/source/telemetry.md
@@ -31,17 +31,14 @@ sudo make install
 
 hICN collectd plugins have been tested in:
 
-- Ubuntu 16.04 LTS (x86_64)
-- Ubuntu 18.04 LTS (x86_64)
-- Debian Stable/Testing
-- Red Hat Enterprise Linux 7
-- CentOS 7
+- Ubuntu 20.04 LTS
 
 ### Dependencies
 
 Build dependencies:
 
-- VPP 20.01, Debian packages can be found on [packagecloud](https://packagecloud.io/fdio/release/install):
+VPP 22.02, Debian packages can be found on
+[packagecloud](https://packagecloud.io/fdio/release/install):
   - vpp
   - libvppinfra-dev
   - vpp-dev
@@ -62,14 +59,18 @@ Before running collectd, a vpp forwarder must be started. If the vpp-hicn plugin
 is used, the hicn-plugin must be available in the vpp forwarder.
 
 If you need the custom types that the two plugins define, they are present in
-`telemetry/custom_types.db`. It is useful if you are using InfluxDB as it requires
-the type database for multi-value metrics
-(see [CollectD protocol support in InfluxDB](https://docs.influxdata.com/influxdb/v1.7/supported_protocols/collectd/)).
+`telemetry/custom_types.db`. It is useful if you are using InfluxDB as it
+requires the type database for multi-value metrics (see [CollectD protocol
+support in
+InfluxDB](https://docs.influxdata.com/influxdb/v1.7/supported_protocols/collectd/)).
 
 ## Plugin options
 `vpp` and `vpp-hicn` have the same two options:
-- `Verbose` enables additional statistics. You can check the sources to have an exact list of available metrics.
-- `Tag` tags the data with the given string. Useful for identifying the context in which the data was retrieved in InfluxDB for instance. If the tag value is `None`, no tag is applied.
+- `Verbose` enables additional statistics. You can check the sources to have an
+  exact list of available metrics.
+- `Tag` tags the data with the given string. Useful for identifying the context
+  in which the data was retrieved in InfluxDB for instance. If the tag value is
+  `None`, no tag is applied.
 
 ### Example: storing statistics from vpp and vpp-hicn
 
diff --git a/docs/source/transport.md b/docs/source/transport.md
index 3e7844ad5..eb5b9d71a 100644
--- a/docs/source/transport.md
+++ b/docs/source/transport.md
@@ -1,38 +1,51 @@
-# Transport library
-
 ## Introduction
 
-This library provides transport services and socket API for applications willing to communicate
-using the hICN protocol stack.
+The transport library provides transport services and socket API for
+applications willing to communicate using the hICN protocol stack.
 
 Overview:
 - Implementation of the hICN core objects (interest, data, name..) exploiting
-  the API provided by [libhicn](../lib).
-- Connectors for connecting the application to either the hicn-plugin or the
-  hicn-light forwarder.
+  the API provided by [libhicn](./lib.md).
+- IO modules for seamlessly connecting the application to the hicn-plugin for [VPP](https://github.com/FDio/vpp) or the
+  [hicn-light](./hicn-light.md) forwarder.
 - Transport protocols (RAAQM, CBR, RTC)
-- Transport services (authentication, integrity, segmentation, reassembly, naming)
+- Transport services (authentication, integrity, segmentation, reassembly,
+  naming)
 - Interfaces for applications (from low-level interfaces for interest-data
   interaction to high level interfaces for Application Data Unit interaction)
 
+
 ## Build dependencies
 
 ### Ubuntu
 
-- libparc
-- libmemif (linux only, if compiling with VPP support)
-- libasio
+```bash
+sudo apt install libasio-dev libconfig++-dev libssl-dev
+```
 
 If you wish to use the library for connecting to the vpp hicn-plugin, you will
-need to also install vpp, the vpp libraries and the libmemif libraries:
+need to also install vpp and its libraries.
 
-- DEB packages:
-  - vpp
-  - vpp-lib
-  - vpp-dev
+```bash
+# Prevent vpp to set sysctl
+export VPP_INSTALL_SKIP_SYSCTL=1
+VPP_VERSION=$(cat "${VERSION_PATH}" | grep VPP_DEFAULT_VERSION | cut -d ' ' -f 2 | tr -d '"' | grep -Po '\d\d.\d\d')
 
-You can get them either from from the vpp packages or the source code. Check
-the [VPP wiki](https://wiki.fd.io/view/VPP) for instructions.
+curl -s https://packagecloud.io/install/repositories/fdio/${VPP_VERSION//./}/script.deb.sh | bash
+curl -L https://packagecloud.io/fdio/${VPP_VERSION//./}/gpgkey | apt-key add -
+sed -E -i 's/(deb.*)(\[.*\])(.*)/\1\3/g' /etc/apt/sources.list.d/fdio_${VPP_VERSION//./}.list
+apt-get update
+
+apt-get install -y \
+  vpp-dev \
+  libvppinfra-dev \
+  vpp-plugin-core \
+  vpp \
+  libvppinfra
+```
+
+You can get them either from from the vpp packages or the source code. Check the
+[VPP wiki](https://wiki.fd.io/view/VPP) for instructions.
 
 ### macOS
 
@@ -40,31 +53,23 @@ We recommend to use [HomeBrew](https://brew.sh/) for installing the libasio
 dependency:
 
 ```bash
-brew install asio
+brew install asio libconfig openssl@1.1
 ```
 
-Download, compile and install libparc:
+Since VPP does not support macOS, the IO module memif is not built.
 
-```bash
-git clone -b cframework/master https://gerrit.fd.io/r/cicn cframework && cd cframework
-mkdir -p libparc.build && cd libparc.build
-cmake ../libparc
-make
-make install
-```
-
-Libparc will be installed by default under `/usr/local/lib` and `/usr/local/include`.
-Since VPP does not support macOS, the hicn-plugin connector is not built.
 
 ## Build the library
 
-From the project root folder:
+The library is built by default from the main CMakeLists.txt.
+If you have all the dependencies installed, including [libhicn](./lib.md),
+you can also build libtransport alone:
 
 ```bash
 cd libtransport
 mkdir build && cd build
 cmake ..
-make
+cmake --build .
 ```
 
 ### Compile options
@@ -75,11 +80,7 @@ The build process can be customized with the following options:
 - `CMAKE_BUILD_TYPE`: The build configuration. Options: `Release`, `Debug`.
   Default is `Release`.
 - `ASIO_HOME`: The folder containing the libasio headers.
-- `LIBPARC_HOME`: The folder containing the libparc headers and libraries.
 - `VPP_HOME`: The folder containing the installation of VPP.
-- `LIBMEMIF_HOME`: The folder containing the libmemif headers and libraries.
-- `BUILD_MEMIF_CONNECTOR`: On linux, set this value to `ON` for building the
-  VPP connector.
 
 An option can be set using cmake -D`OPTION`=`VALUE`.
 
@@ -88,5 +89,245 @@ An option can be set using cmake -D`OPTION`=`VALUE`.
 For installing the library, from the cmake build folder:
 
 ```bash
-sudo make install
+cmake --build . -- install
+```
+
+
+## Usage
+
+Examples on how to use the library can be found in the apps folder of the project.
+In particular you can check the **hiperf** application, which demonstrates
+how to use the API to interact with the hicn transport, both for consumer and producer.
+
+### Configuration file
+
+The transport can be configured using a configuration file. There are two ways
+to tell libransport where to find the configuration file:
+
+- programmatically - you set the configuration file path in your application:
+```cpp
+// Set conf file path
+std::string conf_file = "/opt/hicn/etc/transport.config"
+// Parse config file
+transport::interface::global_config::parseConfigurationFile(conf_file);
+```
+
+- using the environment variable `TRANSPORT_CONFIG`:
+```bash
+export TRANSPORT_CONFIG=/opt/hicn/etc/transport.config
+./hiperf -C b001::1
 ```
+
+Here is an example of configuration file:
+
+```
+// Configuration for io_module
+io_module = {
+  path = [];
+  name = "forwarder_module";
+};
+
+// Configuration for forwarder io_module
+forwarder = {
+  n_threads = 1;
+
+  connectors = {
+    c0 = {
+      /* local_address and local_port are optional */
+      local_address = "127.0.0.1";
+      local_port = 33436;
+      remote_address = "127.0.0.1";
+      remote_port = 33436;
+    }
+  };
+
+  listeners = {
+    l0 = {
+      local_address = "127.0.0.1";
+      local_port = 33437;
+    }
+  };
+};
+
+// Logging
+log = {
+  // Log level (INFO (0), WARNING (1), ERROR (2), FATAL (3))
+  minloglevel = 0;
+
+  // Verbosity level for debug logs
+  v= 2;
+
+  // Log to stderr
+  logtostderr = true;
+
+  // Get fancy colored logs
+  colorlogtostderr = true;
+
+  // Log messages above this level also to stderr
+  stderrthreshold = 2;
+
+  // Set log prefix for each line log
+  log_prefix = true;
+
+  // Log dir
+  log_dir = "/tmp";
+
+  // Log only specific modules.
+  // Example: "membuf=2,rtc=3"
+  vmodule = "";
+
+  // Max log size in MB
+  max_log_size = 10;
+
+  // Log rotation
+  stop_logging_if_full_disk = true;
+};
+```
+
+
+## Security
+
+hICN has built-in authentication and integrity features by either:
+* Cryptographically signing all packets using an asymmetric key (like RSA) or a
+  symmetric one (like HMAC). The latter requires that all parties have prior
+  access to the same key. Beware that this method is computationally expensive
+  and impacts max throughput and CPU usage.
+* Using manifests. Manifests are special packets that holds the digests of a
+  group of data packets. Only the manifest needs to be signed and authenticated;
+  other packets are authenticated simply by verifying that their digest is
+  present in a manifest.
+
+### Per-packet signatures
+
+To enable per-packet signature with asymmetric signing:
+* On the producer, disable manifests (which are ON by default):
+  ```cpp
+  producer_socket->setSocketOption(GeneralTransportOptions::MAKE_MANIFEST, 0);
+  ```
+* On the producer, instantiate an `AsymmetricSigner` object by passing either an
+  asymmetric pair of keys as
+  [EVP_KEY](https://www.openssl.org/docs/man3.0/man3/EVP_PKEY_new.html) object
+  or a keystore path and password as strings:
+  ```cpp
+  std::shared_ptr<Signer> signer = std::make_shared<AsymmetricSigner>("./rsa.p12", "hunter2");
+  ```
+* Pass the signer object to libtransport:
+  ```cpp
+  producer_socket->setSocketOption(GeneralTransportOptions::SIGNER, signer);
+  ```
+* On the consumer, instantiate an `AsymmetricVerifer` object by passing either a
+  certificate as a [X509](https://www.openssl.org/docs/man1.0.2/man3/x509.html)
+  object, an asymmetric public key as a
+  [EVP_KEY](https://www.openssl.org/docs/man3.0/man3/EVP_PKEY_new.html) object
+  or a certificate path as a string:
+  ```cpp
+  std::shared_ptr<Verifier> verifier = std::make_shared<Verifier>("./rsa.crt");
+  ```
+* Pass the verifier object to libtransport:
+  ```cpp
+  consumer_socket->setSocketOption(GeneralTransportOptions::VERIFIER, verifier);
+  ```
+
+To enable per-packet signature with symmetric signing, follow the above steps
+replacing `AsymmetricSigner` with `SymmetricSigner` and `AsymmetricVerifer` with
+`SymmetricSigner`. A `SymmetricSigner` only has one constructor which expects a
+`CryptoSuite` and a passphrase. A `SymmetricVerifier` also has a single
+constructor which expects a passphrase:
+```cpp
+std::shared_ptr<Signer> signer = std::make_shared<SymmetricSigner>(CryptoSuite::HMAC_SHA256, "hunter2");
+std::shared_ptr<Verifier> verifier = std::make_shared<SymmetricVerifier>("hunter2");
+```
+
+Check [Supported crypto suites](#supported-crypto-suites) for the list of
+available suites.
+
+### Enabling manifests
+
+* Follow steps 2-5 in [Per-packet signatures](#per-packet-signatures).
+* By default, a manifest holds the digest of 30 packets. To change this value:
+  ```cpp
+  producer_socket->setSocketOption(GeneralTransportOptions::MAKE_MANIFEST, 20);
+  ```
+
+In the case of RTC, manifests are sent after the data they contain and on the
+consumer side, data packets are immediately forwarded to the application, *even
+if they weren't authenticated yet via a manifest*. This is to minimize latency.
+The digest of incoming data packets are kept in a buffer while waiting for
+manifests to arrive. When that buffer goes above a threshold `T`, an alert is
+raised by the verifier object. That threshold is computed as follows:
+```
+T(t) = producer_rate(t) * max_unverified_time
+```
+
+`max_unverified_time` is a consumer socket option, in milliseconds. It is set
+to `2000` by default. To change it:
+```cpp
+consumer_socket_->setSocketOption(GeneralTransportOptions::MAX_UNVERIFIED_TIME, 4000);
+```
+
+### Handling authentication failures
+
+When a data packet fails authentication, or when the unverified buffer is full
+in the case of RTC, an alert is triggered by the verifier object. By default
+libtransport aborts the connection upon reception of that alert. You may want to
+intercept authentication failures in your application:
+* Define a callback with arguments an `uint32_t` integer, which will be set to
+  the suffix of the faulty packet, and a `auth::VerificationPolicy`, which will
+  be set to the action suggested by the verifier object. The callback must
+  return another `auth::VerificationPolicy` which will be the actual action
+  taken by libtransport:
+  ```cpp
+  auth::VerificationPolicy onAuthFailed(uint32_t suffix, auth::VerificationPolicy policy) {
+    std::cout << "auth failed for packet " << suffix << std::endl;
+    return auth::VerificationPolicy::ACCEPT;
+  }
+  ```
+* Give that callback to your `Verifier` object as well as a list of
+   `auth::VerificationPolicy` to intercept (if left empty, will be set by
+   default to `{ABORT, DROP}`):
+  ```cpp
+  verifier->setVerificationFailedCallback(&onAuthFailed, {
+    auth::VerificationPolicy::ABORT,
+    auth::VerificationPolicy::DROP,
+    auth::VerificationPolicy::UNKNOWN,
+  });
+  ```
+
+### Supported crypto suites
+
+The following `CryptoSuite` are supported by libtransport:
+```
+ECDSA_BLAKE2B512
+ECDSA_BLAKE2S256
+ECDSA_SHA256
+ECDSA_SHA512
+RSA_BLAKE2B512
+RSA_BLAKE2S256
+RSA_SHA256
+RSA_SHA512
+HMAC_BLAKE2B512
+HMAC_BLAKE2S256
+HMAC_SHA256
+HMAC_SHA512
+DSA_BLAKE2B512
+DSA_BLAKE2S256
+DSA_SHA256
+DSA_SHA512
+```
+
+
+## Logging
+
+Internally libtransport uses glog as logging library. If you want to have a more
+verbose transport log when launching a test or an app, you can set environment
+variables in this way:
+
+```
+GLOG_v=4 hiperf -S b001::/64
+```
+
+For a more exhaustive list of options, please check the instructions in the glog
+[README](https://github.com/google/glog#setting-flags).
+
+Useful options include enabling logging *per module*. Also you can compile out
+useless messages in release builds.
diff --git a/docs/source/utils.md b/docs/source/utils.md
index 79ada8985..d6044821a 100644
--- a/docs/source/utils.md
+++ b/docs/source/utils.md
@@ -19,7 +19,6 @@ Basic dependencies:
 - OpenSSL
 - pthreads
 - libevent
-- libparc
 - libhicntransport
 
 ## Executables
@@ -92,45 +91,59 @@ The command `hiperf` is a tool for performing network throughput measurements
 with hicn. It can be executed as server or client using the following options:
 
 ```bash
+HIPERF - Instrumentation tool for performing active networkmeasurements with hICN
 usage: hiperf [-S|-C] [options] [prefix|name]
 
 SERVER OR CLIENT:
--D                           = Run as a daemon
--R                           = Run RTC protocol (client or server)
--f <filename>                = Log file
+-D                                      Run as a daemon
+-R                                      Run RTC protocol (client or server)
+-f      <filename>                      Log file
+-z      <io_module>                     IO module to use. Default: hicnlightng_module
+-F      <conf_file>                     Path to optional configuration file for libtransport
+-a                                      Enables data packet aggregation. Works only in RTC mode
+-X      <param>                         Set FEC params. Options are Rely_K#_N# or RS_K#_N#
 
 SERVER SPECIFIC:
--A <content_size>            = Size of the content to publish. This is not the size of the packet (see -s for it).
--s <packet_size>             = Size of the payload of each data packet.
--r                           = Produce real content of <content_size> bytes
--m                           = Produce transport manifest
--l                           = Start producing content upon the reception of the first interest
--K <keystore_path>           = Path of p12 file containing the crypto material used for signing packets
--k <passphrase>              = String from which a 128-bit symmetric key will be derived for signing packets
--y <hash_algorithm>          = Use the selected hash algorithm for calculating manifest digests
--p <password>                = Password for p12 keystore
--x                           = Produce a content of <content_size>, then after downloading it produce a new content of <content_size> without resetting the suffix to 0.
--B <bitrate>                 = Bitrate for RTC producer, to be used with the -R option.
--I                           = Interactive mode, start/stop real time content production by pressing return. To be used with the -R option
--E                           = Enable encrypted communication. Requires the path to a p12 file containing the crypto material used for the TLS handshake
+-A      <content_size>                  Sends an application data unit in bytes that is published once before exit
+-s      <packet_size>                   Data packet payload size.
+-r                                      Produce real content of <content_size> bytes
+-m      <manifest_capacity>             Produce transport manifest
+-l                                      Start producing content upon the reception of the first interest
+-K      <keystore_path>                 Path of p12 file containing the crypto material used for signing packets
+-k      <passphrase>                    String from which a 128-bit symmetric key will be derived for signing packets
+-p      <password>                      Password for p12 keystore
+-y      <hash_algorithm>                Use the selected hash algorithm for computing manifest digests (default: SHA256)
+-x                                      Produces application data units of size <content_size> without resetting the name suffix to 0.
+-B      <bitrate>                       RTC producer data bitrate, to be used with the -R option.
+-I                                      Interactive mode, start/stop real time content production by pressing return. To be used with the -R option
+-T      <filename>                      Trace based mode, hiperf takes as input a file with a trace. Each line of the file indicates the timestamp and the size of the packet to generate. To be used with the -R option. -B and -I will be ignored.
+-E                                      Enable encrypted communication. Requires the path to a p12 file containing the crypto material used for the TLS handshake
+-G      <port>                          Input stream from localhost at the specified port
 
 CLIENT SPECIFIC:
--b <beta_parameter>          = RAAQM beta parameter
--d <drop_factor_parameter>   = RAAQM drop factor parameter
--L <interest lifetime>       = Set interest lifetime.
--M <Download for real>       = Store the content downloaded.
--W <window_size>             = Use a fixed congestion window for retrieving the data.
--i <stats_interval>          = Show the statistics every <stats_interval> milliseconds.
--v                           = Enable verification of received data
--c <certificate_path>        = Path of the producer certificate to be used for verifying the origin of the packets received. Must be used with -v.
--k <passphrase>              = String from which is derived the symmetric key used by the producer to sign packets and by the consumer to verify them. Must be used with -v.
--t                           = Test mode, check if the client is receiving the correct data. This is an RTC specific option, to be used with the -R (default false)
--P                           = Prefix of the producer where to do the handshake
+-b      <beta_parameter>                RAAQM beta parameter
+-d      <drop_factor_parameter>         RAAQM drop factor parameter
+-L      <interest lifetime>             Set interest lifetime.
+-u      <delay>                         Set max lifetime of unverified packets.
+-M      <input_buffer_size>             Size of consumer input buffer. If 0, reassembly of packets will be disabled.
+-W      <window_size>                   Use a fixed congestion window for retrieving the data.
+-i      <stats_interval>                Show the statistics every <stats_interval> milliseconds.
+-c      <certificate_path>              Path of the producer certificate to be used for verifying the origin of the packets received.
+-k      <passphrase>                    String from which is derived the symmetric key used by the producer to sign packets and by the consumer to verify them.
+-t                                      Test mode, check if the client is receiving the correct data. This is an RTC specific option, to be used with the -R (default: false)
+-P                                      Prefix of the producer where to do the handshake
+-j      <relay_name>                    Publish received content under the name relay_name.This is an RTC specific option, to be used with the -R (default: false)
+-g      <port>                          Output stream to localhost at the specified port
+-e      <strategy>                      Enance the network with a realiability strategy. Options 1: unreliable, 2: rtx only, 3: fec only, 4: delay based, 5: low rate, 6: low rate and best path 7: low rate and replication, 8: low rate and best path/replication(default: 2 = rtx only)
+-H                                      Disable periodic print headers in stats report.
+-n      <nb_iterations>                 Print the stats report <nb_iterations> times and exit.
+                                        This option limits the duration of the run to <nb_iterations> * <stats_interval> milliseconds.
 ```
 
 Example:
 ```
-hiperf -S c001::/64
+hiperf -S b001::/64
+hiperf -C b001::
 ```
 
 ## Client/Server benchmarking using `hiperf`
@@ -161,8 +174,7 @@ apt-get install -y git \
                    build-essential \
                    libasio-dev \
                    libcurl4-openssl-dev \
-                   --no-install-recommends \
-                   libparc-dev
+                   --no-install-recommends
 mkdir hicn-suite && cd hicn-suite
 git clone https://github.com/FDio/hicn.git hicn-src
 mkdir hicn-build && cd hicn-build
@@ -289,8 +301,7 @@ apt-get install -y git \
                    vpp vpp-dev vpp-plugin-core libvppinfra \
                    libmemif libmemif-dev \
                    python3-ply \
-                   --no-install-recommends \
-                   libparc-dev
+                   --no-install-recommends
 mkdir hicn-suite && cd hicn-suite
 git clone https://github.com/FDio/hicn.git hicn-src
 mkdir hicn-build && cd hicn-build
diff --git a/docs/source/vpp-plugin.md b/docs/source/vpp-plugin.md
index 7f49cd8b9..b6b469494 100644
--- a/docs/source/vpp-plugin.md
+++ b/docs/source/vpp-plugin.md
@@ -22,7 +22,7 @@ mkdir -p build
 cd build
 cmake .. -DCMAKE_INSTALL_PREFIX=/usr
 make
-sudo make install
+sudo cmake --build . -- install
 ```
 
 VPP source code - build type `RELEASE`:
@@ -32,7 +32,7 @@ mkdir -p build
 cd build
 cmake .. -DVPP_HOME=<vpp dir>/build-root/install-vpp-native/vpp -DCMAKE_INSTALL_PREFIX=<vpp src>/build-root/install-vpp-native/vpp
 make
-sudo make install
+cmake --build . -- install
 ```
 
 VPP source code - build type `DEBUG`:
@@ -42,7 +42,7 @@ mkdir -p build
 cd build
 cmake .. -DCMAKE_BUILD_TYPE=DEBUG -DVPP_HOME=<vpp dir>/build-root/install-vpp_debug-native/vpp -DCMAKE_INSTALL_PREFIX=<vpp src>/build-root/install-vpp_debug-native/vpp
 make
-sudo make install
+cmake --build . -- install
 ```
 
 CMAKE variables:
@@ -57,7 +57,7 @@ CMAKE variables:
 
 Build dependencies:
 
-- VPP 20.01
+- VPP 22.02
   - DEB packages (can be found <https://packagecloud.io/fdio/release/install):>
     - vpp
     - libvppinfra-dev
@@ -65,11 +65,11 @@ Build dependencies:
 
 Runtime dependencies:
 
-- VPP 20.01
+- VPP 22.02
   - DEB packages (can be found <https://packagecloud.io/fdio/release/install):>
     - vpp
     - vpp-plugin-core
-    - vpp-plugin-dpdk (only to use DPDK compatible nics)
+    - vpp-plugin-dpdk (optional - only to use DPDK compatible nics)
 
 Hardware support (not mandatory):
 
@@ -91,7 +91,7 @@ Detailed information for configuring VPP can be found at
 
 ### Setup the host for VPP
 
-Hugepages must be enabled in the system.
+It is preferable to have hugepages enabled in the system, although it is not a requirement:
 
 ```bash
 sudo sysctl -w vm.nr_hugepages=1024
@@ -163,7 +163,7 @@ interface.
 
 VPP can be started as a process or a service:
 
-Start VPP as a service in Ubuntu 16.04+:
+Start VPP as a service in Ubuntu 20.04+:
 ```bash
 sudo systemctl start vpp
 ```
@@ -299,22 +299,22 @@ vpp# set interface ip address TenGigabitEtherneta/0/1 2001::3/64
 vpp# set interface state TenGigabitEtherneta/0/1 up
 ```
 
-Once the two forwarder are started, run the `ping_server` application on the
+Once the two forwarder are started, run the `hicn-ping-server` application on the
 host where the forwarder B is running:
 
 ```bash
-sudo ping_server -n b002::1
+sudo hicn-ping-server -n b002::1/128 -z memif_module
 ```
 
-Then `ping_client` on the host where forwarder B is running:
+Then `hicn-ping-client` on the host where forwarder B is running:
 
 ```bash
-sudo ping_client -n b002::1
+sudo hicn-ping-client -n b002::1 -z memif_module
 ```
 
 ### Example: packet generator
 
-The packet generator can be used to test the performace of the hICN plugin, as
+The packet generator can be used to test the performance of the hICN plugin, as
 well as a tool to inject packet in a forwarder or network for other test use
 cases It is made of two entities, a client that inject interest into a vpp
 forwarder and a server that replies to any interest with the corresponding
diff --git a/extras/CMakeLists.txt b/extras/CMakeLists.txt
index 4cda43992..1683902db 100644
--- a/extras/CMakeLists.txt
+++ b/extras/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -17,6 +17,7 @@ list(APPEND CMAKE_MODULE_PATH
   ${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Modules
 )
 
+include("${CMAKE_CURRENT_SOURCE_DIR}/../versions.cmake")
 set (DESTDIR ${CMAKE_BINARY_DIR}/extras-root)
 
 # add_subdirectory(router-plugin)
diff --git a/extras/libmemif/CMakeLists.txt b/extras/libmemif/CMakeLists.txt
deleted file mode 100644
index dab69c56f..000000000
--- a/extras/libmemif/CMakeLists.txt
+++ /dev/null
@@ -1,43 +0,0 @@
-# Copyright (c) 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.
-
-cmake_minimum_required(VERSION 3.10)
-project(libmemif)
-
-list(APPEND MODULE_PATH
-  ${CMAKE_MODULE_PATH}
-  ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules
-)
-
-string(REPLACE ";" "|" MODULE_PATH "${MODULE_PATH}")
-
-include(ExternalProject)
-
-ExternalProject_Add(libmemif
-  GIT_REPOSITORY https://github.com/FDio/vpp.git
-  GIT_TAG v21.06
-  GIT_SHALLOW TRUE
-  PREFIX ${CMAKE_CURRENT_BINARY_DIR}/libmemif
-  PATCH_COMMAND bash -c "cp ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists1.patch ./extras/libmemif/CMakeLists.txt && cp ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists2.patch ./extras/libmemif/src/CMakeLists.txt"
-  # Use the alternate list separator
-  # (https://cmake.org/cmake/help/latest/manual/cmake-language.7.html#lists)
-  LIST_SEPARATOR |
-  CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_MODULE_PATH=${MODULE_PATH}
-  SOURCE_SUBDIR ./extras/libmemif
-  BUILD_COMMAND ${CMAKE_COMMAND} --build . -- package
-)
-
-if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-    include(Packager)
-    make_packages()
-endif()
diff --git a/extras/libmemif/CMakeLists1.patch b/extras/libmemif/CMakeLists1.patch
deleted file mode 100644
index adf41a417..000000000
--- a/extras/libmemif/CMakeLists1.patch
+++ /dev/null
@@ -1,75 +0,0 @@
-# Copyright (c) 2017 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.
-
-cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
-
-project(memif)
-set(CMAKE_C_STANDARD 11)
-
-list(APPEND CMAKE_MODULE_PATH
-  ${CMAKE_CURRENT_SOURCE_DIR}/cmake
-)
-
-include(CheckCCompilerFlag)
-include(CheckFunctionExists)
-
-execute_process(
-  COMMAND find ${VPP_SRC} -type d -name "cmake"
-  OUTPUT_VARIABLE CMAKE_DEPS_FOLDER
-  OUTPUT_STRIP_TRAILING_WHITESPACE
-)
-include(BuildMacros)
-
-if (NOT CMAKE_BUILD_TYPE)
-  message(STATUS "${PROJECT_NAME}: No build type selected, default to Release")
-  set(CMAKE_BUILD_TYPE "Release")
-endif ()
-
-set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g -DMEMIF_DBG -DICMP_DBG")
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
-set(CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/lib)
-set(CMAKE_INSTALL_MESSAGE NEVER)
-
-find_package(Threads REQUIRED)
-include_directories(${CMAKE_THREADS_INCLUDE_DIRS})
-
-check_function_exists(memfd_create HAVE_MEMFD_CREATE)
-if(${HAVE_MEMFD_CREATE})
-  add_definitions(-DHAVE_MEMFD_CREATE)
-endif()
-
-include_directories(src)
-set(LIBMEMIF memif)
-set(COMPONENT libmemif)
-set(LIBMEMIF_SHARED ${LIBMEMIF}.shared)
-
-set(LIBMEMIF_INCLUDE_DIRS
-  ${CMAKE_CURRENT_SOURCE_DIR}
-  "" CACHE INTERNAL
-  "" FORCE
-)
-
-set(LIBMEMIF_LIBRARIES
-  ${LIBMEMIF_SHARED}
-  "" CACHE INTERNAL
-  "" FORCE
-)
-
-include (Packaging)
-
-add_subdirectory(src)
-
-if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-  include(Packager)
-  make_packages()
-endif()
\ No newline at end of file
diff --git a/extras/libmemif/CMakeLists2.patch b/extras/libmemif/CMakeLists2.patch
deleted file mode 100644
index 1a02cd725..000000000
--- a/extras/libmemif/CMakeLists2.patch
+++ /dev/null
@@ -1,44 +0,0 @@
-# Copyright (c) 2017 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.
-
-cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
-
-set(HEADERS_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-
-list(APPEND MEMIF_HEADERS
-  libmemif.h
-  memif.h
-)
-
-list(APPEND MEMIF_PRIVATE_HEADERS
-  memif_private.h
-  socket.h
-)
-
-list(APPEND MEMIF_SOURCES
-  main.c
-  socket.c
-)
-
-include_directories(${HEADERS_DIR})
-
-build_library(${LIBMEMIF}
-  SHARED
-  SOURCES ${MEMIF_SOURCES}
-  INSTALL_HEADERS ${MEMIF_HEADERS}
-  LINK_LIBRARIES ${CMAKE_THREAD_LIBS_INIT}
-  HEADER_ROOT_DIR memif
-  COMPONENT ${COMPONENT}
-)
-
-remove_flag_from_target(${LIBMEMIF_SHARED} -Werror)
\ No newline at end of file
diff --git a/extras/libmemif/cmake/Modules/Packaging.cmake b/extras/libmemif/cmake/Modules/Packaging.cmake
deleted file mode 100644
index 2b0f54200..000000000
--- a/extras/libmemif/cmake/Modules/Packaging.cmake
+++ /dev/null
@@ -1,44 +0,0 @@
-# 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.
-
-######################
-# Packages section
-######################
-
-set(${COMPONENT}_DESCRIPTION
-  "Libmemif, shared memory interface"
-  CACHE STRING "Description for deb/rpm package."
-)
-
-set(${COMPONENT}_DEB_DEPENDENCIES
-  "" CACHE STRING "Dependencies for deb/rpm package."
-)
-
-set(${COMPONENT}_RPM_DEPENDENCIES
-  "" CACHE STRING "Dependencies for deb/rpm package."
-)
-
-set(${COMPONENT}-dev_DESCRIPTION
-  "Libmemif, shared memory interface header files"
-  CACHE STRING "Description for deb/rpm package."
-)
-
-set(${COMPONENT}-dev_DEB_DEPENDENCIES
-  "${COMPONENT} (>= stable_version)"
-  CACHE STRING "Dependencies for deb/rpm package."
-)
-
-set(${COMPONENT}-dev_RPM_DEPENDENCIES
-  "${COMPONENT} >= stable_version"
-  CACHE STRING "Dependencies for deb/rpm package."
-)
diff --git a/extras/libyang/CMakeLists.txt b/extras/libyang/CMakeLists.txt
index 1956d185a..3dec9c5fb 100644
--- a/extras/libyang/CMakeLists.txt
+++ b/extras/libyang/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/extras/libyang/cmake/Modules/Packaging.cmake b/extras/libyang/cmake/Modules/Packaging.cmake
index 853b18e58..9a7738196 100644
--- a/extras/libyang/cmake/Modules/Packaging.cmake
+++ b/extras/libyang/cmake/Modules/Packaging.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/extras/packethicn/CMakeLists.txt b/extras/packethicn/CMakeLists.txt
index cb168ae1f..a4615708a 100644
--- a/extras/packethicn/CMakeLists.txt
+++ b/extras/packethicn/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,19 +11,39 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-cmake_minimum_required(VERSION 3.5)
+##############################################################
+# Project and cmake version
+##############################################################
+cmake_minimum_required(VERSION 3.10)
 cmake_policy(SET CMP0048 NEW)
-
 project(packethicn VERSION 0.0.1 DESCRIPTION "hICN protocol plugin" LANGUAGES C)
 
+
+##############################################################
+# Cmake modules
+##############################################################
 set(CMAKE_MODULE_PATH
   ${CMAKE_MODULE_PATH}
   ${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/Modules
-  ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules
 )
 
+
+##############################################################
+# Naming
+##############################################################
 set(PACKETHICN packethicn)
 
+
+##############################################################
+# Packaging and versioning
+##############################################################
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../versions.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/packaging.cmake)
+
+
+##############################################################
+# Dependencies and third party libs
+##############################################################
 if(APPLE)
   find_package(Wireshark CONFIG REQUIRED
     PATHS /usr/local/opt/wireshark/lib/wireshark/cmake/ /usr/local/Cellar/wireshark/*/lib/wireshark/cmake
@@ -35,8 +55,21 @@ endif()
 MATH(EXPR Wireshark_PATCH_NEXT_VERSION "${Wireshark_PATCH_VERSION}+1")
 set(Wireshark_NEXT_VERSION ${Wireshark_MAJOR_VERSION}.${Wireshark_MINOR_VERSION}.${Wireshark_PATCH_NEXT_VERSION})
 
+
+##############################################################
+# Check if building as subproject or as root project
+##############################################################
 if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-  find_package(Libhicn REQUIRED)
+  include(CommonSetup)
+  find_package(Libhicn ${CURRENT_VERSION} REQUIRED NO_MODULE)
+
+  if (DISABLE_SHARED_LIBRARIES)
+    set(LIBTYPE static)
+  else()
+    set(LIBTYPE shared)
+  endif()
+
+  list(APPEND HICN_LIBRARIES hicn::hicn.${LIBTYPE})
 else()
   if(DISABLE_SHARED_LIBRARIES)
     if(WIN32)
@@ -55,39 +88,56 @@ else()
   endif()
 endif()
 
+
+##############################################################
+# Check if wiresharks supports plugins
+##############################################################
 if(NOT Wireshark_PLUGINS_ENABLED)
   message(FATAL_ERROR "Wireshark was compiled without support for plugins")
 endif()
 
+
+##############################################################
+# Compilaer flags
+##############################################################
 set(CMAKE_C_VISIBILITY_PRESET hidden)
-if (CMAKE_COMPILER_IS_GNUCC)
-  set(CMAKE_C_FLAGS  "-Wall -Wextra ${CMAKE_C_FLAGS}")
-endif()
 
+
+##############################################################
+# Compiler definitions
+##############################################################
 set(COMPILER_DEFINITIONS -DVERSION=\"${PROJECT_VERSION}\")
 
+
+##############################################################
+# Sources
+##############################################################
 set(SOURCE_FILES
   packet-hicn.c
 )
 
+
+##############################################################
+# Include dirs
+##############################################################
 list(APPEND PACKETHICN_INCLUDE_DIRS
   ${HICN_INCLUDE_DIRS}
 )
 
+
+##############################################################
+# Libraries
+##############################################################
 list(APPEND LIBRARIES
   ${HICN_LIBRARIES}
   epan
 )
 
-if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-    set(LIBHICN hicn CACHE INTERNAL "" FORCE)
-endif()
-
-include(Packaging)
-include(BuildMacros)
 
+##############################################################
+# Build library
+##############################################################
 build_library(${PACKETHICN}
-  MODULE
   SOURCES ${SOURCE_FILES}
   LINK_LIBRARIES ${LIBRARIES}
   DEPENDS ${DEPENDENCIES}
@@ -95,10 +145,12 @@ build_library(${PACKETHICN}
   INCLUDE_DIRS ${PACKETHICN_INCLUDE_DIRS}
   INSTALL_FULL_PATH_DIR ${Wireshark_PLUGIN_INSTALL_DIR}/epan
   DEFINITIONS ${COMPILER_DEFINITIONS}
-  EMPTY_PREFIX true
 )
 
+
+##############################################################
+# Make package if needed
+##############################################################
 if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-    include(Packager)
     make_packages()
 endif()
\ No newline at end of file
diff --git a/extras/packethicn/cmake/Modules/Packaging.cmake b/extras/packethicn/cmake/packaging.cmake
index 5bea05c3c..b7a7f4552 100644
--- a/extras/packethicn/cmake/Modules/Packaging.cmake
+++ b/extras/packethicn/cmake/packaging.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -21,11 +21,11 @@ set(${PACKETHICN}_DESCRIPTION
 )
 
 set(${PACKETHICN}_DEB_DEPENDENCIES
-  "lib${LIBHICN} (>= stable_version), wireshark (>= ${Wireshark_VERSION}), wireshark (<< ${Wireshark_NEXT_VERSION})"
+  "lib${LIBHICN} (= stable_version), wireshark (>= ${Wireshark_VERSION}), wireshark (<< ${Wireshark_NEXT_VERSION})"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(${PACKETHICN}_RPM_DEPENDENCIES
-  "lib${LIBHICN} >= stable_version, wireshark >= ${Wireshark_VERSION}, wireshark < ${Wireshark_NEXT_VERSION}"
+  "lib${LIBHICN} = stable_version, wireshark >= ${Wireshark_VERSION}, wireshark < ${Wireshark_NEXT_VERSION}"
   CACHE STRING "Dependencies for deb/rpm package."
 )
\ No newline at end of file
diff --git a/extras/packethicn/packet-hicn.c b/extras/packethicn/packet-hicn.c
index c17252bb7..87466fdbf 100644
--- a/extras/packethicn/packet-hicn.c
+++ b/extras/packethicn/packet-hicn.c
@@ -17,11 +17,11 @@
 #include <gmodule.h>
 
 #define WS_BUILD_DLL
-#include "ws_symbol_export.h"
 #include "config.h"
+#include "ws_symbol_export.h"
 
-#include "epan/proto.h"
 #include "epan/etypes.h"
+#include "epan/proto.h"
 
 #include <hicn/hicn.h>
 
@@ -36,14 +36,14 @@
 /* TCP-HICN flags */
 #define FLAGS_BITS_LEN 8
 #define FLAGS_MASK 0xFF
-#define TH_FIN  0x01
-#define TH_SYN  0x02
-#define TH_RST  0x04
-#define TH_ACK  0x10
-#define TH_CWR  0x80
-#define TH_ID   0x40
-#define TH_MAN  0x20
-#define TH_SIG  0x08
+#define TH_FIN 0x01
+#define TH_SYN 0x02
+#define TH_RST 0x04
+#define TH_ACK 0x10
+#define TH_CWR 0x80
+#define TH_ID 0x40
+#define TH_MAN 0x20
+#define TH_SIG 0x08
 
 #define HICN_PORT 9695
 
@@ -84,7 +84,6 @@ static gint ett_hicn_l3 = -1;
 static gint ett_hicn_l4 = -1;
 static gint ett_hicn_l4_flags = -1;
 
-
 static uint8_t *_p_hdr = NULL;
 
 bool is_interest(const hicn_header_t *header) {
@@ -97,39 +96,38 @@ bool is_interest(const hicn_header_t *header) {
 
 // TODO: HANDLE ERRORS
 
-hicn_header_t *get_header(tvbuff_t *tvb, const gint offset, const gint length){
+hicn_header_t *get_header(tvbuff_t *tvb, const gint offset, const gint length) {
   tvb_ensure_bytes_exist(tvb, offset, length);
-  hicn_header_t *pkt_hdr = (hicn_header_t *) tvb_get_ptr(tvb, offset, length);
-  _p_hdr = (uint8_t *) pkt_hdr;
+  hicn_header_t *pkt_hdr = (hicn_header_t *)tvb_get_ptr(tvb, offset, length);
+  _p_hdr = (uint8_t *)pkt_hdr;
   return pkt_hdr;
 }
 
-uint32_t get_offset(uint8_t *data_addr){
-  return data_addr - _p_hdr;
-}
+uint32_t get_offset(uint8_t *data_addr) { return data_addr - _p_hdr; }
 
-static int
-dissect_hicn(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
-{
+static int dissect_hicn(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+                        void *data _U_) {
   gint i = 0;
   guint bpos;
 
   hicn_header_t *pkt_hdr = get_header(tvb, 0, HICN_V6_TCP_HDRLEN);
 
   wmem_strbuf_t *flags_strbuf = wmem_strbuf_new_label(wmem_packet_scope());
-  static const gchar *flags[] = {"_FIN", "_SYN", "_RST", "SIG", "_ACK", "MAN", "ID", "_CWR"};
+  static const gchar *flags[] = {"_FIN", "_SYN", "_RST", "SIG",
+                                 "_ACK", "MAN",  "ID",   "_CWR"};
   wmem_strbuf_append(flags_strbuf, "<None>");
 
-  uint32_t flags_offset = get_offset((uint8_t *) &(pkt_hdr->v6.tcp.flags));
+  uint32_t flags_offset = get_offset((uint8_t *)&(pkt_hdr->v6.tcp.flags));
 
   gboolean first_flag = TRUE;
-  for(i=0; i<9; i++) {
+  for (i = 0; i < 9; i++) {
     bpos = 1 << i;
-    if(pkt_hdr->v6.tcp.flags & bpos) {
-      if(first_flag) {
+    if (pkt_hdr->v6.tcp.flags & bpos) {
+      if (first_flag) {
         wmem_strbuf_truncate(flags_strbuf, 0);
       }
-      wmem_strbuf_append_printf(flags_strbuf, "%s%s", first_flag ? "" : ", ", flags[i]);
+      wmem_strbuf_append_printf(flags_strbuf, "%s%s", first_flag ? "" : ", ",
+                                flags[i]);
       first_flag = FALSE;
     }
   }
@@ -138,99 +136,176 @@ dissect_hicn(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_
   col_set_str(pinfo->cinfo, COL_PROTOCOL, "HICN");
   col_clear(pinfo->cinfo, COL_INFO);
 
-  proto_item *ti = proto_tree_add_item(tree, proto_hicn, tvb, 0, HICN_V6_TCP_HDRLEN, ENC_NA);
+  proto_item *ti =
+      proto_tree_add_item(tree, proto_hicn, tvb, 0, HICN_V6_TCP_HDRLEN, ENC_NA);
   proto_tree *hicn_tree = proto_item_add_subtree(ti, ett_hicn);
 
   // L3
   proto_item *ti_l3;
-  proto_tree *hicn_l3_tree = proto_tree_add_subtree(hicn_tree, tvb, 0, IPV6_HDRLEN, ett_hicn_l3, &ti_l3, "HICN Layer 3");
+  proto_tree *hicn_l3_tree = proto_tree_add_subtree(
+      hicn_tree, tvb, 0, IPV6_HDRLEN, ett_hicn_l3, &ti_l3, "HICN Layer 3");
 
-  if(is_interest(pkt_hdr)){
+  if (is_interest(pkt_hdr)) {
     proto_item_append_text(ti, ", Interest Packet");
     col_set_str(pinfo->cinfo, COL_INFO, "Interest Packet");
-    proto_tree_add_item(hicn_l3_tree, hf_hicn_ipv6_src, tvb, get_offset((uint8_t *) &(pkt_hdr->v6.ip.saddr)), sizeof(pkt_hdr->v6.ip.saddr), ENC_BIG_ENDIAN);
-    proto_tree_add_item(hicn_l3_tree, hf_hicn_ipv6_dst_interest, tvb, get_offset((uint8_t *) &(pkt_hdr->v6.ip.daddr)), sizeof(pkt_hdr->v6.ip.daddr), ENC_BIG_ENDIAN);
+    proto_tree_add_item(hicn_l3_tree, hf_hicn_ipv6_src, tvb,
+                        get_offset((uint8_t *)&(pkt_hdr->v6.ip.saddr)),
+                        sizeof(pkt_hdr->v6.ip.saddr), ENC_BIG_ENDIAN);
+    proto_tree_add_item(hicn_l3_tree, hf_hicn_ipv6_dst_interest, tvb,
+                        get_offset((uint8_t *)&(pkt_hdr->v6.ip.daddr)),
+                        sizeof(pkt_hdr->v6.ip.daddr), ENC_BIG_ENDIAN);
   } else {
     // TODO: NEW LABEL FOR NACKS
     proto_item_append_text(ti, ", Data Packet");
     col_set_str(pinfo->cinfo, COL_INFO, "Data Packet");
-    proto_tree_add_item(hicn_l3_tree, hf_hicn_ipv6_src_data, tvb, get_offset((uint8_t *) &(pkt_hdr->v6.ip.saddr)), sizeof(pkt_hdr->v6.ip.saddr), ENC_BIG_ENDIAN);
-    proto_tree_add_item(hicn_l3_tree, hf_hicn_ipv6_dst, tvb, get_offset((uint8_t *) &(pkt_hdr->v6.ip.daddr)), sizeof(pkt_hdr->v6.ip.daddr), ENC_BIG_ENDIAN);
+    proto_tree_add_item(hicn_l3_tree, hf_hicn_ipv6_src_data, tvb,
+                        get_offset((uint8_t *)&(pkt_hdr->v6.ip.saddr)),
+                        sizeof(pkt_hdr->v6.ip.saddr), ENC_BIG_ENDIAN);
+    proto_tree_add_item(hicn_l3_tree, hf_hicn_ipv6_dst, tvb,
+                        get_offset((uint8_t *)&(pkt_hdr->v6.ip.daddr)),
+                        sizeof(pkt_hdr->v6.ip.daddr), ENC_BIG_ENDIAN);
   }
 
   // L4
   proto_item *ti_l4;
-  proto_tree *hicn_l4_tree = proto_tree_add_subtree(hicn_tree, tvb, IPV6_HDRLEN, TCP_HDRLEN, ett_hicn_l4, &ti_l4, "HICN Layer 4");
-
-  proto_tree_add_item(hicn_l4_tree, hf_hicn_tcp_namesuffix, tvb, get_offset((uint8_t *) &(pkt_hdr->v6.tcp.name_suffix)), sizeof(pkt_hdr->v6.tcp.name_suffix), ENC_BIG_ENDIAN);
-  proto_tree_add_item(hicn_l4_tree, hf_hicn_tcp_pathlabel, tvb, get_offset((uint8_t *) &(pkt_hdr->v6.tcp.pathlabel))+PATHLABEL_PAD_LEN, sizeof(pkt_hdr->v6.tcp.pathlabel), ENC_BIG_ENDIAN);
-  proto_item *ti_l4_ts = proto_tree_add_bits_item(hicn_l4_tree, hf_hicn_tcp_timescale, tvb,
-    get_offset((uint8_t *) &(pkt_hdr->v6.tcp.data_offset_and_reserved))*8 + TIMESCALE_BITS_OFFSET, TIMESCALE_BITS_LENGTH, ENC_BIG_ENDIAN);
-  proto_item_append_text(ti_l4_ts, " (Lifetime scaling factor: %dx)", pkt_hdr->v6.tcp.timescale+1);
-  proto_item *hicn_l4_flags_tree = proto_tree_add_uint_format_value(hicn_l4_tree, hf_hicn_tcp_flags, tvb,
-    get_offset((uint8_t *) &(pkt_hdr->v6.tcp.flags)), 1, pkt_hdr->v6.tcp.flags, "0x%02x (%s)", pkt_hdr->v6.tcp.flags, wmem_strbuf_get_str(flags_strbuf)
-  );
-  proto_tree *field_tree = proto_item_add_subtree(hicn_l4_flags_tree, ett_hicn_l4_flags);
-  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_cwr, tvb, flags_offset, 1, pkt_hdr->v6.tcp.flags);
-  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_id, tvb, flags_offset, 1, pkt_hdr->v6.tcp.flags);
-  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_man, tvb, flags_offset, 1, pkt_hdr->v6.tcp.flags);
-  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_ack, tvb, flags_offset, 1, pkt_hdr->v6.tcp.flags);
-  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_sig, tvb, flags_offset, 1, pkt_hdr->v6.tcp.flags);
-  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_rst, tvb, flags_offset, 1, pkt_hdr->v6.tcp.flags);
-  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_syn, tvb, flags_offset, 1, pkt_hdr->v6.tcp.flags);
-  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_fin, tvb, flags_offset, 1, pkt_hdr->v6.tcp.flags);
-  proto_tree_add_item(hicn_l4_tree, hf_hicn_tcp_ldr, tvb, get_offset((uint8_t *) &(pkt_hdr->v6.tcp.ldr)), sizeof(pkt_hdr->v6.tcp.ldr), ENC_BIG_ENDIAN);
-  proto_tree_add_item(hicn_l4_tree, hf_hicn_tcp_csum, tvb, get_offset((uint8_t *) &(pkt_hdr->v6.tcp.csum)), sizeof(pkt_hdr->v6.tcp.ldr), ENC_BIG_ENDIAN);
-  proto_item *ti_l4_lt = proto_tree_add_item(hicn_l4_tree, hf_hicn_tcp_lifetime, tvb, get_offset((uint8_t *) &(pkt_hdr->v6.tcp.lifetime)), sizeof(pkt_hdr->v6.tcp.ldr), ENC_BIG_ENDIAN);
+  proto_tree *hicn_l4_tree =
+      proto_tree_add_subtree(hicn_tree, tvb, IPV6_HDRLEN, TCP_HDRLEN,
+                             ett_hicn_l4, &ti_l4, "HICN Layer 4");
+
+  proto_tree_add_item(hicn_l4_tree, hf_hicn_tcp_namesuffix, tvb,
+                      get_offset((uint8_t *)&(pkt_hdr->v6.tcp.name_suffix)),
+                      sizeof(pkt_hdr->v6.tcp.name_suffix), ENC_BIG_ENDIAN);
+  proto_tree_add_item(hicn_l4_tree, hf_hicn_tcp_pathlabel, tvb,
+                      get_offset((uint8_t *)&(pkt_hdr->v6.tcp.pathlabel)) +
+                          PATHLABEL_PAD_LEN,
+                      sizeof(pkt_hdr->v6.tcp.pathlabel), ENC_BIG_ENDIAN);
+  proto_item *ti_l4_ts = proto_tree_add_bits_item(
+      hicn_l4_tree, hf_hicn_tcp_timescale, tvb,
+      get_offset((uint8_t *)&(pkt_hdr->v6.tcp.data_offset_and_reserved)) * 8 +
+          TIMESCALE_BITS_OFFSET,
+      TIMESCALE_BITS_LENGTH, ENC_BIG_ENDIAN);
+  proto_item_append_text(ti_l4_ts, " (Lifetime scaling factor: %dx)",
+                         pkt_hdr->v6.tcp.timescale + 1);
+  proto_item *hicn_l4_flags_tree = proto_tree_add_uint_format_value(
+      hicn_l4_tree, hf_hicn_tcp_flags, tvb,
+      get_offset((uint8_t *)&(pkt_hdr->v6.tcp.flags)), 1, pkt_hdr->v6.tcp.flags,
+      "0x%02x (%s)", pkt_hdr->v6.tcp.flags, wmem_strbuf_get_str(flags_strbuf));
+  proto_tree *field_tree =
+      proto_item_add_subtree(hicn_l4_flags_tree, ett_hicn_l4_flags);
+  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_cwr, tvb, flags_offset,
+                         1, pkt_hdr->v6.tcp.flags);
+  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_id, tvb, flags_offset, 1,
+                         pkt_hdr->v6.tcp.flags);
+  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_man, tvb, flags_offset,
+                         1, pkt_hdr->v6.tcp.flags);
+  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_ack, tvb, flags_offset,
+                         1, pkt_hdr->v6.tcp.flags);
+  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_sig, tvb, flags_offset,
+                         1, pkt_hdr->v6.tcp.flags);
+  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_rst, tvb, flags_offset,
+                         1, pkt_hdr->v6.tcp.flags);
+  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_syn, tvb, flags_offset,
+                         1, pkt_hdr->v6.tcp.flags);
+  proto_tree_add_boolean(field_tree, hf_hicn_tcp_flags_fin, tvb, flags_offset,
+                         1, pkt_hdr->v6.tcp.flags);
+  proto_tree_add_item(hicn_l4_tree, hf_hicn_tcp_ldr, tvb,
+                      get_offset((uint8_t *)&(pkt_hdr->v6.tcp.ldr)),
+                      sizeof(pkt_hdr->v6.tcp.ldr), ENC_BIG_ENDIAN);
+  proto_tree_add_item(hicn_l4_tree, hf_hicn_tcp_csum, tvb,
+                      get_offset((uint8_t *)&(pkt_hdr->v6.tcp.csum)),
+                      sizeof(pkt_hdr->v6.tcp.ldr), ENC_BIG_ENDIAN);
+  proto_item *ti_l4_lt =
+      proto_tree_add_item(hicn_l4_tree, hf_hicn_tcp_lifetime, tvb,
+                          get_offset((uint8_t *)&(pkt_hdr->v6.tcp.lifetime)),
+                          sizeof(pkt_hdr->v6.tcp.ldr), ENC_BIG_ENDIAN);
   proto_item_append_text(ti_l4_lt, " milliseconds");
 
   dissector_handle_t data_handle = find_dissector("data");
-  call_dissector(data_handle, tvb_new_subset_remaining(tvb, HICN_V6_TCP_HDRLEN), pinfo, tree);
+  call_dissector(data_handle, tvb_new_subset_remaining(tvb, HICN_V6_TCP_HDRLEN),
+                 pinfo, tree);
   return tvb_captured_length(tvb);
 }
 
-static void
-proto_register_hicn(void)
-{
+static void proto_register_hicn(void) {
   static hf_register_info hf[] = {
-    { &hf_hicn_ipv6_src, { "Source Address", "hicn.l3.src", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }},
-    { &hf_hicn_ipv6_src_data, { "Name Prefix", "hicn.l3.src", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }},
-    { &hf_hicn_ipv6_dst, { "Destination Address", "hicn.l3.dst", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }},
-    { &hf_hicn_ipv6_dst_interest, { "Name Prefix", "hicn.l3.dst", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL }},
-    { &hf_hicn_tcp_namesuffix, { "Name Suffix", "hicn.l4.namesuffix", FT_UINT32, BASE_HEX_DEC , NULL, 0x0, NULL, HFILL }},
-    { &hf_hicn_tcp_pathlabel, { "Path Label", "hicn.l4.pathlabel", FT_UINT8, BASE_HEX_DEC , NULL, 0x0, NULL, HFILL }},
-    { &hf_hicn_tcp_hdrlen_timescale, { "Header length and Timescale", "hicn.l4.hdrlen_ts", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
-    { &hf_hicn_tcp_hdrlen, { "Header length", "hicn.l4.hdrlen", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
-    { &hf_hicn_tcp_timescale, { "Timescale", "hicn.l4.timescale", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
-    { &hf_hicn_tcp_flags, { "Flags", "hicn.l4.flags", FT_UINT8, BASE_HEX, NULL, FLAGS_MASK, NULL, HFILL }},
-    { &hf_hicn_tcp_flags_cwr, { "_CWR", "hicn.l4.flags.cwr", FT_BOOLEAN, FLAGS_BITS_LEN, TFS(&tfs_set_notset), TH_CWR, NULL, HFILL }},
-    { &hf_hicn_tcp_flags_id, { "ID", "hicn.l4.flags.id", FT_BOOLEAN, FLAGS_BITS_LEN, TFS(&tfs_set_notset),TH_ID, NULL, HFILL }},
-    { &hf_hicn_tcp_flags_man, { "MAN", "hicn.l4.flags.man", FT_BOOLEAN, FLAGS_BITS_LEN, TFS(&tfs_set_notset), TH_MAN, NULL, HFILL }},
-    { &hf_hicn_tcp_flags_ack, { "_ACK", "hicn.l4.flags.ack", FT_BOOLEAN, FLAGS_BITS_LEN, TFS(&tfs_set_notset), TH_ACK, NULL, HFILL }},
-    { &hf_hicn_tcp_flags_sig, { "SIG", "hicn.l4.flags.sig", FT_BOOLEAN, FLAGS_BITS_LEN, TFS(&tfs_set_notset), TH_SIG, NULL, HFILL }},
-    { &hf_hicn_tcp_flags_rst, { "_RST", "hicn.l4.flags.reset", FT_BOOLEAN, FLAGS_BITS_LEN, TFS(&tfs_set_notset), TH_RST, NULL, HFILL }},
-    { &hf_hicn_tcp_flags_syn, { "_SYN", "hicn.l4.flags.syn", FT_BOOLEAN, FLAGS_BITS_LEN, TFS(&tfs_set_notset), TH_SYN, NULL, HFILL }},
-    { &hf_hicn_tcp_flags_fin, { "_FIN", "hicn.l4.flags.fin", FT_BOOLEAN, FLAGS_BITS_LEN, TFS(&tfs_set_notset), TH_FIN, NULL, HFILL }},
-    { &hf_hicn_tcp_ldr, { "Loss Detection and Recovery", "hicn.l4.ldr", FT_UINT16, BASE_HEX , NULL, 0x0, NULL, HFILL }},
-    { &hf_hicn_tcp_csum, { "Checksum", "hicn.l4.csum", FT_UINT16, BASE_HEX , NULL, 0x0, NULL, HFILL }},
-    { &hf_hicn_tcp_lifetime, { "Lifetime", "hicn.l4.lifetime", FT_UINT16, BASE_DEC , NULL, 0x0, NULL, HFILL }}
-  };
+      {&hf_hicn_ipv6_src,
+       {"Source Address", "hicn.l3.src", FT_IPv6, BASE_NONE, NULL, 0x0, NULL,
+        HFILL}},
+      {&hf_hicn_ipv6_src_data,
+       {"Name Prefix", "hicn.l3.src", FT_IPv6, BASE_NONE, NULL, 0x0, NULL,
+        HFILL}},
+      {&hf_hicn_ipv6_dst,
+       {"Destination Address", "hicn.l3.dst", FT_IPv6, BASE_NONE, NULL, 0x0,
+        NULL, HFILL}},
+      {&hf_hicn_ipv6_dst_interest,
+       {"Name Prefix", "hicn.l3.dst", FT_IPv6, BASE_NONE, NULL, 0x0, NULL,
+        HFILL}},
+      {&hf_hicn_tcp_namesuffix,
+       {"Name Suffix", "hicn.l4.namesuffix", FT_UINT32, BASE_HEX_DEC, NULL, 0x0,
+        NULL, HFILL}},
+      {&hf_hicn_tcp_pathlabel,
+       {"Path Label", "hicn.l4.pathlabel", FT_UINT8, BASE_HEX_DEC, NULL, 0x0,
+        NULL, HFILL}},
+      {&hf_hicn_tcp_hdrlen_timescale,
+       {"Header length and Timescale", "hicn.l4.hdrlen_ts", FT_UINT8, BASE_HEX,
+        NULL, 0x0, NULL, HFILL}},
+      {&hf_hicn_tcp_hdrlen,
+       {"Header length", "hicn.l4.hdrlen", FT_UINT8, BASE_DEC, NULL, 0x0, NULL,
+        HFILL}},
+      {&hf_hicn_tcp_timescale,
+       {"Timescale", "hicn.l4.timescale", FT_UINT8, BASE_DEC, NULL, 0x0, NULL,
+        HFILL}},
+      {&hf_hicn_tcp_flags,
+       {"Flags", "hicn.l4.flags", FT_UINT8, BASE_HEX, NULL, FLAGS_MASK, NULL,
+        HFILL}},
+      {&hf_hicn_tcp_flags_cwr,
+       {"_CWR", "hicn.l4.flags.cwr", FT_BOOLEAN, FLAGS_BITS_LEN,
+        TFS(&tfs_set_notset), TH_CWR, NULL, HFILL}},
+      {&hf_hicn_tcp_flags_id,
+       {"ID", "hicn.l4.flags.id", FT_BOOLEAN, FLAGS_BITS_LEN,
+        TFS(&tfs_set_notset), TH_ID, NULL, HFILL}},
+      {&hf_hicn_tcp_flags_man,
+       {"MAN", "hicn.l4.flags.man", FT_BOOLEAN, FLAGS_BITS_LEN,
+        TFS(&tfs_set_notset), TH_MAN, NULL, HFILL}},
+      {&hf_hicn_tcp_flags_ack,
+       {"_ACK", "hicn.l4.flags.ack", FT_BOOLEAN, FLAGS_BITS_LEN,
+        TFS(&tfs_set_notset), TH_ACK, NULL, HFILL}},
+      {&hf_hicn_tcp_flags_sig,
+       {"SIG", "hicn.l4.flags.sig", FT_BOOLEAN, FLAGS_BITS_LEN,
+        TFS(&tfs_set_notset), TH_SIG, NULL, HFILL}},
+      {&hf_hicn_tcp_flags_rst,
+       {"_RST", "hicn.l4.flags.reset", FT_BOOLEAN, FLAGS_BITS_LEN,
+        TFS(&tfs_set_notset), TH_RST, NULL, HFILL}},
+      {&hf_hicn_tcp_flags_syn,
+       {"_SYN", "hicn.l4.flags.syn", FT_BOOLEAN, FLAGS_BITS_LEN,
+        TFS(&tfs_set_notset), TH_SYN, NULL, HFILL}},
+      {&hf_hicn_tcp_flags_fin,
+       {"_FIN", "hicn.l4.flags.fin", FT_BOOLEAN, FLAGS_BITS_LEN,
+        TFS(&tfs_set_notset), TH_FIN, NULL, HFILL}},
+      {&hf_hicn_tcp_ldr,
+       {"Loss Detection and Recovery", "hicn.l4.ldr", FT_UINT16, BASE_HEX, NULL,
+        0x0, NULL, HFILL}},
+      {&hf_hicn_tcp_csum,
+       {"Checksum", "hicn.l4.csum", FT_UINT16, BASE_HEX, NULL, 0x0, NULL,
+        HFILL}},
+      {&hf_hicn_tcp_lifetime,
+       {"Lifetime", "hicn.l4.lifetime", FT_UINT16, BASE_DEC, NULL, 0x0, NULL,
+        HFILL}}};
 
   static gint *ett[] = {
-    &ett_hicn,
-    &ett_hicn_l3,
-    &ett_hicn_l4,
-    &ett_hicn_l4_flags,
+      &ett_hicn,
+      &ett_hicn_l3,
+      &ett_hicn_l4,
+      &ett_hicn_l4_flags,
   };
 
-  proto_hicn = proto_register_protocol ("Hybrid Information-Centric Networking Protocol", "HICN", "hicn");
+  proto_hicn = proto_register_protocol(
+      "Hybrid Information-Centric Networking Protocol", "HICN", "hicn");
   proto_register_field_array(proto_hicn, hf, array_length(hf));
   proto_register_subtree_array(ett, array_length(ett));
 }
 
-static void
-proto_reg_handoff_hicn(void)
-{
+static void proto_reg_handoff_hicn(void) {
   static dissector_handle_t hicn_handle;
 
   hicn_handle = create_dissector_handle(dissect_hicn, proto_hicn);
@@ -239,8 +314,7 @@ proto_reg_handoff_hicn(void)
   dissector_add_uint("ethertype", ETHERTYPE_IPv6, hicn_handle);
 }
 
-void plugin_register(void)
-{
+void plugin_register(void) {
   static proto_plugin plug_hicn;
   plug_hicn.register_protoinfo = proto_register_hicn;
   plug_hicn.register_handoff = proto_reg_handoff_hicn;
diff --git a/extras/router-plugin/.clang-format b/extras/router-plugin/.clang-format
new file mode 100644
index 000000000..351a70e20
--- /dev/null
+++ b/extras/router-plugin/.clang-format
@@ -0,0 +1,20 @@
+# Minimal clang-format version is 8
+
+BasedOnStyle: GNU
+UseTab: Always
+SpaceAfterCStyleCast: true
+SortIncludes: false
+AlignConsecutiveMacros: true
+BreakBeforeTernaryOperators: false
+BreakBeforeBinaryOperators: None
+ContinuationIndentWidth: 2
+
+ForEachMacros:
+  - 'clib_bitmap_foreach'
+  - 'pool_foreach'
+  - 'pool_foreach_index'
+  - 'vec_foreach'
+  - 'vec_foreach_backwards'
+  - 'vec_foreach_index'
+  - 'vec_foreach_index_backwards'
+  - 'vlib_foreach_rx_tx'
diff --git a/extras/router-plugin/CMakeLists.txt b/extras/router-plugin/CMakeLists.txt
index 81ad2e628..63594297a 100644
--- a/extras/router-plugin/CMakeLists.txt
+++ b/extras/router-plugin/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -29,7 +29,7 @@ set(HICN_EXTRA_PLUGIN hicn-router-plugin)
 
 # Dependencies
 
-find_package(Vpp REQUIRED)
+find_package(Vpp ${VPP_DEFAULT_VERSION} REQUIRED)
 
 include_directories(${VPP_INCLUDE_DIR})
 
@@ -66,7 +66,7 @@ if (CMAKE_BUILD_TYPE STREQUAL "Release")
    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -Wall -march=native -O3 -g")
 elseif (CMAKE_BUILD_TYPE STREQUAL "Debug")
    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wall -march=native -O0 -g")
-   add_definitions(-DCLIB_DEBUG -fPIC -fstack-protector-all)
+   add_definitions(-DHICN_DDEBUG -DCLIB_DEBUG -fPIC -fstack-protector-all)
 endif()
 
 include_directories(SYSTEM)
diff --git a/extras/router-plugin/cmake/Modules/Packaging.cmake b/extras/router-plugin/cmake/Modules/Packaging.cmake
index 69f63971f..15a4f68b8 100644
--- a/extras/router-plugin/cmake/Modules/Packaging.cmake
+++ b/extras/router-plugin/cmake/Modules/Packaging.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -15,17 +15,22 @@
 # Packages section
 ######################
 
+##############################################################
+# Get VPP version
+##############################################################
+list(GET VPP_DEFAULT_VERSION 0 VPP_VERSION)
+
 set(${HICN_EXTRA_PLUGIN}_DESCRIPTION
   "A extra plugin to VPP."
   CACHE STRING "Description for deb/rpm package."
 )
 
 set(${HICN_EXTRA_PLUGIN}_DEB_DEPENDENCIES
-  "vpp (>= stable_version-release), vpp (<< next_version-release), vpp-plugin-core (>= stable_version-release), vpp-plugin-core (<< next_version-release)"
+  "vpp (= ${VPP_VERSION}-release), vpp-plugin-core (= ${VPP_VERSION}-release)"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(${HICN_EXTRA_PLUGIN}_RPM_DEPENDENCIES
-  "vpp >= stable_version-release, vpp < next_version-release, vpp-plugins >= stable_version-release, vpp-plugins < next_version-release"
+  "vpp = ${VPP_VERSION}-release, vpp-plugins = ${VPP_VERSION}-release"
   CACHE STRING "Dependencies for deb/rpm package."
 )
diff --git a/extras/router-plugin/devices/rtnetlink/mapper.c b/extras/router-plugin/devices/rtnetlink/mapper.c
index ed4fa5634..410d5527d 100644
--- a/extras/router-plugin/devices/rtnetlink/mapper.c
+++ b/extras/router-plugin/devices/rtnetlink/mapper.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,254 +13,273 @@
  * limitations under the License.
  */
 
+#include <vnet/fib/fib.h>
 #include <vnet/ip/ip.h>
 #include <vnet/ip/lookup.h>
-#include <vnet/fib/fib.h>
 
-#include "netns.h"
 #include "mapper.h"
+#include "netns.h"
+#include <hicn/util/sstrncpy.h>
 
-typedef struct {
+typedef struct
+{
   int linux_ifindex;
   u32 sw_if_index;
 } mapper_map_t;
 
-typedef struct {
+typedef struct
+{
   char nsname[RTNL_NETNS_NAMELEN + 1];
   mapper_map_t *mappings;
-  u32 netns_handle; //Used to receive notifications
-  u32 v4fib_index; //One fib index for the namespace
+  u32 netns_handle; // Used to receive notifications
+  u32 v4fib_index;  // One fib index for the namespace
   u32 v6fib_index;
 } mapper_ns_t;
 
-typedef struct {
+typedef struct
+{
   mapper_ns_t *namespaces;
 } mapper_main_t;
 
 static mapper_main_t mapper_main;
 
-mapper_map_t *mapper_get_by_ifindex(mapper_ns_t *ns, int ifindex)
+mapper_map_t *
+mapper_get_by_ifindex (mapper_ns_t *ns, int ifindex)
 {
   mapper_map_t *map;
-  pool_foreach(map, ns->mappings, {
-      if (ifindex == map->linux_ifindex)
-        return map;
-  });
+  pool_foreach (map, ns->mappings, {
+    if (ifindex == map->linux_ifindex)
+      return map;
+  })
+    ;
   return NULL;
 }
 
-int mapper_add_del_route(mapper_ns_t *ns, ns_route_t *route, int del)
+int
+mapper_add_del_route (mapper_ns_t *ns, ns_route_t *route, int del)
 {
   mapper_main_t *mm = &mapper_main;
-  clib_warning("NS %d %s %U", ns - mm->namespaces, del?"del":"add", format_ns_route, route);
+  clib_warning ("NS %d %s %U", ns - mm->namespaces, del ? "del" : "add",
+		format_ns_route, route);
 
-  mapper_map_t *map = mapper_get_by_ifindex(ns, route->oif);
+  mapper_map_t *map = mapper_get_by_ifindex (ns, route->oif);
   if (!map)
     return 0;
 
-  if (route->rtm.rtm_family == AF_INET6) {
-
-    //Filter-out multicast
-    if (route->rtm.rtm_dst_len >= 8 && route->dst[0] == 0xff)
-      return 0;
-
-    fib_prefix_t prefix;
-    ip46_address_t nh;
-
-    memset (&prefix, 0, sizeof (prefix));
-    prefix.fp_len = route->rtm.rtm_dst_len;
-    prefix.fp_proto = FIB_PROTOCOL_IP6;
-    clib_memcpy (&prefix.fp_addr.ip6, route->dst, sizeof (prefix.fp_addr.ip6));
-
-    memset (&nh, 0, sizeof (nh));
-    clib_memcpy (&nh.ip6, route->gateway, sizeof (nh.ip6));
-
-    fib_table_entry_path_add (ns->v6fib_index, &prefix, FIB_SOURCE_API,
-                              FIB_ENTRY_FLAG_NONE, prefix.fp_proto,
-                              &nh, map->sw_if_index, ns->v6fib_index,
-                              0 /* weight */,
-                              (fib_mpls_label_t *) MPLS_LABEL_INVALID,
-                              FIB_ROUTE_PATH_FLAG_NONE);
-  } else {
-    fib_prefix_t prefix;
-    ip46_address_t nh;
-
-    memset (&prefix, 0, sizeof (prefix));
-    prefix.fp_len = route->rtm.rtm_dst_len;
-    prefix.fp_proto = FIB_PROTOCOL_IP4;
-    clib_memcpy (&prefix.fp_addr.ip4, route->dst, sizeof (prefix.fp_addr.ip4));
-
-    memset (&nh, 0, sizeof (nh));
-    clib_memcpy (&nh.ip4, route->gateway, sizeof (nh.ip4));
-
-    fib_table_entry_path_add (ns->v4fib_index, &prefix, FIB_SOURCE_API,
-                              FIB_ENTRY_FLAG_NONE, prefix.fp_proto,
-                              &nh, map->sw_if_index, ns->v4fib_index,
-                              0 /* weight */,
-                              (fib_mpls_label_t *) MPLS_LABEL_INVALID,
-                              FIB_ROUTE_PATH_FLAG_NONE);
-  }
+  if (route->rtm.rtm_family == AF_INET6)
+    {
+
+      // Filter-out multicast
+      if (route->rtm.rtm_dst_len >= 8 && route->dst[0] == 0xff)
+	return 0;
+
+      fib_prefix_t prefix;
+      ip_address_t nh;
+
+      memset (&prefix, 0, sizeof (prefix));
+      prefix.fp_len = route->rtm.rtm_dst_len;
+      prefix.fp_proto = FIB_PROTOCOL_IP6;
+      clib_memcpy (&prefix.fp_addr.ip6, route->dst,
+		   sizeof (prefix.fp_addr.ip6));
+
+      memset (&nh, 0, sizeof (nh));
+      clib_memcpy (&nh.ip6, route->gateway, sizeof (nh.ip6));
+
+      fib_table_entry_path_add (
+	ns->v6fib_index, &prefix, FIB_SOURCE_API, FIB_ENTRY_FLAG_NONE,
+	prefix.fp_proto, &nh, map->sw_if_index, ns->v6fib_index,
+	0 /* weight */, (fib_mpls_label_t *) MPLS_LABEL_INVALID,
+	FIB_ROUTE_PATH_FLAG_NONE);
+    }
+  else
+    {
+      fib_prefix_t prefix;
+      ip_address_t nh;
+
+      memset (&prefix, 0, sizeof (prefix));
+      prefix.fp_len = route->rtm.rtm_dst_len;
+      prefix.fp_proto = FIB_PROTOCOL_IP4;
+      clib_memcpy (&prefix.fp_addr.ip4, route->dst,
+		   sizeof (prefix.fp_addr.ip4));
+
+      memset (&nh, 0, sizeof (nh));
+      clib_memcpy (&nh.ip4, route->gateway, sizeof (nh.ip4));
+
+      fib_table_entry_path_add (
+	ns->v4fib_index, &prefix, FIB_SOURCE_API, FIB_ENTRY_FLAG_NONE,
+	prefix.fp_proto, &nh, map->sw_if_index, ns->v4fib_index,
+	0 /* weight */, (fib_mpls_label_t *) MPLS_LABEL_INVALID,
+	FIB_ROUTE_PATH_FLAG_NONE);
+    }
 
   return 0;
 }
 
 static void
-mapper_netns_notify_cb(void *obj, netns_type_t type,
-                       u32 flags, uword opaque)
+mapper_netns_notify_cb (void *obj, netns_type_t type, u32 flags, uword opaque)
 {
   mapper_main_t *mm = &mapper_main;
   mapper_ns_t *ns = &mm->namespaces[(u32) opaque];
-  ASSERT(!pool_is_free_index(mm->namespaces, (u32) opaque));
+  ASSERT (!pool_is_free_index (mm->namespaces, (u32) opaque));
   if (type != NETNS_TYPE_ROUTE)
-    return; //For now...
+    return; // For now...
 
   ns_route_t *route = obj;
-  if (flags & NETNS_F_DEL) {
-    mapper_add_del_route(ns, route, 1);
-  } else if (flags & NETNS_F_ADD) {
-    mapper_add_del_route(ns, route, 0);
-  }
+  if (flags & NETNS_F_DEL)
+    {
+      mapper_add_del_route (ns, route, 1);
+    }
+  else if (flags & NETNS_F_ADD)
+    {
+      mapper_add_del_route (ns, route, 0);
+    }
 }
 
 void
-mapper_delmap(mapper_ns_t*ns, mapper_map_t *map)
+mapper_delmap (mapper_ns_t *ns, mapper_map_t *map)
 {
   ns_route_t *route;
-  netns_t *netns = netns_getns(ns->netns_handle);
-  pool_foreach(route, netns->routes, {
-      if (route->oif == map->linux_ifindex)
-        mapper_add_del_route(ns, route, 1);
-  });
-  pool_put(ns->mappings, map);
+  netns_t *netns = netns_getns (ns->netns_handle);
+  pool_foreach (route, netns->routes, {
+    if (route->oif == map->linux_ifindex)
+      mapper_add_del_route (ns, route, 1);
+  })
+    ;
+  pool_put (ns->mappings, map);
 }
 
 mapper_map_t *
-mapper_getmap(mapper_ns_t*ns, u32 sw_if_index,
-              int linux_ifindex, int create)
+mapper_getmap (mapper_ns_t *ns, u32 sw_if_index, int linux_ifindex, int create)
 {
   mapper_map_t *map;
-  pool_foreach(map, ns->mappings, {
-      if (linux_ifindex == map->linux_ifindex) {
-        if (sw_if_index != map->sw_if_index)
-          return NULL; //Cannot have multiple mapping with the same ifindex
-        else
-          return map;
+  pool_foreach (map, ns->mappings, {
+    if (linux_ifindex == map->linux_ifindex)
+      {
+	if (sw_if_index != map->sw_if_index)
+	  return NULL; // Cannot have multiple mapping with the same ifindex
+	else
+	  return map;
       }
-  });
+  })
+    ;
 
   if (!create)
     return NULL;
 
-  pool_get(ns->mappings, map);
+  pool_get (ns->mappings, map);
   map->linux_ifindex = linux_ifindex;
   map->sw_if_index = sw_if_index;
   ip6_main.fib_index_by_sw_if_index[sw_if_index] = ns->v6fib_index;
   ip4_main.fib_index_by_sw_if_index[sw_if_index] = ns->v4fib_index;
 
-  //Load available routes
+  // Load available routes
   ns_route_t *route;
-  netns_t *netns = netns_getns(ns->netns_handle);
-  pool_foreach(route, netns->routes, {
-      if (route->oif == map->linux_ifindex)
-        mapper_add_del_route(ns, route, 0);
-  });
+  netns_t *netns = netns_getns (ns->netns_handle);
+  pool_foreach (route, netns->routes, {
+    if (route->oif == map->linux_ifindex)
+      mapper_add_del_route (ns, route, 0);
+  })
+    ;
   return map;
 }
 
 u32
-mapper_get_ns(char *nsname)
+mapper_get_ns (char *nsname)
 {
   mapper_main_t *mm = &mapper_main;
   mapper_ns_t *ns;
-  pool_foreach(ns, mm->namespaces, {
-      if (!strcmp(nsname, ns->nsname))
-        return ns - mm->namespaces;
-  });
+  pool_foreach (ns, mm->namespaces, {
+    if (!strcmp (nsname, ns->nsname))
+      return ns - mm->namespaces;
+  })
+    ;
   return ~0;
 }
 
 int
-mapper_add_del(u32 nsindex, int linux_ifindex,
-               u32 sw_if_index, int del)
+mapper_add_del (u32 nsindex, int linux_ifindex, u32 sw_if_index, int del)
 {
   mapper_main_t *mm = &mapper_main;
-  //ip6_main_t *im6 = &ip6_main;
+  // ip6_main_t *im6 = &ip6_main;
   mapper_ns_t *ns = &mm->namespaces[nsindex];
   mapper_map_t *map;
-  //vnet_sw_interface_t *iface = vnet_get_sw_interface(vnet_get_main(), sw_if_index);
+  // vnet_sw_interface_t *iface = vnet_get_sw_interface(vnet_get_main(),
+  // sw_if_index);
 
-  if (pool_is_free(mm->namespaces, ns))
+  if (pool_is_free (mm->namespaces, ns))
     return -1;
 
   /*if (!del) {
     if ((iface->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) &&
-        im6->fib_index_by_sw_if_index[sw_if_index] != ~0) {
+	im6->fib_index_by_sw_if_index[sw_if_index] != ~0) {
       //A custom fib index will be used...
-      clib_warning("Cannot add interface with a custom fib index (current is %d)",
-                   im6->fib_index_by_sw_if_index[sw_if_index]);
-      return -1;
+      clib_warning("Cannot add interface with a custom fib index (current is
+  %d)", im6->fib_index_by_sw_if_index[sw_if_index]); return -1;
     }
   }*/
 
-  if (!(map = mapper_getmap(ns, sw_if_index, linux_ifindex, !del)))
+  if (!(map = mapper_getmap (ns, sw_if_index, linux_ifindex, !del)))
     return -1;
 
   if (del)
-    mapper_delmap(ns, map);
+    mapper_delmap (ns, map);
 
   return 0;
 }
 
 int
-mapper_add_ns(char *nsname, u32 v4fib_index, u32 v6fib_index, u32 *nsindex)
+mapper_add_ns (char *nsname, u32 v4fib_index, u32 v6fib_index, u32 *nsindex)
 {
   mapper_main_t *mm = &mapper_main;
   mapper_ns_t *ns;
-  if (mapper_get_ns(nsname) != ~0)
-    return -1; //Already exists
+  if (mapper_get_ns (nsname) != ~0)
+    return -1; // Already exists
 
-  pool_get(mm->namespaces, ns);
-  strcpy(ns->nsname, nsname);
+  pool_get (mm->namespaces, ns);
+  int rc = strcpy_s (ns->nsname, sizeof (ns->nsname), nsname);
+  if (rc != EOK)
+    return -1;
   ns->v4fib_index = v4fib_index;
   ns->v6fib_index = v6fib_index;
   ns->mappings = 0;
 
   netns_sub_t sub;
   sub.notify = mapper_netns_notify_cb;
-  sub.opaque = (uword)(ns - mm->namespaces);
-  if ((ns->netns_handle = netns_open(ns->nsname, &sub)) == ~0) {
-    pool_put(mm->namespaces, ns);
-    return -1;
-  }
+  sub.opaque = (uword) (ns - mm->namespaces);
+  if ((ns->netns_handle = netns_open (ns->nsname, &sub)) == ~0)
+    {
+      pool_put (mm->namespaces, ns);
+      return -1;
+    }
   *nsindex = ns - mm->namespaces;
   return 0;
 }
 
 int
-mapper_del_ns(u32 nsindex)
+mapper_del_ns (u32 nsindex)
 {
   mapper_main_t *mm = &mapper_main;
   mapper_ns_t *ns = &mm->namespaces[nsindex];
-  if (pool_is_free(mm->namespaces, ns))
+  if (pool_is_free (mm->namespaces, ns))
     return -1;
 
-  //Remove all existing mappings
+  // Remove all existing mappings
   int i, *indexes = 0;
-  pool_foreach_index(i, ns->mappings, {
-    vec_add1(indexes, i);
-  });
-  vec_foreach_index(i, indexes) {
-    mapper_delmap(ns, &ns->mappings[indexes[i]]);
-  }
-  vec_free(indexes);
-
-  netns_close(ns->netns_handle);
-  pool_put(mm->namespaces, ns);
+  pool_foreach_index (i, ns->mappings, { vec_add1 (indexes, i); })
+    ;
+  vec_foreach_index (i, indexes)
+    {
+      mapper_delmap (ns, &ns->mappings[indexes[i]]);
+    }
+  vec_free (indexes);
+
+  netns_close (ns->netns_handle);
+  pool_put (mm->namespaces, ns);
   return 0;
 }
 
 clib_error_t *
-mapper_init (vlib_main_t * vm)
+mapper_init (vlib_main_t *vm)
 {
   mapper_main_t *mm = &mapper_main;
   mm->namespaces = 0;
diff --git a/extras/router-plugin/devices/rtnetlink/mapper.h b/extras/router-plugin/devices/rtnetlink/mapper.h
index 32e95d48f..436e5dc4d 100644
--- a/extras/router-plugin/devices/rtnetlink/mapper.h
+++ b/extras/router-plugin/devices/rtnetlink/mapper.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -28,8 +28,9 @@
  * A mapped VPP interface must not have any configured fib.
  */
 
-int mapper_add_ns(char *nsname, u32 v4fib_index, u32 v6fib_index, u32 *nsindex);
-int mapper_del_ns(u32 nsindex);
-int mapper_add_del(u32 nsindex, int linux_ifindex, u32 sw_if_index, int del);
+int mapper_add_ns (char *nsname, u32 v4fib_index, u32 v6fib_index,
+		   u32 *nsindex);
+int mapper_del_ns (u32 nsindex);
+int mapper_add_del (u32 nsindex, int linux_ifindex, u32 sw_if_index, int del);
 
 #endif /* MAPPER_H_ */
diff --git a/extras/router-plugin/devices/rtnetlink/netns.c b/extras/router-plugin/devices/rtnetlink/netns.c
index 19adb469a..0d9986185 100644
--- a/extras/router-plugin/devices/rtnetlink/netns.c
+++ b/extras/router-plugin/devices/rtnetlink/netns.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,190 +13,197 @@
  * limitations under the License.
  */
 
-
-#include <vlib/vlib.h>
+#include <stddef.h>
 #include <vlib/unix/unix.h>
+#include <vlib/vlib.h>
 #include <vnet/ethernet/ethernet.h>
+#include <vnet/ip/format.h>
 #include <vnet/ip/ip4_packet.h>
 #include <vnet/ip/ip6_packet.h>
-#include <vnet/ip/format.h>
-#include <stddef.h>
 
 #include "netns.h"
+#include <hicn/util/sstrncpy.h>
 
 /* Enable some RTA values debug */
 //#define RTNL_CHECK
 
-#define is_nonzero(x)                           \
-  ({                                            \
-    u8 __is_zero_zero[sizeof(x)] = {};          \
-    memcmp(__is_zero_zero, &x, sizeof(x));      \
+#define is_nonzero(x)                                                         \
+  ({                                                                          \
+    u8 __is_zero_zero[sizeof (x)] = {};                                       \
+    memcmp (__is_zero_zero, &x, sizeof (x));                                  \
   })
 
-typedef struct {
-  u8 type;      //Attribute identifier
-  u8 unique;    //Part of the values uniquely identifying an entry
-  u16 offset;   //Offset where stored in struct
-  u16 size;     //Length of the attribute
+typedef struct
+{
+  u8 type;    // Attribute identifier
+  u8 unique;  // Part of the values uniquely identifying an entry
+  u16 offset; // Offset where stored in struct
+  u16 size;   // Length of the attribute
 } rtnl_mapping_t;
 
-#define ns_foreach_ifla                         \
-  _(IFLA_ADDRESS, hwaddr)                       \
-  _(IFLA_BROADCAST, broadcast)                  \
-  _(IFLA_IFNAME, ifname)                        \
-  _(IFLA_MASTER, master)                        \
-  _(IFLA_MTU, mtu)                              \
-  _(IFLA_QDISC, qdisc)
+#define ns_foreach_ifla                                                       \
+  _ (IFLA_ADDRESS, hwaddr)                                                    \
+  _ (IFLA_BROADCAST, broadcast)                                               \
+  _ (IFLA_IFNAME, ifname)                                                     \
+  _ (IFLA_MASTER, master)                                                     \
+  _ (IFLA_MTU, mtu)                                                           \
+  _ (IFLA_QDISC, qdisc)
 
 static rtnl_mapping_t ns_ifmap[] = {
-#define _(t, e)                                 \
-  {                                             \
-    .type = t,                                  \
-    .offset = offsetof(ns_link_t, e),           \
-    .size = sizeof(((ns_link_t*)0)->e)          \
-  },
+#define _(t, e)                                                               \
+  { .type = t,                                                                \
+    .offset = offsetof (ns_link_t, e),                                        \
+    .size = sizeof (((ns_link_t *) 0)->e) },
   ns_foreach_ifla
 #undef _
   { .type = 0 }
 };
 
-u8 *format_ns_link (u8 *s, va_list *args)
+u8 *
+format_ns_link (u8 *s, va_list *args)
 {
-  ns_link_t *l = va_arg(*args, ns_link_t *);
-  s = format(s, "%s index %u", l->ifname, l->ifi.ifi_index);
+  ns_link_t *l = va_arg (*args, ns_link_t *);
+  s = format (s, "%s index %u", l->ifname, l->ifi.ifi_index);
   return s;
 }
 
-#define ns_foreach_rta                          \
-  _(RTA_DST, dst, 1)                            \
-  _(RTA_SRC, src, 1)                            \
-  _(RTA_GATEWAY, gateway, 1)                    \
-  _(RTA_IIF, iif, 1)                            \
-  _(RTA_OIF, oif, 1)                            \
-  _(RTA_PREFSRC, prefsrc, 0)                    \
-  _(RTA_TABLE, table, 0)                        \
-  _(RTA_PRIORITY, priority, 0)                  \
-  _(RTA_CACHEINFO, cacheinfo, 0)                \
-  _(RTA_ENCAP, encap, 1)
+#define ns_foreach_rta                                                        \
+  _ (RTA_DST, dst, 1)                                                         \
+  _ (RTA_SRC, src, 1)                                                         \
+  _ (RTA_GATEWAY, gateway, 1)                                                 \
+  _ (RTA_IIF, iif, 1)                                                         \
+  _ (RTA_OIF, oif, 1)                                                         \
+  _ (RTA_PREFSRC, prefsrc, 0)                                                 \
+  _ (RTA_TABLE, table, 0)                                                     \
+  _ (RTA_PRIORITY, priority, 0)                                               \
+  _ (RTA_CACHEINFO, cacheinfo, 0)                                             \
+  _ (RTA_ENCAP, encap, 1)
 
 static rtnl_mapping_t ns_routemap[] = {
-#define _(t, e, u)                              \
-  {                                             \
-    .type = t, .unique = u,                     \
-    .offset = offsetof(ns_route_t, e),          \
-    .size = sizeof(((ns_route_t*)0)->e)         \
-  },
+#define _(t, e, u)                                                            \
+  { .type = t,                                                                \
+    .unique = u,                                                              \
+    .offset = offsetof (ns_route_t, e),                                       \
+    .size = sizeof (((ns_route_t *) 0)->e) },
   ns_foreach_rta
 #undef _
   { .type = 0 }
 };
 
-u8 *format_ns_route (u8 *s, va_list *args)
+u8 *
+format_ns_route (u8 *s, va_list *args)
 {
-  ns_route_t *r = va_arg(*args, ns_route_t *);
-  void *format_ip = r->rtm.rtm_family == AF_INET ? format_ip4_address : format_ip6_address;
-  s = format(s, "%U/%d", format_ip, r->dst, r->rtm.rtm_dst_len);
+  ns_route_t *r = va_arg (*args, ns_route_t *);
+  void *format_ip =
+    r->rtm.rtm_family == AF_INET ? format_ip4_address : format_ip6_address;
+  s = format (s, "%U/%d", format_ip, r->dst, r->rtm.rtm_dst_len);
   if (r->rtm.rtm_src_len)
-    s = format(s, " from %U/%d", format_ip, r->src, r->rtm.rtm_src_len);
-  if (is_nonzero(r->gateway))
-    s = format(s, " via %U", format_ip, r->gateway);
+    s = format (s, " from %U/%d", format_ip, r->src, r->rtm.rtm_src_len);
+  if (is_nonzero (r->gateway))
+    s = format (s, " via %U", format_ip, r->gateway);
   if (r->iif)
-    s = format(s, " iif %d", r->iif);
+    s = format (s, " iif %d", r->iif);
   if (r->oif)
-    s = format(s, " oif %d", r->oif);
-  if (is_nonzero(r->prefsrc))
-    s = format(s, " src %U", format_ip, r->prefsrc);
+    s = format (s, " oif %d", r->oif);
+  if (is_nonzero (r->prefsrc))
+    s = format (s, " src %U", format_ip, r->prefsrc);
   if (r->table)
-    s = format(s, " table %d", r->table);
+    s = format (s, " table %d", r->table);
   if (r->priority)
-    s = format(s, " priority %u", r->priority);
+    s = format (s, " priority %u", r->priority);
   return s;
 }
 
-#define ns_foreach_ifaddr                       \
-  _(IFA_ADDRESS, addr, 1)                       \
-  _(IFA_LOCAL, local, 1)                        \
-  _(IFA_LABEL, label, 0)                        \
-  _(IFA_BROADCAST, broadcast, 0)                \
-  _(IFA_ANYCAST, anycast, 0)                    \
-  _(IFA_CACHEINFO, cacheinfo, 0)
+#define ns_foreach_ifaddr                                                     \
+  _ (IFA_ADDRESS, addr, 1)                                                    \
+  _ (IFA_LOCAL, local, 1)                                                     \
+  _ (IFA_LABEL, label, 0)                                                     \
+  _ (IFA_BROADCAST, broadcast, 0)                                             \
+  _ (IFA_ANYCAST, anycast, 0)                                                 \
+  _ (IFA_CACHEINFO, cacheinfo, 0)
 
 static rtnl_mapping_t ns_addrmap[] = {
-#define _(t, e, u)                              \
-  {                                             \
-    .type = t, .unique = u,                     \
-    .offset = offsetof(ns_addr_t, e),           \
-    .size = sizeof(((ns_addr_t*)0)->e)          \
-  },
+#define _(t, e, u)                                                            \
+  { .type = t,                                                                \
+    .unique = u,                                                              \
+    .offset = offsetof (ns_addr_t, e),                                        \
+    .size = sizeof (((ns_addr_t *) 0)->e) },
   ns_foreach_ifaddr
 #undef _
   { .type = 0 }
 };
 
-u8 *format_ns_addr (u8 *s, va_list *args)
-{
-  ns_addr_t *a = va_arg(*args, ns_addr_t *);
-  void *format_ip = a->ifaddr.ifa_family == AF_INET ? format_ip4_address : format_ip6_address;
-  s = format(s, "%U/%d", format_ip, a->addr, a->ifaddr.ifa_prefixlen);
-  if (is_nonzero(a->label))
-    s = format(s, " dev %s", a->label);
-  if (is_nonzero(a->broadcast))
-    s = format(s, " broadcast %U", format_ip, a->broadcast);
-  if (is_nonzero(a->anycast))
-    s = format(s, " anycast %U", format_ip, a->anycast);
-  if (is_nonzero(a->local))
-    s = format(s, " local %U", format_ip, a->local);
+u8 *
+format_ns_addr (u8 *s, va_list *args)
+{
+  ns_addr_t *a = va_arg (*args, ns_addr_t *);
+  void *format_ip =
+    a->ifaddr.ifa_family == AF_INET ? format_ip4_address : format_ip6_address;
+  s = format (s, "%U/%d", format_ip, a->addr, a->ifaddr.ifa_prefixlen);
+  if (is_nonzero (a->label))
+    s = format (s, " dev %s", a->label);
+  if (is_nonzero (a->broadcast))
+    s = format (s, " broadcast %U", format_ip, a->broadcast);
+  if (is_nonzero (a->anycast))
+    s = format (s, " anycast %U", format_ip, a->anycast);
+  if (is_nonzero (a->local))
+    s = format (s, " local %U", format_ip, a->local);
   return s;
 }
 
 #ifndef NDA_RTA
-#define NDA_RTA(r)  ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
-#define NDA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ndmsg))
+#define NDA_RTA(r)                                                            \
+  ((struct rtattr *) (((char *) (r)) + NLMSG_ALIGN (sizeof (struct ndmsg))))
+#define NDA_PAYLOAD(n) NLMSG_PAYLOAD (n, sizeof (struct ndmsg))
 #endif
 
-#define ns_foreach_neigh                        \
-  _(NDA_DST, dst, 1)                            \
-  _(NDA_LLADDR, lladdr, 0)                      \
-  _(NDA_PROBES, probes, 0)                      \
-  _(NDA_CACHEINFO, cacheinfo, 0)
+#define ns_foreach_neigh                                                      \
+  _ (NDA_DST, dst, 1)                                                         \
+  _ (NDA_LLADDR, lladdr, 0)                                                   \
+  _ (NDA_PROBES, probes, 0)                                                   \
+  _ (NDA_CACHEINFO, cacheinfo, 0)
 
 static rtnl_mapping_t ns_neighmap[] = {
-#define _(t, e, u)                              \
-  {                                             \
-    .type = t, .unique = u,                     \
-    .offset = offsetof(ns_neigh_t, e),          \
-    .size = sizeof(((ns_neigh_t*)0)->e)         \
-  },
+#define _(t, e, u)                                                            \
+  { .type = t,                                                                \
+    .unique = u,                                                              \
+    .offset = offsetof (ns_neigh_t, e),                                       \
+    .size = sizeof (((ns_neigh_t *) 0)->e) },
   ns_foreach_neigh
 #undef _
   { .type = 0 }
 };
 
-u8 *format_ns_neigh (u8 *s, va_list *args)
+u8 *
+format_ns_neigh (u8 *s, va_list *args)
 {
-  ns_neigh_t *n = va_arg(*args, ns_neigh_t *);
-  void *format_ip = n->nd.ndm_family == AF_INET ? format_ip4_address : format_ip6_address;
-  s = format(s, "%U", format_ip, n->dst);
-  if (is_nonzero(n->lladdr))
-    s = format(s, " lladdr %U", format_ethernet_address, n->lladdr);
+  ns_neigh_t *n = va_arg (*args, ns_neigh_t *);
+  void *format_ip =
+    n->nd.ndm_family == AF_INET ? format_ip4_address : format_ip6_address;
+  s = format (s, "%U", format_ip, n->dst);
+  if (is_nonzero (n->lladdr))
+    s = format (s, " lladdr %U", format_ethernet_address, n->lladdr);
   if (n->probes)
-    s = format(s, " probes %d", n->probes);
+    s = format (s, " probes %d", n->probes);
   return s;
 }
 
-typedef struct {
-  void (*notify)(void *obj, netns_type_t type, u32 flags, uword opaque);
+typedef struct
+{
+  void (*notify) (void *obj, netns_type_t type, u32 flags, uword opaque);
   uword opaque;
   u32 netns_index;
 } netns_handle_t;
 
-typedef struct {
+typedef struct
+{
   netns_t netns;
   u32 rtnl_handle;
   u32 subscriber_count;
 } netns_p;
 
-typedef struct {
+typedef struct
+{
   netns_p *netnss;
   netns_handle_t *handles;
 } netns_main_t;
@@ -204,22 +211,25 @@ typedef struct {
 netns_main_t netns_main;
 
 static int
-rtnl_parse_rtattr(struct rtattr *db[], size_t max,
-                  struct rtattr *rta, size_t len) {
-  for(; RTA_OK(rta, len); rta = RTA_NEXT(rta, len)) {
-    if (rta->rta_type <= max)
-      db[rta->rta_type] = rta;
+rtnl_parse_rtattr (struct rtattr *db[], size_t max, struct rtattr *rta,
+		   size_t len)
+{
+  for (; RTA_OK (rta, len); rta = RTA_NEXT (rta, len))
+    {
+      if (rta->rta_type <= max)
+	db[rta->rta_type] = rta;
 #ifdef RTNL_CHECK
-    else
-      clib_warning("RTA type too high: %d", rta->rta_type);
+      else
+	clib_warning ("RTA type too high: %d", rta->rta_type);
 #endif
-  }
+    }
 
-  if(len) {
-    clib_warning("rattr lenght mistmatch %d %d len",
-                 (int) len, (int) rta->rta_len);
-    return -1;
-  }
+  if (len)
+    {
+      clib_warning ("rattr lenght mistmatch %d %d len", (int) len,
+		    (int) rta->rta_len);
+      return -1;
+    }
   return 0;
 }
 
@@ -230,24 +240,24 @@ rtnl_parse_rtattr(struct rtattr *db[], size_t max,
  */
 #ifdef RTNL_CHECK
 static void
-rtnl_entry_check(struct rtattr *rtas[],
-                 size_t rta_len,
-                 rtnl_mapping_t map[],
-                 char *logstr)
+rtnl_entry_check (struct rtattr *rtas[], size_t rta_len, rtnl_mapping_t map[],
+		  char *logstr)
 {
   int i;
-  for (i=0; i<rta_len; i++) {
-    if (!rtas[i])
-      continue;
-
-    rtnl_mapping_t *m = map;
-    for (m = map; m->type; m++) {
-      if (m->type == rtas[i]->rta_type)
-        break;
+  for (i = 0; i < rta_len; i++)
+    {
+      if (!rtas[i])
+	continue;
+
+      rtnl_mapping_t *m = map;
+      for (m = map; m->type; m++)
+	{
+	  if (m->type == rtas[i]->rta_type)
+	    break;
+	}
+      if (!m->type)
+	clib_warning ("Unknown RTA type %d (%s)", rtas[i]->rta_type, logstr);
     }
-    if (!m->type)
-      clib_warning("Unknown RTA type %d (%s)", rtas[i]->rta_type, logstr);
-  }
 }
 #endif
 
@@ -255,433 +265,469 @@ rtnl_entry_check(struct rtattr *rtas[],
  * Check if the provided entry matches the parsed and unique rtas
  */
 static int
-rtnl_entry_match(void *entry,
-                 struct rtattr *rtas[],
-                 rtnl_mapping_t map[])
+rtnl_entry_match (void *entry, struct rtattr *rtas[], rtnl_mapping_t map[])
 {
   u8 zero[1024] = {};
-  for ( ;map->type != 0; map++) {
-    struct rtattr *rta = rtas[map->type];
-    size_t rta_len = rta?RTA_PAYLOAD(rta):0;
-    if (!map->unique)
-      continue;
-
-    if (rta && RTA_PAYLOAD(rta) > map->size) {
-      clib_warning("rta (type=%d len=%d) too long (max %d)",
-                   rta->rta_type, rta->rta_len, map->size);
-      return -1;
-    }
-
-    if ((rta && memcmp(RTA_DATA(rta), entry + map->offset, rta_len)) ||
-        memcmp(entry + map->offset + rta_len, zero, map->size - rta_len)) {
-      return 0;
+  for (; map->type != 0; map++)
+    {
+      struct rtattr *rta = rtas[map->type];
+      size_t rta_len = rta ? RTA_PAYLOAD (rta) : 0;
+      if (!map->unique)
+	continue;
+
+      if (rta && RTA_PAYLOAD (rta) > map->size)
+	{
+	  clib_warning ("rta (type=%d len=%d) too long (max %d)",
+			rta->rta_type, rta->rta_len, map->size);
+	  return -1;
+	}
+
+      if ((rta && memcmp (RTA_DATA (rta), entry + map->offset, rta_len)) ||
+	  memcmp (entry + map->offset + rta_len, zero, map->size - rta_len))
+	{
+	  return 0;
+	}
     }
-  }
   return 1;
 }
 
 static int
-rtnl_entry_set(void *entry,
-               struct rtattr *rtas[],
-               rtnl_mapping_t map[],
-               int init)
-{
-  for (; map->type != 0; map++) {
-
-    struct rtattr *rta = rtas[map->type];
-
-    if(map->type == RTA_ENCAP && rta) {
-      /*Data of RTA_ENCAP is a pointer to rta attributes for MPLS*/
-      rta = (struct rtattr*)RTA_DATA(rta);
-      if (RTA_PAYLOAD(rta) > map->size) {
-        clib_warning("rta (type=%d len=%d) too long (max %d)", rta->rta_type, rta->rta_len, map->size);
-        return -1;
-      }
-      memcpy(entry + map->offset, RTA_DATA(rta), map->size);
-      memset(entry + map->offset + map->size, 0, 0);
-    } else if (rta) {
-      if (RTA_PAYLOAD(rta) > map->size) {
-        clib_warning("rta (type=%d len=%d) too long (max %d)", rta->rta_type, rta->rta_len, map->size);
-        return -1;
-      }
-      memcpy(entry + map->offset, RTA_DATA(rta), RTA_PAYLOAD(rta));
-      memset(entry + map->offset + RTA_PAYLOAD(rta), 0, map->size - RTA_PAYLOAD(rta));
-    } else if (init) {
-      memset(entry + map->offset, 0, map->size);
+rtnl_entry_set (void *entry, struct rtattr *rtas[], rtnl_mapping_t map[],
+		int init)
+{
+  for (; map->type != 0; map++)
+    {
+
+      struct rtattr *rta = rtas[map->type];
+
+      if (map->type == RTA_ENCAP && rta)
+	{
+	  /*Data of RTA_ENCAP is a pointer to rta attributes for MPLS*/
+	  rta = (struct rtattr *) RTA_DATA (rta);
+	  if (RTA_PAYLOAD (rta) > map->size)
+	    {
+	      clib_warning ("rta (type=%d len=%d) too long (max %d)",
+			    rta->rta_type, rta->rta_len, map->size);
+	      return -1;
+	    }
+	  memcpy (entry + map->offset, RTA_DATA (rta), map->size);
+	  memset (entry + map->offset + map->size, 0, 0);
+	}
+      else if (rta)
+	{
+	  if (RTA_PAYLOAD (rta) > map->size)
+	    {
+	      clib_warning ("rta (type=%d len=%d) too long (max %d)",
+			    rta->rta_type, rta->rta_len, map->size);
+	      return -1;
+	    }
+	  memcpy (entry + map->offset, RTA_DATA (rta), RTA_PAYLOAD (rta));
+	  memset (entry + map->offset + RTA_PAYLOAD (rta), 0,
+		  map->size - RTA_PAYLOAD (rta));
+	}
+      else if (init)
+	{
+	  memset (entry + map->offset, 0, map->size);
+	}
     }
-  }
   return 0;
 }
 
 void
-netns_notify(netns_p *ns, void *obj, netns_type_t type, u32 flags)
+netns_notify (netns_p *ns, void *obj, netns_type_t type, u32 flags)
 {
   netns_main_t *nm = &netns_main;
   netns_handle_t *h;
-  pool_foreach(h, nm->handles, {
-      if (h->netns_index == (ns - nm->netnss) &&  h->notify)
-        h->notify(obj, type, flags, h->opaque);
-    });
+  pool_foreach (h, nm->handles, {
+    if (h->netns_index == (ns - nm->netnss) && h->notify)
+      h->notify (obj, type, flags, h->opaque);
+  })
+    ;
 }
 
 static_always_inline int
-mask_match(void *a, void *b, void *mask, size_t len)
+mask_match (void *a, void *b, void *mask, size_t len)
 {
   u8 *va = (u8 *) a;
   u8 *vb = (u8 *) b;
   u8 *vm = (u8 *) mask;
-  while (len--) {
-    if ((va[len] ^ vb[len]) & vm[len])
-      return 0;
-  }
+  while (len--)
+    {
+      if ((va[len] ^ vb[len]) & vm[len])
+	return 0;
+    }
   return 1;
 }
 
 static ns_link_t *
-ns_get_link(netns_p *ns, struct ifinfomsg *ifi, struct rtattr *rtas[])
+ns_get_link (netns_p *ns, struct ifinfomsg *ifi, struct rtattr *rtas[])
 {
   ns_link_t *link;
-  pool_foreach(link, ns->netns.links, {
-      if(ifi->ifi_index == link->ifi.ifi_index)
-        return link;
-    });
+  pool_foreach (link, ns->netns.links, {
+    if (ifi->ifi_index == link->ifi.ifi_index)
+      return link;
+  })
+    ;
   return NULL;
 }
 
 static int
-ns_rcv_link(netns_p *ns, struct nlmsghdr *hdr)
+ns_rcv_link (netns_p *ns, struct nlmsghdr *hdr)
 {
   ns_link_t *link;
   struct ifinfomsg *ifi;
   struct rtattr *rtas[IFLA_MAX + 1] = {};
-  size_t datalen = hdr->nlmsg_len - NLMSG_ALIGN(sizeof(*hdr));
+  size_t datalen = hdr->nlmsg_len - NLMSG_ALIGN (sizeof (*hdr));
 
-  if(datalen < sizeof(*ifi))
+  if (datalen < sizeof (*ifi))
     return -1;
 
-  ifi = NLMSG_DATA(hdr);
-  if((datalen > NLMSG_ALIGN(sizeof(*ifi))) &&
-     rtnl_parse_rtattr(rtas, IFLA_MAX, IFLA_RTA(ifi),
-                       IFLA_PAYLOAD(hdr))) {
-    return -1;
-  }
+  ifi = NLMSG_DATA (hdr);
+  if ((datalen > NLMSG_ALIGN (sizeof (*ifi))) &&
+      rtnl_parse_rtattr (rtas, IFLA_MAX, IFLA_RTA (ifi), IFLA_PAYLOAD (hdr)))
+    {
+      return -1;
+    }
 #ifdef RTNL_CHECK
-  rtnl_entry_check(rtas, IFLA_MAX + 1, ns_ifmap, "link");
+  rtnl_entry_check (rtas, IFLA_MAX + 1, ns_ifmap, "link");
 #endif
 
-  link = ns_get_link(ns, ifi, rtas);
+  link = ns_get_link (ns, ifi, rtas);
 
-  if (hdr->nlmsg_type == RTM_DELLINK) {
-    if (!link)
-      return -1;
-    pool_put(ns->netns.links, link);
-    netns_notify(ns, link, NETNS_TYPE_LINK, NETNS_F_DEL);
-    return 0;
-  }
-
-  if (!link) {
-    pool_get(ns->netns.links, link);
-    rtnl_entry_set(link, rtas, ns_ifmap, 1);
-  } else {
-    rtnl_entry_set(link, rtas, ns_ifmap, 0);
-  }
+  if (hdr->nlmsg_type == RTM_DELLINK)
+    {
+      if (!link)
+	return -1;
+      pool_put (ns->netns.links, link);
+      netns_notify (ns, link, NETNS_TYPE_LINK, NETNS_F_DEL);
+      return 0;
+    }
+
+  if (!link)
+    {
+      pool_get (ns->netns.links, link);
+      rtnl_entry_set (link, rtas, ns_ifmap, 1);
+    }
+  else
+    {
+      rtnl_entry_set (link, rtas, ns_ifmap, 0);
+    }
 
   link->ifi = *ifi;
-  link->last_updated = vlib_time_now(vlib_get_main());
-  netns_notify(ns, link, NETNS_TYPE_LINK, NETNS_F_ADD);
+  link->last_updated = vlib_time_now (vlib_get_main ());
+  netns_notify (ns, link, NETNS_TYPE_LINK, NETNS_F_ADD);
   return 0;
 }
 
 static ns_route_t *
-ns_get_route(netns_p *ns, struct rtmsg *rtm, struct rtattr *rtas[])
+ns_get_route (netns_p *ns, struct rtmsg *rtm, struct rtattr *rtas[])
 {
   ns_route_t *route;
 
-  //This describes the values which uniquely identify a route
-  struct rtmsg msg = {
-    .rtm_family = 0xff,
-    .rtm_dst_len = 0xff,
-    .rtm_src_len = 0xff,
-    .rtm_table = 0xff,
-    .rtm_protocol = 0xff,
-    .rtm_type = 0xff
-  };
-
-  pool_foreach(route, ns->netns.routes, {
-      if(mask_match(&route->rtm, rtm, &msg, sizeof(struct rtmsg)) &&
-         rtnl_entry_match(route, rtas, ns_routemap))
-        return route;
-    });
+  // This describes the values which uniquely identify a route
+  struct rtmsg msg = { .rtm_family = 0xff,
+		       .rtm_dst_len = 0xff,
+		       .rtm_src_len = 0xff,
+		       .rtm_table = 0xff,
+		       .rtm_protocol = 0xff,
+		       .rtm_type = 0xff };
+
+  pool_foreach (route, ns->netns.routes, {
+    if (mask_match (&route->rtm, rtm, &msg, sizeof (struct rtmsg)) &&
+	rtnl_entry_match (route, rtas, ns_routemap))
+      return route;
+  })
+    ;
   return NULL;
 }
 
 static int
-ns_rcv_route(netns_p *ns, struct nlmsghdr *hdr)
+ns_rcv_route (netns_p *ns, struct nlmsghdr *hdr)
 {
   ns_route_t *route;
   struct rtmsg *rtm;
   struct rtattr *rtas[RTA_MAX + 1] = {};
-  size_t datalen = hdr->nlmsg_len - NLMSG_ALIGN(sizeof(*hdr));
+  size_t datalen = hdr->nlmsg_len - NLMSG_ALIGN (sizeof (*hdr));
 
-  if(datalen < sizeof(*rtm))
+  if (datalen < sizeof (*rtm))
     return -1;
 
-  rtm = NLMSG_DATA(hdr);
-  if((datalen > NLMSG_ALIGN(sizeof(*rtm))) &&
-     rtnl_parse_rtattr(rtas, RTA_MAX, RTM_RTA(rtm),
-                       RTM_PAYLOAD(hdr))) {
-    return -1;
-  }
+  rtm = NLMSG_DATA (hdr);
+  if ((datalen > NLMSG_ALIGN (sizeof (*rtm))) &&
+      rtnl_parse_rtattr (rtas, RTA_MAX, RTM_RTA (rtm), RTM_PAYLOAD (hdr)))
+    {
+      return -1;
+    }
 #ifdef RTNL_CHECK
-  rtnl_entry_check(rtas, RTA_MAX + 1, ns_routemap, "route");
+  rtnl_entry_check (rtas, RTA_MAX + 1, ns_routemap, "route");
 #endif
-  route = ns_get_route(ns, rtm, rtas);
+  route = ns_get_route (ns, rtm, rtas);
+
+  if (hdr->nlmsg_type == RTM_DELROUTE)
+    {
+      if (!route)
+	return -1;
+      pool_put (ns->netns.routes, route);
+      netns_notify (ns, route, NETNS_TYPE_ROUTE, NETNS_F_DEL);
+      return 0;
+    }
 
-  if (hdr->nlmsg_type == RTM_DELROUTE) {
-    if (!route)
-      return -1;
-    pool_put(ns->netns.routes, route);
-    netns_notify(ns, route, NETNS_TYPE_ROUTE, NETNS_F_DEL);
-    return 0;
-  }
-
-  if (!route) {
-    pool_get(ns->netns.routes, route);
-    memset(route, 0, sizeof(*route));
-    rtnl_entry_set(route, rtas, ns_routemap, 1);
-  } else {
-    rtnl_entry_set(route, rtas, ns_routemap, 0);
-  }
+  if (!route)
+    {
+      pool_get (ns->netns.routes, route);
+      memset (route, 0, sizeof (*route));
+      rtnl_entry_set (route, rtas, ns_routemap, 1);
+    }
+  else
+    {
+      rtnl_entry_set (route, rtas, ns_routemap, 0);
+    }
 
   route->rtm = *rtm;
-  route->last_updated = vlib_time_now(vlib_get_main());
-  netns_notify(ns, route, NETNS_TYPE_ROUTE, NETNS_F_ADD);
+  route->last_updated = vlib_time_now (vlib_get_main ());
+  netns_notify (ns, route, NETNS_TYPE_ROUTE, NETNS_F_ADD);
   return 0;
 }
 
 static ns_addr_t *
-ns_get_addr(netns_p *ns, struct ifaddrmsg *ifaddr, struct rtattr *rtas[])
+ns_get_addr (netns_p *ns, struct ifaddrmsg *ifaddr, struct rtattr *rtas[])
 {
   ns_addr_t *addr;
 
-  //This describes the values which uniquely identify a route
+  // This describes the values which uniquely identify a route
   struct ifaddrmsg msg = {
     .ifa_family = 0xff,
     .ifa_prefixlen = 0xff,
   };
 
-  pool_foreach(addr, ns->netns.addresses, {
-      if(mask_match(&addr->ifaddr, ifaddr, &msg, sizeof(struct ifaddrmsg)) &&
-         rtnl_entry_match(addr, rtas, ns_addrmap))
-        return addr;
-    });
+  pool_foreach (addr, ns->netns.addresses, {
+    if (mask_match (&addr->ifaddr, ifaddr, &msg, sizeof (struct ifaddrmsg)) &&
+	rtnl_entry_match (addr, rtas, ns_addrmap))
+      return addr;
+  })
+    ;
   return NULL;
 }
 
 static int
-ns_rcv_addr(netns_p *ns, struct nlmsghdr *hdr)
+ns_rcv_addr (netns_p *ns, struct nlmsghdr *hdr)
 {
   ns_addr_t *addr;
   struct ifaddrmsg *ifaddr;
   struct rtattr *rtas[IFA_MAX + 1] = {};
-  size_t datalen = hdr->nlmsg_len - NLMSG_ALIGN(sizeof(*hdr));
+  size_t datalen = hdr->nlmsg_len - NLMSG_ALIGN (sizeof (*hdr));
 
-  if(datalen < sizeof(*ifaddr))
+  if (datalen < sizeof (*ifaddr))
     return -1;
 
-  ifaddr = NLMSG_DATA(hdr);
-  if((datalen > NLMSG_ALIGN(sizeof(*ifaddr))) &&
-     rtnl_parse_rtattr(rtas, IFA_MAX, IFA_RTA(ifaddr),
-                       IFA_PAYLOAD(hdr))) {
-    return -1;
-  }
+  ifaddr = NLMSG_DATA (hdr);
+  if ((datalen > NLMSG_ALIGN (sizeof (*ifaddr))) &&
+      rtnl_parse_rtattr (rtas, IFA_MAX, IFA_RTA (ifaddr), IFA_PAYLOAD (hdr)))
+    {
+      return -1;
+    }
 #ifdef RTNL_CHECK
-  rtnl_entry_check(rtas, IFA_MAX + 1, ns_addrmap, "addr");
+  rtnl_entry_check (rtas, IFA_MAX + 1, ns_addrmap, "addr");
 #endif
-  addr = ns_get_addr(ns, ifaddr, rtas);
+  addr = ns_get_addr (ns, ifaddr, rtas);
+
+  if (hdr->nlmsg_type == RTM_DELADDR)
+    {
+      if (!addr)
+	return -1;
+      pool_put (ns->netns.addresses, addr);
+      netns_notify (ns, addr, NETNS_TYPE_ADDR, NETNS_F_DEL);
+      return 0;
+    }
 
-  if (hdr->nlmsg_type == RTM_DELADDR) {
-    if (!addr)
-      return -1;
-    pool_put(ns->netns.addresses, addr);
-    netns_notify(ns, addr, NETNS_TYPE_ADDR, NETNS_F_DEL);
-    return 0;
-  }
-
-  if (!addr) {
-    pool_get(ns->netns.addresses, addr);
-    memset(addr, 0, sizeof(*addr));
-    rtnl_entry_set(addr, rtas, ns_addrmap, 1);
-  } else {
-    rtnl_entry_set(addr, rtas, ns_addrmap, 0);
-  }
+  if (!addr)
+    {
+      pool_get (ns->netns.addresses, addr);
+      memset (addr, 0, sizeof (*addr));
+      rtnl_entry_set (addr, rtas, ns_addrmap, 1);
+    }
+  else
+    {
+      rtnl_entry_set (addr, rtas, ns_addrmap, 0);
+    }
 
   addr->ifaddr = *ifaddr;
-  addr->last_updated = vlib_time_now(vlib_get_main());
-  netns_notify(ns, addr, NETNS_TYPE_ADDR, NETNS_F_ADD);
+  addr->last_updated = vlib_time_now (vlib_get_main ());
+  netns_notify (ns, addr, NETNS_TYPE_ADDR, NETNS_F_ADD);
   return 0;
 }
 
 static ns_neigh_t *
-ns_get_neigh(netns_p *ns, struct ndmsg *nd, struct rtattr *rtas[])
+ns_get_neigh (netns_p *ns, struct ndmsg *nd, struct rtattr *rtas[])
 {
   ns_neigh_t *neigh;
 
-  //This describes the values which uniquely identify a route
+  // This describes the values which uniquely identify a route
   struct ndmsg msg = {
     .ndm_family = 0xff,
     .ndm_ifindex = 0xff,
   };
 
-  pool_foreach(neigh, ns->netns.neighbors, {
-      if(mask_match(&neigh->nd, nd, &msg, sizeof(&msg)) &&
-         rtnl_entry_match(neigh, rtas, ns_neighmap))
-        return neigh;
-    });
+  pool_foreach (neigh, ns->netns.neighbors, {
+    if (mask_match (&neigh->nd, nd, &msg, sizeof (&msg)) &&
+	rtnl_entry_match (neigh, rtas, ns_neighmap))
+      return neigh;
+  })
+    ;
   return NULL;
 }
 
 static int
-ns_rcv_neigh(netns_p *ns, struct nlmsghdr *hdr)
+ns_rcv_neigh (netns_p *ns, struct nlmsghdr *hdr)
 {
   ns_neigh_t *neigh;
   struct ndmsg *nd;
   struct rtattr *rtas[NDA_MAX + 1] = {};
-  size_t datalen = hdr->nlmsg_len - NLMSG_ALIGN(sizeof(*hdr));
+  size_t datalen = hdr->nlmsg_len - NLMSG_ALIGN (sizeof (*hdr));
 
-  if(datalen < sizeof(*nd))
+  if (datalen < sizeof (*nd))
     return -1;
 
-  nd = NLMSG_DATA(hdr);
-  if((datalen > NLMSG_ALIGN(sizeof(*nd))) &&
-     rtnl_parse_rtattr(rtas, NDA_MAX, NDA_RTA(nd),
-                       NDA_PAYLOAD(hdr))) {
-    return -1;
-  }
+  nd = NLMSG_DATA (hdr);
+  if ((datalen > NLMSG_ALIGN (sizeof (*nd))) &&
+      rtnl_parse_rtattr (rtas, NDA_MAX, NDA_RTA (nd), NDA_PAYLOAD (hdr)))
+    {
+      return -1;
+    }
 #ifdef RTNL_CHECK
-  rtnl_entry_check(rtas, NDA_MAX + 1, ns_neighmap, "nd");
+  rtnl_entry_check (rtas, NDA_MAX + 1, ns_neighmap, "nd");
 #endif
-  neigh = ns_get_neigh(ns, nd, rtas);
+  neigh = ns_get_neigh (ns, nd, rtas);
+
+  if (hdr->nlmsg_type == RTM_DELNEIGH)
+    {
+      if (!neigh)
+	return -1;
+      pool_put (ns->netns.neighbors, neigh);
+      netns_notify (ns, neigh, NETNS_TYPE_NEIGH, NETNS_F_DEL);
+      return 0;
+    }
 
-  if (hdr->nlmsg_type == RTM_DELNEIGH) {
-    if (!neigh)
-      return -1;
-    pool_put(ns->netns.neighbors, neigh);
-    netns_notify(ns, neigh, NETNS_TYPE_NEIGH, NETNS_F_DEL);
-    return 0;
-  }
-
-  if (!neigh) {
-    pool_get(ns->netns.neighbors, neigh);
-    memset(neigh, 0, sizeof(*neigh));
-    rtnl_entry_set(neigh, rtas, ns_neighmap, 1);
-  } else {
-    rtnl_entry_set(neigh, rtas, ns_neighmap, 0);
-  }
+  if (!neigh)
+    {
+      pool_get (ns->netns.neighbors, neigh);
+      memset (neigh, 0, sizeof (*neigh));
+      rtnl_entry_set (neigh, rtas, ns_neighmap, 1);
+    }
+  else
+    {
+      rtnl_entry_set (neigh, rtas, ns_neighmap, 0);
+    }
 
   neigh->nd = *nd;
-  neigh->last_updated = vlib_time_now(vlib_get_main());
-  netns_notify(ns, neigh, NETNS_TYPE_NEIGH, NETNS_F_ADD);
+  neigh->last_updated = vlib_time_now (vlib_get_main ());
+  netns_notify (ns, neigh, NETNS_TYPE_NEIGH, NETNS_F_ADD);
   return 0;
 }
 
-#define ns_object_foreach                       \
-  _(neighbors, NETNS_TYPE_NEIGH)                \
-  _(routes, NETNS_TYPE_ROUTE)                   \
-  _(addresses, NETNS_TYPE_ADDR)                 \
-  _(links, NETNS_TYPE_LINK)
+#define ns_object_foreach                                                     \
+  _ (neighbors, NETNS_TYPE_NEIGH)                                             \
+  _ (routes, NETNS_TYPE_ROUTE)                                                \
+  _ (addresses, NETNS_TYPE_ADDR)                                              \
+  _ (links, NETNS_TYPE_LINK)
 
 static void
-ns_recv_error(rtnl_error_t err, uword o)
+ns_recv_error (rtnl_error_t err, uword o)
 {
-  //An error was received. Reset everything.
+  // An error was received. Reset everything.
   netns_p *ns = &netns_main.netnss[o];
   u32 *indexes = 0;
   u32 *i = 0;
 
-#define _(pool, type)                                           \
-  pool_foreach_index(*i, ns->netns.pool, {                      \
-      vec_add1(indexes, *i);                                    \
-    })                                                          \
-    vec_foreach(i, indexes) {                                   \
-    pool_put_index(ns->netns.pool, *i);                         \
-    netns_notify(ns, &ns->netns.pool[*i], type, NETNS_F_DEL);   \
-  }                                                             \
-  vec_reset_length(indexes);
+#define _(pool, type)                                                         \
+  pool_foreach_index (*i, ns->netns.pool, { vec_add1 (indexes, *i); })        \
+    vec_foreach (i, indexes)                                                  \
+      {                                                                       \
+	pool_put_index (ns->netns.pool, *i);                                  \
+	netns_notify (ns, &ns->netns.pool[*i], type, NETNS_F_DEL);            \
+      }                                                                       \
+  vec_reset_length (indexes);
 
   ns_object_foreach
 
 #undef _
-    vec_free(indexes);
+    vec_free (indexes);
 }
 
 static void
-ns_recv_rtnl(struct nlmsghdr *hdr, uword o)
+ns_recv_rtnl (struct nlmsghdr *hdr, uword o)
 {
   netns_p *ns = &netns_main.netnss[o];
-  switch (hdr->nlmsg_type) {
-  case RTM_NEWROUTE:
-  case RTM_DELROUTE:
-    ns_rcv_route(ns, hdr);
-    break;
-  case RTM_NEWLINK:
-  case RTM_DELLINK:
-    ns_rcv_link(ns, hdr);
-    break;
-  case RTM_NEWADDR:
-  case RTM_DELADDR:
-    ns_rcv_addr(ns, hdr);
-    break;
-  case RTM_NEWNEIGH:
-  case RTM_DELNEIGH:
-    ns_rcv_neigh(ns, hdr);
-    break;
-  default:
-    clib_warning("unknown rtnl type %d", hdr->nlmsg_type);
-    break;
-  }
+  switch (hdr->nlmsg_type)
+    {
+    case RTM_NEWROUTE:
+    case RTM_DELROUTE:
+      ns_rcv_route (ns, hdr);
+      break;
+    case RTM_NEWLINK:
+    case RTM_DELLINK:
+      ns_rcv_link (ns, hdr);
+      break;
+    case RTM_NEWADDR:
+    case RTM_DELADDR:
+      ns_rcv_addr (ns, hdr);
+      break;
+    case RTM_NEWNEIGH:
+    case RTM_DELNEIGH:
+      ns_rcv_neigh (ns, hdr);
+      break;
+    default:
+      clib_warning ("unknown rtnl type %d", hdr->nlmsg_type);
+      break;
+    }
 }
 
 static void
-netns_destroy(netns_p *ns)
+netns_destroy (netns_p *ns)
 {
   netns_main_t *nm = &netns_main;
-  rtnl_stream_close(ns->rtnl_handle);
-  pool_put(nm->netnss, ns);
-  pool_free(ns->netns.links);
-  pool_free(ns->netns.addresses);
-  pool_free(ns->netns.routes);
-  pool_free(ns->netns.neighbors);
+  rtnl_stream_close (ns->rtnl_handle);
+  pool_put (nm->netnss, ns);
+  pool_free (ns->netns.links);
+  pool_free (ns->netns.addresses);
+  pool_free (ns->netns.routes);
+  pool_free (ns->netns.neighbors);
 }
 
 static netns_p *
-netns_get(char *name)
+netns_get (char *name)
 {
   netns_main_t *nm = &netns_main;
   netns_p *ns;
-  pool_foreach(ns, nm->netnss, {
-      if (!strcmp(name, ns->netns.name))
-        return ns;
-    });
+  pool_foreach (ns, nm->netnss, {
+    if (!strcmp (name, ns->netns.name))
+      return ns;
+  })
+    ;
 
-  if (strlen(name) > RTNL_NETNS_NAMELEN)
+  if (strlen (name) > RTNL_NETNS_NAMELEN)
     return NULL;
 
-  pool_get(nm->netnss, ns);
+  pool_get (nm->netnss, ns);
   rtnl_stream_t s = {
     .recv_message = ns_recv_rtnl,
     .error = ns_recv_error,
-    .opaque = (uword)(ns - nm->netnss),
+    .opaque = (uword) (ns - nm->netnss),
   };
-  strcpy(s.name, name);
+  int rc = strcpy_s (s.name, sizeof (s.name), name);
+  if (rc != EOK)
+    return NULL;
 
   u32 handle;
-  if ((handle = rtnl_stream_open(&s)) == ~0) {
-    pool_put(nm->netnss, ns);
-    return NULL;
-  }
+  if ((handle = rtnl_stream_open (&s)) == ~0)
+    {
+      pool_put (nm->netnss, ns);
+      return NULL;
+    }
 
-  strcpy(ns->netns.name, name);
+  rc = strcpy_s (ns->netns.name, sizeof (ns->netns.name), name);
+  if (rc != EOK)
+    return NULL;
   ns->netns.addresses = 0;
   ns->netns.links = 0;
   ns->netns.neighbors = 0;
@@ -691,15 +737,16 @@ netns_get(char *name)
   return ns;
 }
 
-u32 netns_open(char *name, netns_sub_t *sub)
+u32
+netns_open (char *name, netns_sub_t *sub)
 {
   netns_main_t *nm = &netns_main;
   netns_p *ns;
   netns_handle_t *p;
-  if (!(ns = netns_get(name)))
+  if (!(ns = netns_get (name)))
     return ~0;
 
-  pool_get(nm->handles, p);
+  pool_get (nm->handles, p);
   p->netns_index = ns - nm->netnss;
   p->notify = sub->notify;
   p->opaque = sub->opaque;
@@ -707,76 +754,82 @@ u32 netns_open(char *name, netns_sub_t *sub)
   return p - nm->handles;
 }
 
-netns_t *netns_getns(u32 handle)
+netns_t *
+netns_getns (u32 handle)
 {
   netns_main_t *nm = &netns_main;
-  netns_handle_t *h = pool_elt_at_index(nm->handles, handle);
-  netns_p *ns = pool_elt_at_index(nm->netnss, h->netns_index);
+  netns_handle_t *h = pool_elt_at_index (nm->handles, handle);
+  netns_p *ns = pool_elt_at_index (nm->netnss, h->netns_index);
   return &ns->netns;
 }
 
-void netns_close(u32 handle)
+void
+netns_close (u32 handle)
 {
   netns_main_t *nm = &netns_main;
-  netns_handle_t *h = pool_elt_at_index(nm->handles, handle);
-  netns_p *ns = pool_elt_at_index(nm->netnss, h->netns_index);
-  pool_put(h, nm->handles);
+  netns_handle_t *h = pool_elt_at_index (nm->handles, handle);
+  netns_p *ns = pool_elt_at_index (nm->netnss, h->netns_index);
+  pool_put (h, nm->handles);
   ns->subscriber_count--;
   if (!ns->subscriber_count)
-    netns_destroy(ns);
+    netns_destroy (ns);
 }
 
-void netns_callme(u32 handle, char del)
+void
+netns_callme (u32 handle, char del)
 {
   netns_main_t *nm = &netns_main;
-  netns_handle_t *h = pool_elt_at_index(nm->handles, handle);
-  netns_p *ns = pool_elt_at_index(nm->netnss, h->netns_index);
+  netns_handle_t *h = pool_elt_at_index (nm->handles, handle);
+  netns_p *ns = pool_elt_at_index (nm->netnss, h->netns_index);
   u32 i = 0;
   if (!h->notify)
     return;
 
-#define _(pool, type)                                           \
-  pool_foreach_index(i, ns->netns.pool, {                       \
-      h->notify(&ns->netns.pool[i], type,                       \
-                del?NETNS_F_DEL:NETNS_F_ADD, h->opaque);        \
-    });
+#define _(pool, type)                                                         \
+  pool_foreach_index (i, ns->netns.pool, {                                    \
+    h->notify (&ns->netns.pool[i], type, del ? NETNS_F_DEL : NETNS_F_ADD,     \
+	       h->opaque);                                                    \
+  })                                                                          \
+    ;
 
   ns_object_foreach
 #undef _
+}
 
+u8 *
+format_ns_object (u8 *s, va_list *args)
+{
+  netns_type_t t = va_arg (*args, netns_type_t);
+  void *o = va_arg (*args, void *);
+  switch (t)
+    {
+    case NETNS_TYPE_ADDR:
+      return format (s, "addr %U", format_ns_addr, o);
+    case NETNS_TYPE_ROUTE:
+      return format (s, "route %U", format_ns_route, o);
+    case NETNS_TYPE_LINK:
+      return format (s, "link %U", format_ns_link, o);
+    case NETNS_TYPE_NEIGH:
+      return format (s, "neigh %U", format_ns_neigh, o);
     }
-
-u8 *format_ns_object(u8 *s, va_list *args)
-{
-  netns_type_t t = va_arg(*args, netns_type_t);
-  void *o = va_arg(*args, void *);
-  switch (t) {
-  case NETNS_TYPE_ADDR:
-    return format(s, "addr %U", format_ns_addr, o);
-  case NETNS_TYPE_ROUTE:
-    return format(s, "route %U", format_ns_route, o);
-  case NETNS_TYPE_LINK:
-    return format(s, "link %U", format_ns_link, o);
-  case NETNS_TYPE_NEIGH:
-    return format(s, "neigh %U", format_ns_neigh, o);
-  }
   return s;
 }
 
-u8 *format_ns_flags(u8 *s, va_list *args)
+u8 *
+format_ns_flags (u8 *s, va_list *args)
 {
-  u32 flags = va_arg(*args, u32);
+  u32 flags = va_arg (*args, u32);
   if (flags & NETNS_F_ADD)
-    s = format(s, "add");
+    s = format (s, "add");
   else if (flags & NETNS_F_DEL)
-    s = format(s, "del");
+    s = format (s, "del");
   else
-    s = format(s, "mod");
+    s = format (s, "mod");
   return s;
 }
 
 clib_error_t *
-netns_init (vlib_main_t * vm)
+netns_init (vlib_main_t *vm)
 {
   netns_main_t *nm = &netns_main;
   nm->netnss = 0;
diff --git a/extras/router-plugin/devices/rtnetlink/netns.h b/extras/router-plugin/devices/rtnetlink/netns.h
index 53effe5ce..b94356c3b 100644
--- a/extras/router-plugin/devices/rtnetlink/netns.h
+++ b/extras/router-plugin/devices/rtnetlink/netns.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -18,10 +18,10 @@
 
 #include <vlib/vlib.h>
 
-#include <sys/socket.h>
-#include <linux/rtnetlink.h>
 #include <linux/netlink.h>
+#include <linux/rtnetlink.h>
 #include <net/if.h>
+#include <sys/socket.h>
 
 #include "rtnl.h"
 
@@ -30,7 +30,8 @@
 /*so far depth is fixed, looking into ways to be dynamic*/
 #define MPLS_STACK_DEPTH 7
 
-typedef struct {
+typedef struct
+{
   struct ifinfomsg ifi;
   u8 hwaddr[IFHWADDRLEN];
   u8 broadcast[IFHWADDRLEN];
@@ -38,11 +39,13 @@ typedef struct {
   u32 mtu;
   u32 master;
   u8 qdisc[IFNAMSIZ];
-  struct rtnl_link_stats stats; //This struct is big and only comes as a response to a request
+  struct rtnl_link_stats
+    stats; // This struct is big and only comes as a response to a request
   f64 last_updated;
 } ns_link_t;
 
-typedef struct {
+typedef struct
+{
   struct rtmsg rtm;
   u8 dst[16];
   u8 src[16];
@@ -58,7 +61,8 @@ typedef struct {
   f64 last_updated;
 } ns_route_t;
 
-typedef struct {
+typedef struct
+{
   struct ifaddrmsg ifaddr;
   u8 addr[16];
   u8 local[16];
@@ -69,7 +73,8 @@ typedef struct {
   f64 last_updated;
 } ns_addr_t;
 
-typedef struct {
+typedef struct
+{
   struct ndmsg nd;
   u8 dst[16];
   u8 lladdr[IFHWADDRLEN];
@@ -78,28 +83,30 @@ typedef struct {
   f64 last_updated;
 } ns_neigh_t;
 
-typedef struct {
+typedef struct
+{
   char name[RTNL_NETNS_NAMELEN + 1];
-  ns_link_t  *links;
+  ns_link_t *links;
   ns_route_t *routes;
-  ns_addr_t  *addresses;
+  ns_addr_t *addresses;
   ns_neigh_t *neighbors;
 } netns_t;
 
-
-typedef enum {
+typedef enum
+{
   NETNS_TYPE_LINK,
   NETNS_TYPE_ROUTE,
   NETNS_TYPE_ADDR,
   NETNS_TYPE_NEIGH,
 } netns_type_t;
 
-//Flags used in notification functions call
-#define NETNS_F_ADD    0x01
-#define NETNS_F_DEL    0x02
+// Flags used in notification functions call
+#define NETNS_F_ADD 0x01
+#define NETNS_F_DEL 0x02
 
-typedef struct {
-  void (*notify)(void *obj, netns_type_t type, u32 flags, uword opaque);
+typedef struct
+{
+  void (*notify) (void *obj, netns_type_t type, u32 flags, uword opaque);
   uword opaque;
 } netns_sub_t;
 
@@ -110,36 +117,36 @@ typedef struct {
  * existing routes (This is to protect against
  * synch. Vs asynch. issues).
  */
-u32 netns_open(char *name, netns_sub_t *sub);
+u32 netns_open (char *name, netns_sub_t *sub);
 
 /*
  * Retrieves the namespace structure associated with a
  * given namespace handler.
  */
-netns_t *netns_getns(u32 handle);
+netns_t *netns_getns (u32 handle);
 
 /*
  * Terminates a subscriber session.
  */
-void netns_close(u32 handle);
+void netns_close (u32 handle);
 
 /*
  * Calls the callback associated with the handle
  * for all existing objects with the flags
  * set to (del?NETNS_F_DEL:NETNS_F_ADD).
  */
-void netns_callme(u32 handle, char del);
+void netns_callme (u32 handle, char del);
 
 /*
  * netns struct format functions.
  * Taking the struct as single argument.
  */
-u8 *format_ns_neigh(u8 *s, va_list *args);
-u8 *format_ns_addr(u8 *s, va_list *args);
-u8 *format_ns_route(u8 *s, va_list *args);
-u8 *format_ns_link(u8 *s, va_list *args);
+u8 *format_ns_neigh (u8 *s, va_list *args);
+u8 *format_ns_addr (u8 *s, va_list *args);
+u8 *format_ns_route (u8 *s, va_list *args);
+u8 *format_ns_link (u8 *s, va_list *args);
 
-u8 *format_ns_object(u8 *s, va_list *args);
-u8 *format_ns_flags(u8 *s, va_list *args);
+u8 *format_ns_object (u8 *s, va_list *args);
+u8 *format_ns_flags (u8 *s, va_list *args);
 
 #endif
diff --git a/extras/router-plugin/devices/rtnetlink/rtnl.c b/extras/router-plugin/devices/rtnetlink/rtnl.c
index ed3db9e72..9c4757b17 100644
--- a/extras/router-plugin/devices/rtnetlink/rtnl.c
+++ b/extras/router-plugin/devices/rtnetlink/rtnl.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,20 +16,20 @@
 #define _GNU_SOURCE
 #include <sched.h>
 
-#include <vlib/vlib.h>
 #include <vlib/unix/unix.h>
+#include <vlib/vlib.h>
 #include <vppinfra/error.h>
 
-#include <sys/socket.h>
+#include <fcntl.h>
+#include <float.h>
 #include <linux/netlink.h>
 #include <linux/rtnetlink.h>
-#include <float.h>
-#include <fcntl.h>
+#include <sys/socket.h>
 
-#include <sys/types.h>
-#include <sys/wait.h>
 #include <errno.h>
 #include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
 
 #include "netns.h"
 #include "rtnl.h"
@@ -37,19 +37,22 @@
 #undef DBL_MAX
 #define DBL_MAX 1000000000.0
 
-typedef enum {
+typedef enum
+{
   RTNL_E_OPEN,
   RTNL_E_CLOSE,
   RTNL_E_READ,
 } rtnl_event_t;
 
-typedef enum {
+typedef enum
+{
   RTNL_S_INIT,
   RTNL_S_SYNC,
   RTNL_S_READY,
 } rtnl_state_t;
 
-typedef enum {
+typedef enum
+{
   RTNL_SS_OPENING,
   RTNL_SS_LINK,
   RTNL_SS_ADDR,
@@ -58,7 +61,8 @@ typedef enum {
   RTNL_SS_NEIGH,
 } rtnl_sync_state_t;
 
-typedef struct {
+typedef struct
+{
   rtnl_stream_t stream;
   rtnl_state_t state;
   rtnl_sync_state_t sync_state;
@@ -69,7 +73,8 @@ typedef struct {
   f64 timeout;
 } rtnl_ns_t;
 
-typedef struct {
+typedef struct
+{
   f64 now;
   rtnl_ns_t *streams;
 } rtnl_main_t;
@@ -77,204 +82,227 @@ typedef struct {
 static rtnl_main_t rtnl_main;
 static vlib_node_registration_t rtnl_process_node;
 
-#define RTNL_BUFFSIZ 16384
+#define RTNL_BUFFSIZ	  16384
 #define RTNL_DUMP_TIMEOUT 1
 
-static inline u32 grpmask(u32 g)
+static inline u32
+grpmask (u32 g)
 {
   ASSERT (g <= 31);
-  if (g) {
-    return 1 << (g - 1);
-  } else
+  if (g)
+    {
+      return 1 << (g - 1);
+    }
+  else
     return 0;
 }
 
-
-u8 *format_rtnl_nsname2path(u8 *s, va_list *args)
+u8 *
+format_rtnl_nsname2path (u8 *s, va_list *args)
 {
-  char *nsname = va_arg(*args, char *);
-  if (!nsname || !strlen(nsname)) {
-    return format(s, "/proc/self/ns/net");
-  } else if (strpbrk(nsname, "/") != NULL) {
-    return format(s, "%s", nsname);
-  } else {
-    return format(s, "/var/run/netns/%s", nsname);
-  }
+  char *nsname = va_arg (*args, char *);
+  if (!nsname || !strlen (nsname))
+    {
+      return format (s, "/proc/self/ns/net");
+    }
+  else if (strpbrk (nsname, "/") != NULL)
+    {
+      return format (s, "%s", nsname);
+    }
+  else
+    {
+      return format (s, "/var/run/netns/%s", nsname);
+    }
 }
 
 static_always_inline void
-rtnl_schedule_timeout(rtnl_ns_t *ns, f64 when)
+rtnl_schedule_timeout (rtnl_ns_t *ns, f64 when)
 {
   ns->timeout = when;
 }
 
 static_always_inline void
-rtnl_cancel_timeout(rtnl_ns_t *ns)
+rtnl_cancel_timeout (rtnl_ns_t *ns)
 {
   ns->timeout = DBL_MAX;
 }
 
-static clib_error_t *rtnl_read_cb(struct clib_file * f)
+static clib_error_t *
+rtnl_read_cb (struct clib_file *f)
 {
   rtnl_main_t *rm = &rtnl_main;
-  vlib_main_t *vm = vlib_get_main();
+  vlib_main_t *vm = vlib_get_main ();
   rtnl_ns_t *ns = &rm->streams[f->private_data];
-  vlib_process_signal_event(vm, rtnl_process_node.index, RTNL_E_READ, (uword)(ns - rm->streams));
+  vlib_process_signal_event (vm, rtnl_process_node.index, RTNL_E_READ,
+			     (uword) (ns - rm->streams));
   return 0;
 }
 
-int rtnl_dump_request(rtnl_ns_t *ns, int type, void *req, size_t len)
+int
+rtnl_dump_request (rtnl_ns_t *ns, int type, void *req, size_t len)
 {
   struct sockaddr_nl nladdr = { .nl_family = AF_NETLINK };
   struct nlmsghdr nlh = {
-    .nlmsg_len = NLMSG_LENGTH(len),
+    .nlmsg_len = NLMSG_LENGTH (len),
     .nlmsg_type = type,
-    .nlmsg_flags = NLM_F_DUMP|NLM_F_REQUEST,
+    .nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
     .nlmsg_pid = 0,
     .nlmsg_seq = ++ns->rtnl_seq,
   };
-  struct iovec iov[2] = {
-    { .iov_base = &nlh, .iov_len = sizeof(nlh) },
-    { .iov_base = req, .iov_len = len }
-  };
+  struct iovec iov[2] = { { .iov_base = &nlh, .iov_len = sizeof (nlh) },
+			  { .iov_base = req, .iov_len = len } };
   struct msghdr msg = {
     .msg_name = &nladdr,
-    .msg_namelen =  sizeof(nladdr),
+    .msg_namelen = sizeof (nladdr),
     .msg_iov = iov,
     .msg_iovlen = 2,
   };
-  if(sendmsg(ns->rtnl_socket, &msg, 0) < 0) {
-    clib_warning("sendmsg error: %s", strerror(errno));
-    return -1;
-  }
+  if (sendmsg (ns->rtnl_socket, &msg, 0) < 0)
+    {
+      clib_warning ("sendmsg error: %s", strerror (errno));
+      return -1;
+    }
   return 0;
 }
 
-static void rtnl_socket_close(rtnl_ns_t *ns)
+static void
+rtnl_socket_close (rtnl_ns_t *ns)
 {
-  clib_file_del(&file_main, &file_main.file_pool[ns->unix_index]);
-  close(ns->rtnl_socket);
+  clib_file_del (&file_main, &file_main.file_pool[ns->unix_index]);
+  close (ns->rtnl_socket);
 }
 
-struct rtnl_thread_exec {
+struct rtnl_thread_exec
+{
   int fd;
-  void *(*fn)(void *);
+  void *(*fn) (void *);
   void *arg;
   void **ret;
 };
 
-static void *rtnl_exec_in_thread_fn(void *p)
+static void *
+rtnl_exec_in_thread_fn (void *p)
 {
   struct rtnl_thread_exec *ex = (struct rtnl_thread_exec *) p;
-  if (setns(ex->fd, 0))
+  if (setns (ex->fd, 0))
     return (void *) ((uword) (-errno));
 
-  *ex->ret = ex->fn(ex->arg);
+  *ex->ret = ex->fn (ex->arg);
   return NULL;
 }
 
-static int rtnl_exec_in_namespace_byfd(int fd, void *(*fn)(void *), void *arg, void **ret)
+static int
+rtnl_exec_in_namespace_byfd (int fd, void *(*fn) (void *), void *arg,
+			     void **ret)
 {
   pthread_t thread;
   void *thread_ret;
-  struct rtnl_thread_exec ex = {
-    .fd = fd,
-    .fn = fn,
-    .arg = arg,
-    .ret = ret
-  };
-  if(pthread_create(&thread, NULL, rtnl_exec_in_thread_fn, &ex))
+  struct rtnl_thread_exec ex = { .fd = fd, .fn = fn, .arg = arg, .ret = ret };
+  if (pthread_create (&thread, NULL, rtnl_exec_in_thread_fn, &ex))
     return -errno;
 
-  if(pthread_join(thread, &thread_ret))
+  if (pthread_join (thread, &thread_ret))
     return -errno;
 
   if (thread_ret)
-    return (int) ((uword)thread_ret);
+    return (int) ((uword) thread_ret);
 
   return 0;
 }
 
-int rtnl_exec_in_namespace(u32 stream_index, void *(*fn)(void *), void *arg, void **ret)
+int
+rtnl_exec_in_namespace (u32 stream_index, void *(*fn) (void *), void *arg,
+			void **ret)
 {
   rtnl_main_t *rm = &rtnl_main;
-  if (pool_is_free_index(rm->streams, stream_index))
+  if (pool_is_free_index (rm->streams, stream_index))
     return -EBADR;
 
-  rtnl_ns_t *ns = pool_elt_at_index(rm->streams, stream_index);
-  return rtnl_exec_in_namespace_byfd(ns->ns_fd, fn, arg, ret);
+  rtnl_ns_t *ns = pool_elt_at_index (rm->streams, stream_index);
+  return rtnl_exec_in_namespace_byfd (ns->ns_fd, fn, arg, ret);
 }
 
-int rtnl_exec_in_namespace_by_name(char *nsname, void *(*fn)(void *), void *arg, void **ret)
+int
+rtnl_exec_in_namespace_by_name (char *nsname, void *(*fn) (void *), void *arg,
+				void **ret)
 {
   int fd;
-  u8 *s = format((u8 *)0, "%U", format_rtnl_nsname2path, nsname);
+  u8 *s = format ((u8 *) 0, "%U", format_rtnl_nsname2path, nsname);
 
-  if ((fd = open((char *)s, O_RDONLY)) < 0) {
-    vec_free(s);
-    return -errno;
-  }
+  if ((fd = open ((char *) s, O_RDONLY)) < 0)
+    {
+      vec_free (s);
+      return -errno;
+    }
 
-  int r = rtnl_exec_in_namespace_byfd(fd, fn, arg, ret);
-  vec_free(s);
-  close(fd);
+  int r = rtnl_exec_in_namespace_byfd (fd, fn, arg, ret);
+  vec_free (s);
+  close (fd);
   return r;
 }
 
 /* this function is run by the second thread */
-static void *rtnl_thread_fn(void *p)
+static void *
+rtnl_thread_fn (void *p)
 {
   rtnl_ns_t *ns = (rtnl_ns_t *) p;
-  if (setns(ns->ns_fd, 0)) {
-    clib_warning("setns(%d, %d) error %d", ns->ns_fd, CLONE_NEWNET, errno);
-    return (void *) -1;
-  }
+  if (setns (ns->ns_fd, 0))
+    {
+      clib_warning ("setns(%d, %d) error %d", ns->ns_fd, CLONE_NEWNET, errno);
+      return (void *) -1;
+    }
 
-  if ((ns->rtnl_socket = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) == -1) {
-    clib_warning("Cannot open socket");
-    return (void *) -2;
-  }
+  if ((ns->rtnl_socket = socket (AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) == -1)
+    {
+      clib_warning ("Cannot open socket");
+      return (void *) -2;
+    }
 
   return NULL;
 }
 
-static int rtnl_socket_open(rtnl_ns_t *ns)
+static int
+rtnl_socket_open (rtnl_ns_t *ns)
 {
   rtnl_main_t *rm = &rtnl_main;
   pthread_t thread;
   void *thread_ret;
-  if(pthread_create(&thread, NULL, rtnl_thread_fn, ns)) {
-    clib_warning("Can't create opening thread");
-    return -1;
-  }
+  if (pthread_create (&thread, NULL, rtnl_thread_fn, ns))
+    {
+      clib_warning ("Can't create opening thread");
+      return -1;
+    }
 
-  if(pthread_join(thread, &thread_ret)) {
-    clib_warning("Can't join opening thread");
-    return -2;
-  }
+  if (pthread_join (thread, &thread_ret))
+    {
+      clib_warning ("Can't join opening thread");
+      return -2;
+    }
 
-  if (thread_ret) {
-    clib_warning("Could not open netlink socket");
-    return -3;
-  }
+  if (thread_ret)
+    {
+      clib_warning ("Could not open netlink socket");
+      return -3;
+    }
 
   struct sockaddr_nl addr = {
     .nl_family = AF_NETLINK,
     .nl_pad = 0,
     .nl_pid = 0,
     /*add mpls message group*/
-    .nl_groups = grpmask(RTNLGRP_LINK)| grpmask(RTNLGRP_IPV6_IFADDR) |
-    grpmask(RTNLGRP_IPV4_IFADDR) | grpmask(RTNLGRP_IPV4_ROUTE) |
-    grpmask(RTNLGRP_IPV6_ROUTE) | grpmask(RTNLGRP_NEIGH) |
-    grpmask(RTNLGRP_NOTIFY) /* | grpmask(RTNLGRP_MPLS_ROUTE)*/,
+    .nl_groups = grpmask (RTNLGRP_LINK) | grpmask (RTNLGRP_IPV6_IFADDR) |
+		 grpmask (RTNLGRP_IPV4_IFADDR) | grpmask (RTNLGRP_IPV4_ROUTE) |
+		 grpmask (RTNLGRP_IPV6_ROUTE) | grpmask (RTNLGRP_NEIGH) |
+		 grpmask (RTNLGRP_NOTIFY) /* | grpmask(RTNLGRP_MPLS_ROUTE)*/,
   };
 
-  if (bind(ns->rtnl_socket, (struct sockaddr*) &addr, sizeof(addr))) {
-    close(ns->rtnl_socket);
-    return -3;
-  }
+  if (bind (ns->rtnl_socket, (struct sockaddr *) &addr, sizeof (addr)))
+    {
+      close (ns->rtnl_socket);
+      return -3;
+    }
 
-  clib_file_t template = {0};
+  clib_file_t template = { 0 };
   template.read_function = rtnl_read_cb;
   template.file_descriptor = ns->rtnl_socket;
   template.private_data = (uword) (ns - rm->streams);
@@ -283,11 +311,11 @@ static int rtnl_socket_open(rtnl_ns_t *ns)
 }
 
 static int
-rtnl_rcv_error(rtnl_ns_t *ns, struct nlmsghdr *hdr, int *error)
+rtnl_rcv_error (rtnl_ns_t *ns, struct nlmsghdr *hdr, int *error)
 {
-  struct nlmsgerr *err = NLMSG_DATA(hdr);
-  size_t datalen = hdr->nlmsg_len - NLMSG_ALIGN(sizeof(*hdr));
-  if(datalen < sizeof(*err))
+  struct nlmsgerr *err = NLMSG_DATA (hdr);
+  size_t datalen = hdr->nlmsg_len - NLMSG_ALIGN (sizeof (*hdr));
+  if (datalen < sizeof (*err))
     return -1;
 
   *error = err->error;
@@ -295,142 +323,152 @@ rtnl_rcv_error(rtnl_ns_t *ns, struct nlmsghdr *hdr, int *error)
 }
 
 static void
-rtnl_sync_reset(rtnl_ns_t *ns)
+rtnl_sync_reset (rtnl_ns_t *ns)
 {
   if (ns->sync_state == RTNL_SS_OPENING)
     return;
 
-  rtnl_socket_close(ns);
+  rtnl_socket_close (ns);
   ns->sync_state = RTNL_SS_OPENING;
 }
 
 static void
-rtnl_sync_done(rtnl_ns_t *ns)
+rtnl_sync_done (rtnl_ns_t *ns)
 {
   rtnl_main_t *rm = &rtnl_main;
   struct ifaddrmsg addrmsg;
   struct rtmsg rtmsg;
   struct ndmsg ndmsg;
-  switch (ns->sync_state) {
-  case RTNL_SS_OPENING:
-    //Cannot happen here
-    break;
-  case RTNL_SS_LINK:
-    memset(&addrmsg, 0, sizeof(addrmsg));
-    addrmsg.ifa_family = AF_UNSPEC;
-    if(rtnl_dump_request(ns, RTM_GETADDR, &addrmsg, sizeof(addrmsg))) {
-      rtnl_sync_reset(ns);
-      rtnl_schedule_timeout(ns, rm->now + 1);
-      return;
-    }
-    rtnl_schedule_timeout(ns, rm->now + RTNL_DUMP_TIMEOUT);
-    ns->sync_state = RTNL_SS_ADDR;
-    break;
-  case RTNL_SS_ADDR:
-  case RTNL_SS_ROUTE4:
-    memset(&rtmsg, 0, sizeof(rtmsg));
-    rtmsg.rtm_family = (ns->sync_state == RTNL_SS_ADDR)?AF_INET:AF_INET6;
-    rtmsg.rtm_table = RT_TABLE_UNSPEC;
-    if(rtnl_dump_request(ns, RTM_GETROUTE, &rtmsg, sizeof(rtmsg))) {
-      rtnl_sync_reset(ns);
-      rtnl_schedule_timeout(ns, rm->now + 1);
-      return;
+  switch (ns->sync_state)
+    {
+    case RTNL_SS_OPENING:
+      // Cannot happen here
+      break;
+    case RTNL_SS_LINK:
+      memset (&addrmsg, 0, sizeof (addrmsg));
+      addrmsg.ifa_family = AF_UNSPEC;
+      if (rtnl_dump_request (ns, RTM_GETADDR, &addrmsg, sizeof (addrmsg)))
+	{
+	  rtnl_sync_reset (ns);
+	  rtnl_schedule_timeout (ns, rm->now + 1);
+	  return;
+	}
+      rtnl_schedule_timeout (ns, rm->now + RTNL_DUMP_TIMEOUT);
+      ns->sync_state = RTNL_SS_ADDR;
+      break;
+    case RTNL_SS_ADDR:
+    case RTNL_SS_ROUTE4:
+      memset (&rtmsg, 0, sizeof (rtmsg));
+      rtmsg.rtm_family = (ns->sync_state == RTNL_SS_ADDR) ? AF_INET : AF_INET6;
+      rtmsg.rtm_table = RT_TABLE_UNSPEC;
+      if (rtnl_dump_request (ns, RTM_GETROUTE, &rtmsg, sizeof (rtmsg)))
+	{
+	  rtnl_sync_reset (ns);
+	  rtnl_schedule_timeout (ns, rm->now + 1);
+	  return;
+	}
+      rtnl_schedule_timeout (ns, rm->now + RTNL_DUMP_TIMEOUT);
+      ns->sync_state =
+	(ns->sync_state == RTNL_SS_ADDR) ? RTNL_SS_ROUTE4 : RTNL_SS_ROUTE6;
+      break;
+    case RTNL_SS_ROUTE6:
+      memset (&ndmsg, 0, sizeof (ndmsg));
+      ndmsg.ndm_family = AF_UNSPEC;
+      if (rtnl_dump_request (ns, RTM_GETNEIGH, &ndmsg, sizeof (ndmsg)))
+	{
+	  rtnl_sync_reset (ns);
+	  rtnl_schedule_timeout (ns, rm->now + 1);
+	  return;
+	}
+      rtnl_schedule_timeout (ns, rm->now + RTNL_DUMP_TIMEOUT);
+      ns->sync_state = RTNL_SS_NEIGH;
+      break;
+    case RTNL_SS_NEIGH:
+      ns->state = RTNL_S_READY;
+      ns->sync_state = 0;
+      rtnl_cancel_timeout (ns);
+      break;
     }
-    rtnl_schedule_timeout(ns, rm->now + RTNL_DUMP_TIMEOUT);
-    ns->sync_state = (ns->sync_state == RTNL_SS_ADDR)?RTNL_SS_ROUTE4:RTNL_SS_ROUTE6;
-    break;
-  case RTNL_SS_ROUTE6:
-    memset(&ndmsg, 0, sizeof(ndmsg));
-    ndmsg.ndm_family = AF_UNSPEC;
-    if(rtnl_dump_request(ns, RTM_GETNEIGH, &ndmsg, sizeof(ndmsg))) {
-      rtnl_sync_reset(ns);
-      rtnl_schedule_timeout(ns, rm->now + 1);
-      return;
-    }
-    rtnl_schedule_timeout(ns, rm->now + RTNL_DUMP_TIMEOUT);
-    ns->sync_state = RTNL_SS_NEIGH;
-    break;
-  case RTNL_SS_NEIGH:
-    ns->state = RTNL_S_READY;
-    ns->sync_state = 0;
-    rtnl_cancel_timeout(ns);
-    break;
-  }
 }
 
 static void
-rtnl_sync_timeout(rtnl_ns_t *ns)
+rtnl_sync_timeout (rtnl_ns_t *ns)
 {
   rtnl_main_t *rm = &rtnl_main;
   struct ifinfomsg imsg = {};
-  switch (ns->sync_state) {
-  case RTNL_SS_OPENING:
-    if (rtnl_socket_open(ns)) {
-      rtnl_schedule_timeout(ns, rm->now + 10);
-      return;
-    }
-    imsg.ifi_family = AF_UNSPEC;
-    if (rtnl_dump_request(ns, RTM_GETLINK, &imsg, sizeof(imsg))) {
-      rtnl_sync_reset(ns);
-      rtnl_schedule_timeout(ns, rm->now + 10);
+  switch (ns->sync_state)
+    {
+    case RTNL_SS_OPENING:
+      if (rtnl_socket_open (ns))
+	{
+	  rtnl_schedule_timeout (ns, rm->now + 10);
+	  return;
+	}
+      imsg.ifi_family = AF_UNSPEC;
+      if (rtnl_dump_request (ns, RTM_GETLINK, &imsg, sizeof (imsg)))
+	{
+	  rtnl_sync_reset (ns);
+	  rtnl_schedule_timeout (ns, rm->now + 10);
+	}
+      ns->sync_state = RTNL_SS_LINK;
+      rtnl_schedule_timeout (ns, rm->now + 2);
+      break;
+    case RTNL_SS_LINK:
+    case RTNL_SS_ADDR:
+    case RTNL_SS_ROUTE4:
+    case RTNL_SS_ROUTE6:
+    case RTNL_SS_NEIGH:
+      // Timeout happened while synchronizing
+      rtnl_sync_reset (ns);
+      rtnl_schedule_timeout (ns, rm->now + 1);
+      break;
     }
-    ns->sync_state = RTNL_SS_LINK;
-    rtnl_schedule_timeout(ns, rm->now + 2);
-    break;
-  case RTNL_SS_LINK:
-  case RTNL_SS_ADDR:
-  case RTNL_SS_ROUTE4:
-  case RTNL_SS_ROUTE6:
-  case RTNL_SS_NEIGH:
-    //Timeout happened while synchronizing
-    rtnl_sync_reset(ns);
-    rtnl_schedule_timeout(ns, rm->now + 1);
-    break;
-  }
 }
 
 static int
-rtnl_ns_recv(rtnl_ns_t *ns, struct nlmsghdr *hdr)
+rtnl_ns_recv (rtnl_ns_t *ns, struct nlmsghdr *hdr)
 {
   rtnl_main_t *rm = &rtnl_main;
   int ret, error = 0;
 
-  if (ns->state == RTNL_S_SYNC &&
-      ((hdr->nlmsg_flags & RTM_F_NOTIFY) ||
-       (hdr->nlmsg_seq != (ns->rtnl_seq)))) {
-    clib_warning("Received notification while in sync. Restart synchronization.");
-    rtnl_sync_reset(ns);
-    rtnl_schedule_timeout(ns, rm->now);
-  }
-
-  switch (hdr->nlmsg_type) {
-  case NLMSG_DONE:
-    rtnl_sync_done(ns);
-    break;
-  case NLMSG_ERROR:
-    if((ret = rtnl_rcv_error(ns, hdr, &error)))
-      return ret;
-    break;
-  case RTM_NEWROUTE:
-  case RTM_DELROUTE:
-  case RTM_NEWLINK:
-  case RTM_DELLINK:
-  case RTM_NEWADDR:
-  case RTM_DELADDR:
-  case RTM_NEWNEIGH:
-  case RTM_DELNEIGH:
-    if (ns->stream.recv_message)
-      ns->stream.recv_message(hdr, ns->stream.opaque);
-    break;
-  default:
-    clib_warning("Unknown rtnetlink type %d", hdr->nlmsg_type);
-    break;
-  }
+  if (ns->state == RTNL_S_SYNC && ((hdr->nlmsg_flags & RTM_F_NOTIFY) ||
+				   (hdr->nlmsg_seq != (ns->rtnl_seq))))
+    {
+      clib_warning (
+	"Received notification while in sync. Restart synchronization.");
+      rtnl_sync_reset (ns);
+      rtnl_schedule_timeout (ns, rm->now);
+    }
+
+  switch (hdr->nlmsg_type)
+    {
+    case NLMSG_DONE:
+      rtnl_sync_done (ns);
+      break;
+    case NLMSG_ERROR:
+      if ((ret = rtnl_rcv_error (ns, hdr, &error)))
+	return ret;
+      break;
+    case RTM_NEWROUTE:
+    case RTM_DELROUTE:
+    case RTM_NEWLINK:
+    case RTM_DELLINK:
+    case RTM_NEWADDR:
+    case RTM_DELADDR:
+    case RTM_NEWNEIGH:
+    case RTM_DELNEIGH:
+      if (ns->stream.recv_message)
+	ns->stream.recv_message (hdr, ns->stream.opaque);
+      break;
+    default:
+      clib_warning ("Unknown rtnetlink type %d", hdr->nlmsg_type);
+      break;
+    }
   return 0;
 }
 
 static void
-rtnl_process_open(rtnl_ns_t *ns)
+rtnl_process_open (rtnl_ns_t *ns)
 {
   rtnl_main_t *rm = &rtnl_main;
   if (ns->state != RTNL_S_INIT)
@@ -438,163 +476,182 @@ rtnl_process_open(rtnl_ns_t *ns)
 
   ns->state = RTNL_S_SYNC;
   ns->sync_state = RTNL_SS_OPENING;
-  rtnl_schedule_timeout(ns, rm->now);
+  rtnl_schedule_timeout (ns, rm->now);
 }
 
 static void
-rtnl_process_close(rtnl_ns_t *ns)
+rtnl_process_close (rtnl_ns_t *ns)
 {
   rtnl_main_t *rm = &rtnl_main;
   if (ns->state == RTNL_S_INIT)
     return;
 
-  rtnl_socket_close(ns);
-  close(ns->ns_fd);
-  pool_put(rm->streams, ns);
+  rtnl_socket_close (ns);
+  close (ns->ns_fd);
+  pool_put (rm->streams, ns);
 }
 
 static int
-rtnl_process_read(rtnl_ns_t *ns)
+rtnl_process_read (rtnl_ns_t *ns)
 {
   uint8_t buff[RTNL_BUFFSIZ];
   ssize_t len;
   struct nlmsghdr *hdr;
-  while(1) {
-    if((len = recv(ns->rtnl_socket, buff, RTNL_BUFFSIZ, MSG_DONTWAIT)) < 0) {
-      if(errno != EAGAIN) {
-        clib_warning("rtnetlink recv error (%d) [%s]: %s", ns->rtnl_socket, ns->stream.name, strerror(errno));
-        return -1;
-      }
-      return 0;
-    }
-
-    for(hdr = (struct nlmsghdr *) buff;
-        len > 0;
-        len -= NLMSG_ALIGN(hdr->nlmsg_len),
-          hdr = (struct nlmsghdr *) (((uint8_t *) hdr) + NLMSG_ALIGN(hdr->nlmsg_len))) {
-      if((sizeof(*hdr) > (size_t)len) || (hdr->nlmsg_len > (size_t)len)) {
-        clib_warning("rtnetlink buffer too small (%d Vs %d)", (int) hdr->nlmsg_len, (int) len);
-        return -1;
-      }
-      if (rtnl_ns_recv(ns, hdr))
-        return -1;
+  while (1)
+    {
+      if ((len = recv (ns->rtnl_socket, buff, RTNL_BUFFSIZ, MSG_DONTWAIT)) < 0)
+	{
+	  if (errno != EAGAIN)
+	    {
+	      clib_warning ("rtnetlink recv error (%d) [%s]: %s",
+			    ns->rtnl_socket, ns->stream.name,
+			    strerror (errno));
+	      return -1;
+	    }
+	  return 0;
+	}
+
+      for (hdr = (struct nlmsghdr *) buff; len > 0;
+	   len -= NLMSG_ALIGN (hdr->nlmsg_len),
+	  hdr = (struct nlmsghdr *) (((uint8_t *) hdr) +
+				     NLMSG_ALIGN (hdr->nlmsg_len)))
+	{
+	  if ((sizeof (*hdr) > (size_t) len) ||
+	      (hdr->nlmsg_len > (size_t) len))
+	    {
+	      clib_warning ("rtnetlink buffer too small (%d Vs %d)",
+			    (int) hdr->nlmsg_len, (int) len);
+	      return -1;
+	    }
+	  if (rtnl_ns_recv (ns, hdr))
+	    return -1;
+	}
     }
-  }
   return 0;
 }
 
 static void
-rtnl_process_timeout(rtnl_ns_t *ns)
-{
-  switch (ns->state) {
-  case RTNL_S_SYNC:
-    rtnl_sync_timeout(ns);
-    break;
-  case RTNL_S_INIT:
-  case RTNL_S_READY:
-    clib_warning("Should not happen");
-    break;
-  }
+rtnl_process_timeout (rtnl_ns_t *ns)
+{
+  switch (ns->state)
+    {
+    case RTNL_S_SYNC:
+      rtnl_sync_timeout (ns);
+      break;
+    case RTNL_S_INIT:
+    case RTNL_S_READY:
+      clib_warning ("Should not happen");
+      break;
+    }
 }
 
 static uword
-rtnl_process (vlib_main_t * vm,
-              vlib_node_runtime_t * node,
-              vlib_frame_t * frame)
+rtnl_process (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
 {
   rtnl_main_t *rm = &rtnl_main;
   uword event_type;
   uword *event_data = 0;
-  rm->now = vlib_time_now(vm);
+  rm->now = vlib_time_now (vm);
   f64 timeout = DBL_MAX;
   rtnl_ns_t *ns;
 
-  //Setting up
-  while (1) {
-    vlib_process_wait_for_event_or_clock(vm, timeout - rm->now);
-    event_type = vlib_process_get_events(vm, &event_data);
-    rm->now = vlib_time_now(vm);
-
-    if (event_type == ~0) { //Clock event or no event
-      pool_foreach(ns, rm->streams, {
-          if (ns->timeout < rm->now) {
-            ns->timeout = DBL_MAX;
-            rtnl_process_timeout(ns);
-          }
-        });
-    } else {
-      rtnl_ns_t *ns;
-      uword *d;
-      vec_foreach(d, event_data) {
-        ns = &rm->streams[d[0]];
-        switch (event_type)
-          {
-          case RTNL_E_CLOSE:
-            rtnl_process_close(ns);
-            break;
-          case RTNL_E_OPEN:
-            rtnl_process_open(ns);
-            break;
-          case RTNL_E_READ:
-            rtnl_process_read(ns);
-            break;
-          }
-      }
+  // Setting up
+  while (1)
+    {
+      vlib_process_wait_for_event_or_clock (vm, timeout - rm->now);
+      event_type = vlib_process_get_events (vm, &event_data);
+      rm->now = vlib_time_now (vm);
+
+      if (event_type == ~0)
+	{ // Clock event or no event
+	  pool_foreach (ns, rm->streams, {
+	    if (ns->timeout < rm->now)
+	      {
+		ns->timeout = DBL_MAX;
+		rtnl_process_timeout (ns);
+	      }
+	  })
+	    ;
+	}
+      else
+	{
+	  rtnl_ns_t *ns;
+	  uword *d;
+	  vec_foreach (d, event_data)
+	    {
+	      ns = &rm->streams[d[0]];
+	      switch (event_type)
+		{
+		case RTNL_E_CLOSE:
+		  rtnl_process_close (ns);
+		  break;
+		case RTNL_E_OPEN:
+		  rtnl_process_open (ns);
+		  break;
+		case RTNL_E_READ:
+		  rtnl_process_read (ns);
+		  break;
+		}
+	    }
+	}
+
+      vec_reset_length (event_data);
+
+      timeout = DBL_MAX;
+      pool_foreach (ns, rm->streams, {
+	if (ns->timeout < timeout)
+	  timeout = ns->timeout;
+      })
+	;
     }
-
-    vec_reset_length (event_data);
-
-    timeout = DBL_MAX;
-    pool_foreach(ns, rm->streams, {
-        if (ns->timeout < timeout)
-          timeout = ns->timeout;
-      });
-  }
   return frame->n_vectors;
 }
 
-VLIB_REGISTER_NODE(rtnl_process_node, static) = {
+VLIB_REGISTER_NODE (rtnl_process_node, static) = {
   .function = rtnl_process,
   .name = "rtnl-process",
   .type = VLIB_NODE_TYPE_PROCESS,
 };
 
 u32
-rtnl_stream_open(rtnl_stream_t *template)
+rtnl_stream_open (rtnl_stream_t *template)
 {
-  vlib_main_t *vm = vlib_get_main();
+  vlib_main_t *vm = vlib_get_main ();
   rtnl_main_t *rm = &rtnl_main;
   rtnl_ns_t *ns;
   int fd;
-  u8 *s = format((u8 *)0, "%U", format_rtnl_nsname2path, template->name);
-  vec_add1(s, 0);
-
-  if ((fd = open((char *)s, O_RDONLY)) < 0) {
-    clib_unix_warning("open stream %s: ", s);
-    vec_free(s);
-    return ~0;
-  }
+  u8 *s = format ((u8 *) 0, "%U", format_rtnl_nsname2path, template->name);
+  vec_add1 (s, 0);
+
+  if ((fd = open ((char *) s, O_RDONLY)) < 0)
+    {
+      clib_unix_warning ("open stream %s: ", s);
+      vec_free (s);
+      return ~0;
+    }
 
-  vec_free(s);
-  pool_get(rm->streams, ns);
+  vec_free (s);
+  pool_get (rm->streams, ns);
   ns->state = RTNL_S_INIT;
   ns->ns_fd = fd;
   ns->stream = *template;
-  vlib_process_signal_event(vm, rtnl_process_node.index, RTNL_E_OPEN, (uword)(ns - rm->streams));
+  vlib_process_signal_event (vm, rtnl_process_node.index, RTNL_E_OPEN,
+			     (uword) (ns - rm->streams));
   return ns - rm->streams;
 }
 
 void
-rtnl_stream_close(u32 stream_index)
+rtnl_stream_close (u32 stream_index)
 {
-  vlib_main_t *vm = vlib_get_main();
+  vlib_main_t *vm = vlib_get_main ();
   rtnl_main_t *rm = &rtnl_main;
-  ASSERT(!pool_is_free_index(rm->streams, stream_index));
-  vlib_process_signal_event(vm, rtnl_process_node.index, RTNL_E_CLOSE, stream_index);
+  ASSERT (!pool_is_free_index (rm->streams, stream_index));
+  vlib_process_signal_event (vm, rtnl_process_node.index, RTNL_E_CLOSE,
+			     stream_index);
 }
 
 clib_error_t *
-rtnl_init (vlib_main_t * vm)
+rtnl_init (vlib_main_t *vm)
 {
   rtnl_main_t *rm = &rtnl_main;
   rm->streams = 0;
diff --git a/extras/router-plugin/devices/rtnetlink/rtnl.h b/extras/router-plugin/devices/rtnetlink/rtnl.h
index 3f96252c1..4c22b912a 100644
--- a/extras/router-plugin/devices/rtnetlink/rtnl.h
+++ b/extras/router-plugin/devices/rtnetlink/rtnl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,7 +21,8 @@
 #include <linux/netlink.h>
 #include <vppinfra/clib.h>
 
-typedef enum {
+typedef enum
+{
   RTNL_ERR_UNKNOWN,
 } rtnl_error_t;
 
@@ -37,24 +38,27 @@ typedef enum {
  * new dump requests are sent.
  */
 
-typedef struct rtnl_stream_s {
+typedef struct rtnl_stream_s
+{
   char name[RTNL_NETNS_NAMELEN + 1];
-  void (*recv_message)(struct nlmsghdr *hdr, uword opaque);
-  void (*error)(rtnl_error_t err, uword opaque);
+  void (*recv_message) (struct nlmsghdr *hdr, uword opaque);
+  void (*error) (rtnl_error_t err, uword opaque);
   uword opaque;
 } rtnl_stream_t;
 
-u32 rtnl_stream_open(rtnl_stream_t *template);
-void rtnl_stream_close(u32 handle);
+u32 rtnl_stream_open (rtnl_stream_t *template);
+void rtnl_stream_close (u32 handle);
 
 /*
  * Executes a function in a synchronously executed thread in the
  * given namespace.
  * Returns 0 on success, and -errno on error.
  */
-int rtnl_exec_in_namespace(u32 handle, void *(*fn)(void *), void *arg, void **ret);
-int rtnl_exec_in_namespace_by_name(char *nsname, void *(*fn)(void *), void *arg, void **ret);
+int rtnl_exec_in_namespace (u32 handle, void *(*fn) (void *), void *arg,
+			    void **ret);
+int rtnl_exec_in_namespace_by_name (char *nsname, void *(*fn) (void *),
+				    void *arg, void **ret);
 
-u8 *format_rtnl_nsname2path(u8 *s, va_list *args);
+u8 *format_rtnl_nsname2path (u8 *s, va_list *args);
 
 #endif
diff --git a/extras/router-plugin/devices/rtnetlink/test.c b/extras/router-plugin/devices/rtnetlink/test.c
index 031748dd3..c969f6108 100644
--- a/extras/router-plugin/devices/rtnetlink/test.c
+++ b/extras/router-plugin/devices/rtnetlink/test.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -15,183 +15,191 @@
 
 #include <librtnl/netns.h>
 
-#include <vnet/plugin/plugin.h>
 #include <librtnl/mapper.h>
-#include <vnet/ip/ip.h>
 #include <vnet/fib/fib.h>
 #include <vnet/fib/ip4_fib.h>
 #include <vnet/fib/ip6_fib.h>
+#include <vnet/ip/ip.h>
+#include <vnet/plugin/plugin.h>
 
 u32 handles[10];
 
 static void
-test_notify(void *obj, netns_type_t type, u32 flags, uword opaque) {
+test_notify (void *obj, netns_type_t type, u32 flags, uword opaque)
+{
   u32 index = (u32) opaque;
-  const char *action = (flags & NETNS_F_ADD)?"add":(flags & NETNS_F_DEL)?"del":"mod";
+  const char *action = (flags & NETNS_F_ADD) ? "add" :
+		       (flags & NETNS_F_DEL) ? "del" :
+						     "mod";
 
-  switch (type) {
+  switch (type)
+    {
     case NETNS_TYPE_ADDR:
-      clib_warning("%d: addr %s %U", index, action, format_ns_addr, (ns_addr_t *)obj);
+      clib_warning ("%d: addr %s %U", index, action, format_ns_addr,
+		    (ns_addr_t *) obj);
       break;
     case NETNS_TYPE_ROUTE:
-      clib_warning("%d: route %s %U", index, action, format_ns_route, (ns_route_t *)obj);
+      clib_warning ("%d: route %s %U", index, action, format_ns_route,
+		    (ns_route_t *) obj);
       break;
     case NETNS_TYPE_LINK:
-      clib_warning("%d:link %s %U", index, action, format_ns_link, (ns_link_t *)obj);
+      clib_warning ("%d:link %s %U", index, action, format_ns_link,
+		    (ns_link_t *) obj);
       break;
     case NETNS_TYPE_NEIGH:
-      clib_warning("%d: neigh %s %U", index, action, format_ns_neigh, (ns_neigh_t *)obj);
+      clib_warning ("%d: neigh %s %U", index, action, format_ns_neigh,
+		    (ns_neigh_t *) obj);
       break;
-  }
+    }
 }
 
 static clib_error_t *
-test_enable_command_fn (vlib_main_t * vm,
-                        unformat_input_t * input,
-                        vlib_cli_command_t * cmd)
+test_enable_command_fn (vlib_main_t *vm, unformat_input_t *input,
+			vlib_cli_command_t *cmd)
 {
   char *nsname = 0;
   u32 index;
-  if (!unformat(input, "%s", &nsname)) {
-    return clib_error_return(0, "unknown input `%U'",
-                             format_unformat_error, input);
-  }
-  if (!unformat(input, "%d", &index)) {
-    return clib_error_return(0, "unknown input `%U'",
-                             format_unformat_error, input);
-  }
-
-  if (!strcmp(nsname, "default"))
+  if (!unformat (input, "%s", &nsname))
+    {
+      return clib_error_return (0, "unknown input `%U'", format_unformat_error,
+				input);
+    }
+  if (!unformat (input, "%d", &index))
+    {
+      return clib_error_return (0, "unknown input `%U'", format_unformat_error,
+				input);
+    }
+
+  if (!strcmp (nsname, "default"))
     nsname[0] = 0;
 
   netns_sub_t sub;
   sub.notify = test_notify;
   sub.opaque = index;
-  handles[index] = netns_open(nsname, &sub);
-  if (handles[index] == ~0) {
-    return clib_error_create("Could not open netns with name %s", nsname);
-  }
+  handles[index] = netns_open (nsname, &sub);
+  if (handles[index] == ~0)
+    {
+      return clib_error_create ("Could not open netns with name %s", nsname);
+    }
   return 0;
 }
 
 static clib_error_t *
-test_disable_command_fn (vlib_main_t * vm,
-                         unformat_input_t * input,
-                         vlib_cli_command_t * cmd)
+test_disable_command_fn (vlib_main_t *vm, unformat_input_t *input,
+			 vlib_cli_command_t *cmd)
 {
   u32 index;
-  if (!unformat(input, "%d", &index)) {
-    return clib_error_return(0, "unknown input `%U'",
-                             format_unformat_error, input);
-  }
+  if (!unformat (input, "%d", &index))
+    {
+      return clib_error_return (0, "unknown input `%U'", format_unformat_error,
+				input);
+    }
 
-  netns_close(handles[index]);
+  netns_close (handles[index]);
   return 0;
 }
 
 VLIB_CLI_COMMAND (rtnl_enable_command, static) = {
-    .path = "test netns enable",
-    .short_help = "test netns enable [<ns-name>|default] <index>",
-    .function = test_enable_command_fn,
+  .path = "test netns enable",
+  .short_help = "test netns enable [<ns-name>|default] <index>",
+  .function = test_enable_command_fn,
 };
 
 VLIB_CLI_COMMAND (rtnl_disable_command, static) = {
-    .path = "test netns disable",
-    .short_help = "test rtnl disable <index>",
-    .function = test_disable_command_fn,
+  .path = "test netns disable",
+  .short_help = "test rtnl disable <index>",
+  .function = test_disable_command_fn,
 };
 
 u32 mapper_indexes[10];
 
 static clib_error_t *
-mapper_ns_add_command_fn (vlib_main_t * vm,
-                         unformat_input_t * input,
-                         vlib_cli_command_t * cmd)
+mapper_ns_add_command_fn (vlib_main_t *vm, unformat_input_t *input,
+			  vlib_cli_command_t *cmd)
 {
   u32 index;
   char *nsname;
   u32 table_id;
-  if (!unformat(input, "%d", &index))
-    return clib_error_return(0, "invalid index `%U'",
-                             format_unformat_error, input);
-  if (!unformat(input, "%s", &nsname))
-    return clib_error_return(0, "invalid nsname `%U'",
-                             format_unformat_error, input);
-  if (!unformat(input, "%d", &table_id))
-      return clib_error_return(0, "invalid fib index `%U'",
-                               format_unformat_error, input);
-
-  if (!strcmp(nsname, "default"))
+  if (!unformat (input, "%d", &index))
+    return clib_error_return (0, "invalid index `%U'", format_unformat_error,
+			      input);
+  if (!unformat (input, "%s", &nsname))
+    return clib_error_return (0, "invalid nsname `%U'", format_unformat_error,
+			      input);
+  if (!unformat (input, "%d", &table_id))
+    return clib_error_return (0, "invalid fib index `%U'",
+			      format_unformat_error, input);
+
+  if (!strcmp (nsname, "default"))
     nsname[0] = 0;
 
-  u32 fib4 = ip4_fib_index_from_table_id(table_id);
-  u32 fib6 = ip6_fib_index_from_table_id(table_id);
+  u32 fib4 = ip4_fib_index_from_table_id (table_id);
+  u32 fib6 = ip6_fib_index_from_table_id (table_id);
 
-  if (mapper_add_ns(nsname, fib4, fib6, &mapper_indexes[index]))
-    return clib_error_return(0, "Could not add ns %s", nsname);
+  if (mapper_add_ns (nsname, fib4, fib6, &mapper_indexes[index]))
+    return clib_error_return (0, "Could not add ns %s", nsname);
   return 0;
 }
 
 VLIB_CLI_COMMAND (mapper_ns_add_command, static) = {
-    .path = "test mapper ns add",
-    .short_help = "test mapper ns add <index> <nsname> <table-id>",
-    .function = mapper_ns_add_command_fn,
+  .path = "test mapper ns add",
+  .short_help = "test mapper ns add <index> <nsname> <table-id>",
+  .function = mapper_ns_add_command_fn,
 };
 
 static clib_error_t *
-mapper_ns_del_command_fn (vlib_main_t * vm,
-                         unformat_input_t * input,
-                         vlib_cli_command_t * cmd)
+mapper_ns_del_command_fn (vlib_main_t *vm, unformat_input_t *input,
+			  vlib_cli_command_t *cmd)
 {
   u32 index;
-  if (!unformat(input, "%d", &index))
-    return clib_error_return(0, "invalid index `%U'",
-                             format_unformat_error, input);
+  if (!unformat (input, "%d", &index))
+    return clib_error_return (0, "invalid index `%U'", format_unformat_error,
+			      input);
 
-  if (mapper_del_ns(mapper_indexes[index]))
-    return clib_error_return(0, "Could not del ns %d", index);
+  if (mapper_del_ns (mapper_indexes[index]))
+    return clib_error_return (0, "Could not del ns %d", index);
   return 0;
 }
 
 VLIB_CLI_COMMAND (mapper_ns_del_command, static) = {
-    .path = "test mapper ns delete",
-    .short_help = "test mapper ns delete <index>",
-    .function = mapper_ns_del_command_fn,
+  .path = "test mapper ns delete",
+  .short_help = "test mapper ns delete <index>",
+  .function = mapper_ns_del_command_fn,
 };
 
 static clib_error_t *
-mapper_iface_command_fn (vlib_main_t * vm,
-                         unformat_input_t * input,
-                         vlib_cli_command_t * cmd)
+mapper_iface_command_fn (vlib_main_t *vm, unformat_input_t *input,
+			 vlib_cli_command_t *cmd)
 {
   u32 nsindex;
   u32 ifindex;
   u32 sw_if_index;
   int del = 0;
-  if (!unformat(input, "%d", &nsindex))
-    return clib_error_return(0, "invalid nsindex `%U'",
-                             format_unformat_error, input);
-  if (!unformat(input, "%d", &ifindex))
-    return clib_error_return(0, "invalid ifindex `%U'",
-                             format_unformat_error, input);
-  if (!unformat(input, "%d", &sw_if_index))
-    return clib_error_return(0, "invalid sw_if_index `%U'",
-                             format_unformat_error, input);
-  if (unformat(input, "del"))
+  if (!unformat (input, "%d", &nsindex))
+    return clib_error_return (0, "invalid nsindex `%U'", format_unformat_error,
+			      input);
+  if (!unformat (input, "%d", &ifindex))
+    return clib_error_return (0, "invalid ifindex `%U'", format_unformat_error,
+			      input);
+  if (!unformat (input, "%d", &sw_if_index))
+    return clib_error_return (0, "invalid sw_if_index `%U'",
+			      format_unformat_error, input);
+  if (unformat (input, "del"))
     del = 1;
 
-  clib_warning("mapper_add_del %d %d %d %d", mapper_indexes[nsindex], ifindex, sw_if_index, del);
+  clib_warning ("mapper_add_del %d %d %d %d", mapper_indexes[nsindex], ifindex,
+		sw_if_index, del);
 
-  if (mapper_add_del(mapper_indexes[nsindex], ifindex, sw_if_index, del))
-    return clib_error_return(0, "Could not add iface");
+  if (mapper_add_del (mapper_indexes[nsindex], ifindex, sw_if_index, del))
+    return clib_error_return (0, "Could not add iface");
   return 0;
 }
 
-
 VLIB_CLI_COMMAND (mapper_iface_command, static) = {
-    .path = "test mapper iface",
-    .short_help = "test mapper iface <nsindex> <linux-ifindex> <sw_if_index> [del]",
-    .function = mapper_iface_command_fn,
+  .path = "test mapper iface",
+  .short_help =
+    "test mapper iface <nsindex> <linux-ifindex> <sw_if_index> [del]",
+  .function = mapper_iface_command_fn,
 };
 
 /* *INDENT-OFF* */
@@ -200,4 +208,3 @@ VLIB_PLUGIN_REGISTER () = {
   .description = "netlink",
 };
 /* *INDENT-ON* */
-
diff --git a/extras/router-plugin/rtinject/tap_inject.c b/extras/router-plugin/rtinject/tap_inject.c
index f41ae86c8..7befb3862 100644
--- a/extras/router-plugin/rtinject/tap_inject.c
+++ b/extras/router-plugin/rtinject/tap_inject.c
@@ -16,10 +16,10 @@
 
 #include "tap_inject.h"
 
-#include <vnet/mfib/mfib_table.h>
+#include <vnet/fib/fib.h>
 #include <vnet/ip/ip.h>
 #include <vnet/ip/lookup.h>
-#include <vnet/fib/fib.h>
+#include <vnet/mfib/mfib_table.h>
 
 static tap_inject_main_t tap_inject_main;
 extern dpo_type_t tap_inject_dpo_type;
@@ -33,7 +33,7 @@ tap_inject_get_main (void)
 void
 tap_inject_insert_tap (u32 sw_if_index, u32 tap_fd, u32 tap_if_index)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
 
   vec_validate_init_empty (im->sw_if_index_to_tap_fd, sw_if_index, ~0);
   vec_validate_init_empty (im->sw_if_index_to_tap_if_index, sw_if_index, ~0);
@@ -51,7 +51,7 @@ tap_inject_insert_tap (u32 sw_if_index, u32 tap_fd, u32 tap_if_index)
 void
 tap_inject_delete_tap (u32 sw_if_index)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
   u32 tap_fd = im->sw_if_index_to_tap_fd[sw_if_index];
   u32 tap_if_index = im->sw_if_index_to_tap_if_index[sw_if_index];
 
@@ -65,7 +65,7 @@ tap_inject_delete_tap (u32 sw_if_index)
 u32
 tap_inject_lookup_tap_fd (u32 sw_if_index)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
 
   vec_validate_init_empty (im->sw_if_index_to_tap_fd, sw_if_index, ~0);
   return im->sw_if_index_to_tap_fd[sw_if_index];
@@ -74,7 +74,7 @@ tap_inject_lookup_tap_fd (u32 sw_if_index)
 u32
 tap_inject_lookup_sw_if_index_from_tap_fd (u32 tap_fd)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
 
   vec_validate_init_empty (im->tap_fd_to_sw_if_index, tap_fd, ~0);
   return im->tap_fd_to_sw_if_index[tap_fd];
@@ -83,25 +83,24 @@ tap_inject_lookup_sw_if_index_from_tap_fd (u32 tap_fd)
 u32
 tap_inject_lookup_sw_if_index_from_tap_if_index (u32 tap_if_index)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
-  uword * sw_if_index;
+  tap_inject_main_t *im = tap_inject_get_main ();
+  uword *sw_if_index;
 
   sw_if_index = hash_get (im->tap_if_index_to_sw_if_index, tap_if_index);
-  return sw_if_index ? *(u32 *)sw_if_index : ~0;
+  return sw_if_index ? *(u32 *) sw_if_index : ~0;
 }
 
 /* *INDENT-OFF* */
 VLIB_PLUGIN_REGISTER () = {
-    // .version = VPP_BUILD_VER, FIXME
-    .description = "router",
+  // .version = VPP_BUILD_VER, FIXME
+  .description = "router",
 };
 /* *INDENT-ON* */
 
-
 static void
 tap_inject_disable (void)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
 
   im->flags &= ~TAP_INJECT_F_ENABLED;
 
@@ -111,8 +110,8 @@ tap_inject_disable (void)
 static clib_error_t *
 tap_inject_enable (void)
 {
-  vlib_main_t * vm = vlib_get_main ();
-  tap_inject_main_t * im = tap_inject_get_main ();
+  vlib_main_t *vm = vlib_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
 
   if (tap_inject_is_enabled ())
     return 0;
@@ -127,7 +126,8 @@ tap_inject_enable (void)
     }
 
   /* Register ARP and ICMP6 as neighbor nodes. */
-  ethernet_register_input_type (vm, ETHERNET_TYPE_ARP, im->neighbor_node_index);
+  ethernet_register_input_type (vm, ETHERNET_TYPE_ARP,
+				im->neighbor_node_index);
   ip6_register_protocol (IP_PROTOCOL_ICMP6, im->neighbor_node_index);
 
   /* Register remaining protocols. */
@@ -147,26 +147,25 @@ tap_inject_enable (void)
     const mfib_prefix_t pfx_224_0_0_0 = {
         .fp_len = 24,
         .fp_proto = FIB_PROTOCOL_IP4,
-        .fp_grp_addr = {
-            .ip4.as_u32 = clib_host_to_net_u32(0xe0000000),
-        },
-        .fp_src_addr = {
-            .ip4.as_u32 = 0,
-        },
+        .fp_grp_addr =
+            {
+                .ip4.as_u32 = clib_host_to_net_u32(0xe0000000),
+            },
+        .fp_src_addr =
+            {
+                .ip4.as_u32 = 0,
+            },
     };
 
-    dpo_set(&dpo, tap_inject_dpo_type, DPO_PROTO_IP4, ~0);
+    dpo_set (&dpo, tap_inject_dpo_type, DPO_PROTO_IP4, ~0);
 
-    index_t repi = replicate_create(1, DPO_PROTO_IP4);
-    replicate_set_bucket(repi, 0, &dpo);
+    index_t repi = replicate_create (1, DPO_PROTO_IP4);
+    replicate_set_bucket (repi, 0, &dpo);
 
-    mfib_table_entry_special_add(0,
-                                 &pfx_224_0_0_0,
-                                 MFIB_SOURCE_API,
-                                 MFIB_ENTRY_FLAG_ACCEPT_ALL_ITF,
-                                 repi);
+    mfib_table_entry_special_add (0, &pfx_224_0_0_0, MFIB_SOURCE_API,
+				  MFIB_ENTRY_FLAG_ACCEPT_ALL_ITF, repi);
 
-    dpo_reset(&dpo);
+    dpo_reset (&dpo);
   }
 
   im->flags |= TAP_INJECT_F_ENABLED;
@@ -175,24 +174,24 @@ tap_inject_enable (void)
 }
 
 static uword
-tap_inject_iface_isr (vlib_main_t * vm, vlib_node_runtime_t * node,
-                      vlib_frame_t * f)
+tap_inject_iface_isr (vlib_main_t *vm, vlib_node_runtime_t *node,
+		      vlib_frame_t *f)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
-  vnet_hw_interface_t * hw;
-  u32 * hw_if_index;
-  clib_error_t * err = 0;
+  tap_inject_main_t *im = tap_inject_get_main ();
+  vnet_hw_interface_t *hw;
+  u32 *hw_if_index;
+  clib_error_t *err = 0;
 
   vec_foreach (hw_if_index, im->interfaces_to_enable)
     {
       hw = vnet_get_hw_interface (vnet_get_main (), *hw_if_index);
 
       if (hw->hw_class_index == ethernet_hw_interface_class.index)
-        {
-          err = tap_inject_tap_connect (hw);
-          if (err)
-            break;
-        }
+	{
+	  err = tap_inject_tap_connect (hw);
+	  if (err)
+	    break;
+	}
     }
 
   vec_foreach (hw_if_index, im->interfaces_to_disable)
@@ -212,13 +211,12 @@ VLIB_REGISTER_NODE (tap_inject_iface_isr_node, static) = {
   .vector_size = sizeof (u32),
 };
 
-
 static clib_error_t *
-tap_inject_interface_add_del (struct vnet_main_t * vnet_main, u32 hw_if_index,
-                              u32 add)
+tap_inject_interface_add_del (struct vnet_main_t *vnet_main, u32 hw_if_index,
+			      u32 add)
 {
-  vlib_main_t * vm = vlib_get_main ();
-  tap_inject_main_t * im = tap_inject_get_main ();
+  vlib_main_t *vm = vlib_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
 
   if (!tap_inject_is_config_enabled ())
     return 0;
@@ -237,15 +235,14 @@ tap_inject_interface_add_del (struct vnet_main_t * vnet_main, u32 hw_if_index,
 
 VNET_HW_INTERFACE_ADD_DEL_FUNCTION (tap_inject_interface_add_del);
 
-
 static clib_error_t *
 tap_inject_enable_disable_all_interfaces (int enable)
 {
-  vnet_main_t * vnet_main = vnet_get_main ();
-  tap_inject_main_t * im = tap_inject_get_main ();
-  vnet_hw_interface_t * interfaces;
-  vnet_hw_interface_t * hw;
-  u32 ** indices;
+  vnet_main_t *vnet_main = vnet_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
+  vnet_hw_interface_t *interfaces;
+  vnet_hw_interface_t *hw;
+  u32 **indices;
 
   if (enable)
     tap_inject_enable ();
@@ -255,7 +252,8 @@ tap_inject_enable_disable_all_interfaces (int enable)
   /* Collect all the interface indices. */
   interfaces = vnet_main->interface_main.hw_interfaces;
   indices = enable ? &im->interfaces_to_enable : &im->interfaces_to_disable;
-  pool_foreach (hw, interfaces, vec_add1 (*indices, hw - interfaces));
+  pool_foreach (hw, interfaces, vec_add1 (*indices, hw - interfaces))
+    ;
 
   if (tap_inject_iface_isr (vlib_get_main (), 0, 0))
     return clib_error_return (0, "tap-inject interface add del isr failed");
@@ -264,26 +262,26 @@ tap_inject_enable_disable_all_interfaces (int enable)
 }
 
 static clib_error_t *
-tap_inject_cli (vlib_main_t * vm, unformat_input_t * input,
-                 vlib_cli_command_t * cmd)
+tap_inject_cli (vlib_main_t *vm, unformat_input_t *input,
+		vlib_cli_command_t *cmd)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
 
   if (cmd->function_arg)
     {
-      clib_error_t * err;
+      clib_error_t *err;
 
       if (tap_inject_is_config_disabled ())
-        return clib_error_return (0,
-            "tap-inject is disabled in config, thus cannot be enabled.");
+	return clib_error_return (
+	  0, "tap-inject is disabled in config, thus cannot be enabled.");
 
       /* Enable */
       err = tap_inject_enable_disable_all_interfaces (1);
       if (err)
-        {
-          tap_inject_enable_disable_all_interfaces (0);
-          return err;
-        }
+	{
+	  tap_inject_enable_disable_all_interfaces (0);
+	  return err;
+	}
 
       im->flags |= TAP_INJECT_F_CONFIG_ENABLE;
     }
@@ -311,13 +309,12 @@ VLIB_CLI_COMMAND (tap_inject_disable_cmd, static) = {
   .function_arg = 0,
 };
 
-
 static clib_error_t *
-show_tap_inject (vlib_main_t * vm, unformat_input_t * input,
-                 vlib_cli_command_t * cmd)
+show_tap_inject (vlib_main_t *vm, unformat_input_t *input,
+		 vlib_cli_command_t *cmd)
 {
-  vnet_main_t * vnet_main = vnet_get_main ();
-  tap_inject_main_t * im = tap_inject_get_main ();
+  vnet_main_t *vnet_main = vnet_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
   u32 k, v;
 
   if (tap_inject_is_config_disabled ())
@@ -333,10 +330,9 @@ show_tap_inject (vlib_main_t * vm, unformat_input_t * input,
     }
 
   hash_foreach (k, v, im->tap_if_index_to_sw_if_index, {
-    vlib_cli_output (vm, "%U -> %U",
-            format_vnet_sw_interface_name, vnet_main,
-            vnet_get_sw_interface (vnet_main, v),
-            format_tap_inject_tap_name, k);
+    vlib_cli_output (vm, "%U -> %U", format_vnet_sw_interface_name, vnet_main,
+		     vnet_get_sw_interface (vnet_main, v),
+		     format_tap_inject_tap_name, k);
   });
 
   return 0;
@@ -348,31 +344,30 @@ VLIB_CLI_COMMAND (show_tap_inject_cmd, static) = {
   .function = show_tap_inject,
 };
 
-
 static clib_error_t *
-tap_inject_config (vlib_main_t * vm, unformat_input_t * input)
+tap_inject_config (vlib_main_t *vm, unformat_input_t *input)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
 
   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
       if (unformat (input, "enable"))
-        im->flags |= TAP_INJECT_F_CONFIG_ENABLE;
+	im->flags |= TAP_INJECT_F_CONFIG_ENABLE;
 
       else if (unformat (input, "disable"))
-        im->flags |= TAP_INJECT_F_CONFIG_DISABLE;
+	im->flags |= TAP_INJECT_F_CONFIG_DISABLE;
 
       else if (unformat (input, "netlink-only"))
-        im->flags |= TAP_INJECT_F_CONFIG_NETLINK;
+	im->flags |= TAP_INJECT_F_CONFIG_NETLINK;
 
       else
-        return clib_error_return (0, "syntax error `%U'",
-                                  format_unformat_error, input);
+	return clib_error_return (0, "syntax error `%U'",
+				  format_unformat_error, input);
     }
 
   if (tap_inject_is_config_enabled () && tap_inject_is_config_disabled ())
-    return clib_error_return (0,
-              "tap-inject cannot be both enabled and disabled.");
+    return clib_error_return (
+      0, "tap-inject cannot be both enabled and disabled.");
 
   return 0;
 }
diff --git a/extras/router-plugin/rtinject/tap_inject.h b/extras/router-plugin/rtinject/tap_inject.h
index ec5121a09..6226a0aad 100644
--- a/extras/router-plugin/rtinject/tap_inject.h
+++ b/extras/router-plugin/rtinject/tap_inject.h
@@ -17,14 +17,15 @@
 #ifndef _TAP_INJECT_H
 #define _TAP_INJECT_H
 
-#include <vnet/plugin/plugin.h>
 #include <vnet/ip/ip.h>
+#include <vnet/plugin/plugin.h>
 
 #ifndef ETHER_ADDR_LEN
 #define ETHER_ADDR_LEN 6
 #endif
 
-typedef struct {
+typedef struct
+{
   /*
    * tap-inject can be enabled or disabled in config file or during runtime.
    * When disabled in config, it is not possible to enable during runtime.
@@ -36,30 +37,29 @@ typedef struct {
 #define TAP_INJECT_F_CONFIG_ENABLE  (1U << 0)
 #define TAP_INJECT_F_CONFIG_DISABLE (1U << 1)
 #define TAP_INJECT_F_CONFIG_NETLINK (1U << 2)
-#define TAP_INJECT_F_ENABLED        (1U << 3)
+#define TAP_INJECT_F_ENABLED	    (1U << 3)
 
   u32 flags;
 
-  u32 * sw_if_index_to_tap_fd;
-  u32 * sw_if_index_to_tap_if_index;
-  u32 * tap_fd_to_sw_if_index;
-  u32 * tap_if_index_to_sw_if_index;
+  u32 *sw_if_index_to_tap_fd;
+  u32 *sw_if_index_to_tap_if_index;
+  u32 *tap_fd_to_sw_if_index;
+  u32 *tap_if_index_to_sw_if_index;
 
-  u32 * interfaces_to_enable;
-  u32 * interfaces_to_disable;
+  u32 *interfaces_to_enable;
+  u32 *interfaces_to_disable;
 
-  u32 * rx_file_descriptors;
+  u32 *rx_file_descriptors;
 
   u32 rx_node_index;
   u32 tx_node_index;
   u32 neighbor_node_index;
 
-  u32 * rx_buffers;
+  u32 *rx_buffers;
 
 } tap_inject_main_t;
 
-
-tap_inject_main_t * tap_inject_get_main (void);
+tap_inject_main_t *tap_inject_get_main (void);
 
 void tap_inject_insert_tap (u32 sw_if_index, u32 tap_fd, u32 tap_if_index);
 void tap_inject_delete_tap (u32 sw_if_index);
@@ -71,7 +71,7 @@ u32 tap_inject_lookup_sw_if_index_from_tap_if_index (u32 tap_if_index);
 static inline int
 tap_inject_is_enabled (void)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
 
   return !!(im->flags & TAP_INJECT_F_ENABLED);
 }
@@ -79,7 +79,7 @@ tap_inject_is_enabled (void)
 static inline int
 tap_inject_is_config_enabled (void)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
 
   return !!(im->flags & TAP_INJECT_F_CONFIG_ENABLE);
 }
@@ -87,22 +87,20 @@ tap_inject_is_config_enabled (void)
 static inline int
 tap_inject_is_config_disabled (void)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
 
   return !!(im->flags & TAP_INJECT_F_CONFIG_DISABLE);
 }
 
-
 /* Netlink */
 
 void tap_inject_enable_netlink (void);
 
-
 /* Tap */
 
-clib_error_t * tap_inject_tap_connect (vnet_hw_interface_t * hw);
-clib_error_t * tap_inject_tap_disconnect (u32 sw_if_index);
+clib_error_t *tap_inject_tap_connect (vnet_hw_interface_t *hw);
+clib_error_t *tap_inject_tap_disconnect (u32 sw_if_index);
 
-u8 * format_tap_inject_tap_name (u8 * s, va_list * args);
+u8 *format_tap_inject_tap_name (u8 *s, va_list *args);
 
 #endif /* _TAP_INJECT_H */
diff --git a/extras/router-plugin/rtinject/tap_inject_netlink.c b/extras/router-plugin/rtinject/tap_inject_netlink.c
index a221e8eaa..92ffdc6e5 100644
--- a/extras/router-plugin/rtinject/tap_inject_netlink.c
+++ b/extras/router-plugin/rtinject/tap_inject_netlink.c
@@ -15,25 +15,25 @@
  */
 
 #include "../devices/rtnetlink/netns.h"
+#include <arpa/inet.h>
+#include <linux/mpls.h>
 #include <vlibmemory/api.h>
+#include <vnet/ethernet/arp.h>
+#include <vnet/fib/fib.h>
 #include <vnet/ip/ip6_neighbor.h>
 #include <vnet/ip/lookup.h>
-#include <vnet/fib/fib.h>
-#include <vnet/ethernet/arp.h>
-#include <arpa/inet.h>
-#include <linux/mpls.h>
 #include <vnet/mpls/packet.h>
 
 #include "tap_inject.h"
 
 static void
-add_del_addr (ns_addr_t * a, int is_del)
+add_del_addr (ns_addr_t *a, int is_del)
 {
-  vlib_main_t * vm = vlib_get_main ();
+  vlib_main_t *vm = vlib_get_main ();
   u32 sw_if_index;
 
-  sw_if_index = tap_inject_lookup_sw_if_index_from_tap_if_index (
-                                                                 a->ifaddr.ifa_index);
+  sw_if_index =
+    tap_inject_lookup_sw_if_index_from_tap_if_index (a->ifaddr.ifa_index);
 
   if (sw_if_index == ~0)
     return;
@@ -41,37 +41,39 @@ add_del_addr (ns_addr_t * a, int is_del)
   if (a->ifaddr.ifa_family == AF_INET)
     {
       ip4_add_del_interface_address (vm, sw_if_index,
-                                     (ip4_address_t *) a->local, a->ifaddr.ifa_prefixlen, is_del);
+				     (ip4_address_t *) a->local,
+				     a->ifaddr.ifa_prefixlen, is_del);
     }
   else if (a->ifaddr.ifa_family == AF_INET6)
     {
       ip6_add_del_interface_address (vm, sw_if_index,
-                                     (ip6_address_t *) a->addr, a->ifaddr.ifa_prefixlen, is_del);
+				     (ip6_address_t *) a->addr,
+				     a->ifaddr.ifa_prefixlen, is_del);
     }
 }
 
-
-struct set_flags_args {
+struct set_flags_args
+{
   u32 index;
   u8 flags;
 };
 
 static void
-set_flags_cb (struct set_flags_args * a)
+set_flags_cb (struct set_flags_args *a)
 {
   vnet_sw_interface_set_flags (vnet_get_main (), a->index, a->flags);
 }
 
 static void
-add_del_link (ns_link_t * l, int is_del)
+add_del_link (ns_link_t *l, int is_del)
 {
   struct set_flags_args args = { ~0, 0 };
-  vnet_sw_interface_t * sw;
+  vnet_sw_interface_t *sw;
   u8 flags = 0;
   u32 sw_if_index;
 
-  sw_if_index = tap_inject_lookup_sw_if_index_from_tap_if_index (
-                                                                 l->ifi.ifi_index);
+  sw_if_index =
+    tap_inject_lookup_sw_if_index_from_tap_if_index (l->ifi.ifi_index);
 
   if (sw_if_index == ~0)
     return;
@@ -88,19 +90,18 @@ add_del_link (ns_link_t * l, int is_del)
   args.index = sw_if_index;
   args.flags = flags;
 
-  vl_api_rpc_call_main_thread (set_flags_cb, (u8 *)&args, sizeof (args));
+  vl_api_rpc_call_main_thread (set_flags_cb, (u8 *) &args, sizeof (args));
 }
 
-
 static void
-add_del_neigh (ns_neigh_t * n, int is_del)
+add_del_neigh (ns_neigh_t *n, int is_del)
 {
-  vnet_main_t * vnet_main = vnet_get_main ();
-  vlib_main_t * vm = vlib_get_main ();
+  vnet_main_t *vnet_main = vnet_get_main ();
+  vlib_main_t *vm = vlib_get_main ();
   u32 sw_if_index;
 
-  sw_if_index = tap_inject_lookup_sw_if_index_from_tap_if_index (
-                                                                 n->nd.ndm_ifindex);
+  sw_if_index =
+    tap_inject_lookup_sw_if_index_from_tap_if_index (n->nd.ndm_ifindex);
 
   if (sw_if_index == ~0)
     return;
@@ -114,57 +115,54 @@ add_del_neigh (ns_neigh_t * n, int is_del)
       clib_memcpy (&a.mac, n->lladdr, ETHER_ADDR_LEN);
       clib_memcpy (&a.ip4, n->dst, sizeof (a.ip4));
 
-
       if (n->nd.ndm_state & NUD_REACHABLE)
-        {
-          vnet_arp_set_ip4_over_ethernet (vnet_main, sw_if_index,
-                                          &a,
-                                          IP_NEIGHBOR_FLAG_NO_FIB_ENTRY);
-
-        }
+	{
+	  vnet_arp_set_ip4_over_ethernet (vnet_main, sw_if_index, &a,
+					  IP_NEIGHBOR_FLAG_NO_FIB_ENTRY);
+	}
       else if (n->nd.ndm_state & NUD_FAILED)
-        {
-          vnet_arp_unset_ip4_over_ethernet (vnet_main, sw_if_index, &a);
-        }
+	{
+	  vnet_arp_unset_ip4_over_ethernet (vnet_main, sw_if_index, &a);
+	}
     }
   else if (n->nd.ndm_family == AF_INET6)
     {
       if (n->nd.ndm_state & NUD_REACHABLE)
-        {
-
-          mac_address_t * mac1;
-	  mac1=malloc(sizeof(mac_address_t));
-          memcpy (mac1, n->lladdr, ETHER_ADDR_LEN);
-          vnet_set_ip6_ethernet_neighbor (vm, sw_if_index,
-                                          (ip6_address_t *) n->dst, (mac_address_t *) mac1,
-                                           IP_NEIGHBOR_FLAG_NONE);
-        }
+	{
+
+	  mac_address_t *mac1;
+	  mac1 = malloc (sizeof (mac_address_t));
+	  memcpy (mac1, n->lladdr, ETHER_ADDR_LEN);
+	  vnet_set_ip6_ethernet_neighbor (
+	    vm, sw_if_index, (ip6_address_t *) n->dst, (mac_address_t *) mac1,
+	    IP_NEIGHBOR_FLAG_NONE);
+	}
       else
-        vnet_unset_ip6_ethernet_neighbor (vm, sw_if_index,
-                                          (ip6_address_t *) n->dst);
+	vnet_unset_ip6_ethernet_neighbor (vm, sw_if_index,
+					  (ip6_address_t *) n->dst);
     }
 }
 
-
 #define TAP_INJECT_HOST_ROUTE_TABLE_MAIN 254
 
 static void
-get_mpls_label_stack(struct mpls_label *addr, u32* l)
+get_mpls_label_stack (struct mpls_label *addr, u32 *l)
 {
-  u32 entry = ntohl(addr[0].entry);
+  u32 entry = ntohl (addr[0].entry);
   u32 label = (entry & MPLS_LS_LABEL_MASK) >> MPLS_LS_LABEL_SHIFT;
 
-  for(int i = 1; label != 0; i++) {
-    *l++ = label;
-    if(entry & MPLS_LS_S_MASK)
-      return;
-    entry = ntohl(addr[i].entry);
-    label = (entry & MPLS_LS_LABEL_MASK) >> MPLS_LS_LABEL_SHIFT;
-  }
+  for (int i = 1; label != 0; i++)
+    {
+      *l++ = label;
+      if (entry & MPLS_LS_S_MASK)
+	return;
+      entry = ntohl (addr[i].entry);
+      label = (entry & MPLS_LS_LABEL_MASK) >> MPLS_LS_LABEL_SHIFT;
+    }
 }
 
 static void
-add_del_route (ns_route_t * r, int is_del)
+add_del_route (ns_route_t *r, int is_del)
 {
   u32 sw_if_index;
 
@@ -175,101 +173,90 @@ add_del_route (ns_route_t * r, int is_del)
 
   if (r->rtm.rtm_family == AF_INET)
     {
-      u32 stack[MPLS_STACK_DEPTH] = {0};
+      u32 stack[MPLS_STACK_DEPTH] = { 0 };
 
       fib_prefix_t prefix;
-      ip46_address_t nh;
+      ip_address_t nh;
 
       memset (&prefix, 0, sizeof (prefix));
       prefix.fp_len = r->rtm.rtm_dst_len;
       prefix.fp_proto = FIB_PROTOCOL_IP4;
       clib_memcpy (&prefix.fp_addr.ip4, r->dst, sizeof (prefix.fp_addr.ip4));
-      get_mpls_label_stack(r->encap, stack);
+      get_mpls_label_stack (r->encap, stack);
       memset (&nh, 0, sizeof (nh));
       clib_memcpy (&nh.ip4, r->gateway, sizeof (nh.ip4));
-      if(*stack == 0)
-        fib_table_entry_path_add (0, &prefix, FIB_SOURCE_API,
-                                  FIB_ENTRY_FLAG_NONE, prefix.fp_proto,
-                                  &nh, sw_if_index, 0,
-                                  0 /* weight */, NULL,
-                                  FIB_ROUTE_PATH_FLAG_NONE);
-      else {
-        fib_route_path_t *rpaths = NULL, rpath;
-        memset(&rpath, 0, sizeof(rpath));
-        rpath.frp_weight = 1;
-        rpath.frp_proto = DPO_PROTO_IP4;
-        clib_memcpy(&rpath.frp_addr.ip4, r->gateway, sizeof(rpath.frp_addr.ip4));
-        rpath.frp_sw_if_index = sw_if_index;
-        for(int i = 0; i < MPLS_STACK_DEPTH && stack[i] != 0; i++) {
-          fib_mpls_label_t fib_label = {stack[i],0,0,0};
-          vec_add1(rpath.frp_label_stack, fib_label);
-        }
-        vec_add1(rpaths, rpath);
-        fib_table_entry_path_add2(0,
-                                  &prefix,
-                                  FIB_SOURCE_API,
-                                  FIB_ENTRY_FLAG_NONE,
-                                  rpaths);
-      }
+      if (*stack == 0)
+	fib_table_entry_path_add (
+	  0, &prefix, FIB_SOURCE_API, FIB_ENTRY_FLAG_NONE, prefix.fp_proto,
+	  &nh, sw_if_index, 0, 0 /* weight */, NULL, FIB_ROUTE_PATH_FLAG_NONE);
+      else
+	{
+	  fib_route_path_t *rpaths = NULL, rpath;
+	  memset (&rpath, 0, sizeof (rpath));
+	  rpath.frp_weight = 1;
+	  rpath.frp_proto = DPO_PROTO_IP4;
+	  clib_memcpy (&rpath.frp_addr.ip4, r->gateway,
+		       sizeof (rpath.frp_addr.ip4));
+	  rpath.frp_sw_if_index = sw_if_index;
+	  for (int i = 0; i < MPLS_STACK_DEPTH && stack[i] != 0; i++)
+	    {
+	      fib_mpls_label_t fib_label = { stack[i], 0, 0, 0 };
+	      vec_add1 (rpath.frp_label_stack, fib_label);
+	    }
+	  vec_add1 (rpaths, rpath);
+	  fib_table_entry_path_add2 (0, &prefix, FIB_SOURCE_API,
+				     FIB_ENTRY_FLAG_NONE, rpaths);
+	}
     }
   else if (r->rtm.rtm_family == AF_INET6)
     {
       fib_prefix_t prefix;
-      ip46_address_t nh;
+      ip_address_t nh;
       memset (&prefix, 0, sizeof (prefix));
       prefix.fp_len = r->rtm.rtm_dst_len;
       prefix.fp_proto = FIB_PROTOCOL_IP6;
       clib_memcpy (&prefix.fp_addr.ip6, r->dst, sizeof (prefix.fp_addr.ip6));
       memset (&nh, 0, sizeof (nh));
       clib_memcpy (&nh.ip6, r->gateway, sizeof (nh.ip6));
-      fib_table_entry_path_add (0, &prefix, FIB_SOURCE_API,
-                                FIB_ENTRY_FLAG_NONE, prefix.fp_proto,
-                                &nh, sw_if_index, 0,
-                                0 /* weight */, NULL,
-                                FIB_ROUTE_PATH_FLAG_NONE);
+      fib_table_entry_path_add (
+	0, &prefix, FIB_SOURCE_API, FIB_ENTRY_FLAG_NONE, prefix.fp_proto, &nh,
+	sw_if_index, 0, 0 /* weight */, NULL, FIB_ROUTE_PATH_FLAG_NONE);
     }
-/*     else if (r->rtm.rtm_family == AF_MPLS)
-    {
-      u32 dst_label;
-      get_mpls_label_stack((struct mpls_label*) r->dst, &dst_label);
-      struct rtvia *via = (struct rtvia*) r->via;
-      fib_prefix_t prefix;
-      fib_route_path_t *rpaths = NULL, rpath;
-      memset (&prefix, 0, sizeof (prefix));
-      prefix.fp_len = 21;
-      prefix.fp_label = dst_label;
-      prefix.fp_proto = FIB_PROTOCOL_MPLS;
-      prefix.fp_payload_proto = DPO_PROTO_IP4;
-      memset(&rpath, 0, sizeof(rpath));
-      clib_memcpy (&rpath.frp_addr.ip4, via->rtvia_addr, sizeof (rpath.frp_addr.ip4));
-      rpath.frp_weight = 1;
-      rpath.frp_proto = DPO_PROTO_IP4;
-      rpath.frp_fib_index = 0;
-      rpath.frp_sw_if_index = sw_if_index;
-      vec_add1(rpaths, rpath);
-      fib_table_entry_path_add2(0,
-                                &prefix,
-                                FIB_SOURCE_API,
-                                FIB_ENTRY_FLAG_NONE,
-                                rpaths);
-    }*/
+  /*     else if (r->rtm.rtm_family == AF_MPLS)
+      {
+	u32 dst_label;
+	get_mpls_label_stack((struct mpls_label*) r->dst, &dst_label);
+	struct rtvia *via = (struct rtvia*) r->via;
+	fib_prefix_t prefix;
+	fib_route_path_t *rpaths = NULL, rpath;
+	memset (&prefix, 0, sizeof (prefix));
+	prefix.fp_len = 21;
+	prefix.fp_label = dst_label;
+	prefix.fp_proto = FIB_PROTOCOL_MPLS;
+	prefix.fp_payload_proto = DPO_PROTO_IP4;
+	memset(&rpath, 0, sizeof(rpath));
+	clib_memcpy (&rpath.frp_addr.ip4, via->rtvia_addr, sizeof
+     (rpath.frp_addr.ip4)); rpath.frp_weight = 1; rpath.frp_proto =
+     DPO_PROTO_IP4; rpath.frp_fib_index = 0; rpath.frp_sw_if_index =
+     sw_if_index; vec_add1(rpaths, rpath); fib_table_entry_path_add2(0,
+     &prefix, FIB_SOURCE_API, FIB_ENTRY_FLAG_NONE, rpaths);
+      }*/
 }
 
-
 static void
-netns_notify_cb (void * obj, netns_type_t type, u32 flags, uword opaque)
+netns_notify_cb (void *obj, netns_type_t type, u32 flags, uword opaque)
 {
   if (type == NETNS_TYPE_ADDR)
-    add_del_addr ((ns_addr_t *)obj, flags & NETNS_F_DEL);
+    add_del_addr ((ns_addr_t *) obj, flags & NETNS_F_DEL);
 
   else if (type == NETNS_TYPE_LINK)
-    add_del_link ((ns_link_t *)obj, flags & NETNS_F_DEL);
+    add_del_link ((ns_link_t *) obj, flags & NETNS_F_DEL);
 
   else if (type == NETNS_TYPE_NEIGH)
-    add_del_neigh ((ns_neigh_t *)obj, flags & NETNS_F_DEL);
+    add_del_neigh ((ns_neigh_t *) obj, flags & NETNS_F_DEL);
 
   else if (type == NETNS_TYPE_ROUTE)
-    add_del_route ((ns_route_t *)obj, flags & NETNS_F_DEL);
+    add_del_route ((ns_route_t *) obj, flags & NETNS_F_DEL);
 }
 
 void
diff --git a/extras/router-plugin/rtinject/tap_inject_node.c b/extras/router-plugin/rtinject/tap_inject_node.c
index 73c296451..b888b9223 100644
--- a/extras/router-plugin/rtinject/tap_inject_node.c
+++ b/extras/router-plugin/rtinject/tap_inject_node.c
@@ -15,15 +15,16 @@
  */
 
 #include "tap_inject.h"
-#include <sys/uio.h>
 #include <netinet/in.h>
+#include <sys/uio.h>
 #include <vnet/ethernet/arp_packet.h>
 
 vlib_node_registration_t tap_inject_rx_node;
 vlib_node_registration_t tap_inject_tx_node;
 vlib_node_registration_t tap_inject_neighbor_node;
 
-enum {
+enum
+{
   NEXT_NEIGHBOR_ARP,
   NEXT_NEIGHBOR_ICMP6,
 };
@@ -34,7 +35,7 @@ enum {
 dpo_type_t tap_inject_dpo_type;
 
 static inline void
-tap_inject_tap_send_buffer (int fd, vlib_buffer_t * b)
+tap_inject_tap_send_buffer (int fd, vlib_buffer_t *b)
 {
   struct iovec iov;
   ssize_t n_bytes;
@@ -51,10 +52,10 @@ tap_inject_tap_send_buffer (int fd, vlib_buffer_t * b)
 }
 
 static uword
-tap_inject_tx (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * f)
+tap_inject_tx (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *f)
 {
-  vlib_buffer_t * b;
-  u32 * pkts;
+  vlib_buffer_t *b;
+  u32 *pkts;
   u32 fd;
   u32 i;
 
@@ -66,7 +67,7 @@ tap_inject_tx (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * f)
 
       fd = tap_inject_lookup_tap_fd (vnet_buffer (b)->sw_if_index[VLIB_RX]);
       if (fd == ~0)
-        continue;
+	continue;
 
       /* Re-wind the buffer to the start of the Ethernet header. */
       vlib_buffer_advance (b, -b->current_data);
@@ -85,20 +86,19 @@ VLIB_REGISTER_NODE (tap_inject_tx_node) = {
   .type = VLIB_NODE_TYPE_INTERNAL,
 };
 
-
 static uword
-tap_inject_neighbor (vlib_main_t * vm,
-                     vlib_node_runtime_t * node, vlib_frame_t * f)
+tap_inject_neighbor (vlib_main_t *vm, vlib_node_runtime_t *node,
+		     vlib_frame_t *f)
 {
-  vlib_buffer_t * b;
-  u32 * pkts;
+  vlib_buffer_t *b;
+  u32 *pkts;
   u32 fd;
   u32 i;
   u32 bi;
   u32 next_index = node->cached_next_index;
   u32 next = ~0;
   u32 n_left;
-  u32 * to_next;
+  u32 *to_next;
 
   pkts = vlib_frame_vector_args (f);
 
@@ -109,10 +109,10 @@ tap_inject_neighbor (vlib_main_t * vm,
 
       fd = tap_inject_lookup_tap_fd (vnet_buffer (b)->sw_if_index[VLIB_RX]);
       if (fd == ~0)
-        {
-          vlib_buffer_free (vm, &bi, 1);
-          continue;
-        }
+	{
+	  vlib_buffer_free (vm, &bi, 1);
+	  continue;
+	}
 
       /* Re-wind the buffer to the start of the Ethernet header. */
       vlib_buffer_advance (b, -b->current_data);
@@ -121,32 +121,32 @@ tap_inject_neighbor (vlib_main_t * vm,
 
       /* Send the buffer to a neighbor node too? */
       {
-        ethernet_header_t * eth = vlib_buffer_get_current (b);
-        u16 ether_type = htons (eth->type);
-
-        if (ether_type == ETHERNET_TYPE_ARP)
-          {
-            ethernet_arp_header_t * arp = (void *)(eth + 1);
-
-            if (arp->opcode == ntohs (ETHERNET_ARP_OPCODE_reply))
-              next = NEXT_NEIGHBOR_ARP;
-          }
-        else if (ether_type == ETHERNET_TYPE_IP6)
-          {
-            ip6_header_t * ip = (void *)(eth + 1);
-            icmp46_header_t * icmp = (void *)(ip + 1);
-
-            if (ip->protocol == IP_PROTOCOL_ICMP6 &&
-                icmp->type == ICMP6_neighbor_advertisement)
-              next = NEXT_NEIGHBOR_ICMP6;
-          }
+	ethernet_header_t *eth = vlib_buffer_get_current (b);
+	u16 ether_type = htons (eth->type);
+
+	if (ether_type == ETHERNET_TYPE_ARP)
+	  {
+	    ethernet_arp_header_t *arp = (void *) (eth + 1);
+
+	    if (arp->opcode == ntohs (ETHERNET_ARP_OPCODE_reply))
+	      next = NEXT_NEIGHBOR_ARP;
+	  }
+	else if (ether_type == ETHERNET_TYPE_IP6)
+	  {
+	    ip6_header_t *ip = (void *) (eth + 1);
+	    icmp46_header_t *icmp = (void *) (ip + 1);
+
+	    if (ip->protocol == IP_PROTOCOL_ICMP6 &&
+		icmp->type == ICMP6_neighbor_advertisement)
+	      next = NEXT_NEIGHBOR_ICMP6;
+	  }
       }
 
       if (next == ~0)
-        {
-          vlib_buffer_free (vm, &bi, 1);
-          continue;
-        }
+	{
+	  vlib_buffer_free (vm, &bi, 1);
+	  continue;
+	}
 
       /* ARP and ICMP6 expect to start processing after the Ethernet header. */
       vlib_buffer_advance (b, sizeof (ethernet_header_t));
@@ -156,39 +156,41 @@ tap_inject_neighbor (vlib_main_t * vm,
       *(to_next++) = bi;
       --n_left;
 
-      vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
-                                       n_left, bi, next);
+      vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, n_left,
+				       bi, next);
       vlib_put_next_frame (vm, node, next_index, n_left);
     }
 
   return f->n_vectors;
 }
 
-VLIB_REGISTER_NODE (tap_inject_neighbor_node) = {
-  .function = tap_inject_neighbor,
-  .name = "tap-inject-neighbor",
-  .vector_size = sizeof (u32),
-  .type = VLIB_NODE_TYPE_INTERNAL,
-  .n_next_nodes = 2,
-  .next_nodes = {
-    [NEXT_NEIGHBOR_ARP] = "arp-input",
-    [NEXT_NEIGHBOR_ICMP6] = "icmp6-neighbor-solicitation",
-  },
+VLIB_REGISTER_NODE(tap_inject_neighbor_node) = {
+    .function = tap_inject_neighbor,
+    .name = "tap-inject-neighbor",
+    .vector_size = sizeof(u32),
+    .type = VLIB_NODE_TYPE_INTERNAL,
+    .n_next_nodes = 2,
+    .next_nodes =
+        {
+            [NEXT_NEIGHBOR_ARP] = "arp-input",
+            [NEXT_NEIGHBOR_ICMP6] = "icmp6-neighbor-solicitation",
+        },
 };
 
-
 #define MTU 1500
-#define MTU_BUFFERS ((MTU + vlib_buffer_get_default_data_size(vm) - 1) / vlib_buffer_get_default_data_size(vm))
+#define MTU_BUFFERS                                                           \
+  ((MTU + vlib_buffer_get_default_data_size (vm) - 1) /                       \
+   vlib_buffer_get_default_data_size (vm))
 #define NUM_BUFFERS_TO_ALLOC 32
 
 static inline uword
-tap_rx (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * f, int fd)
+tap_rx (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *f, int fd)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
   u32 sw_if_index;
   struct iovec iov[MTU_BUFFERS];
   u32 bi[MTU_BUFFERS];
-  vlib_buffer_t * b;
+  vlib_buffer_t *b;
   ssize_t n_bytes;
   ssize_t n_bytes_left;
   u32 i, j;
@@ -202,25 +204,23 @@ tap_rx (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * f, int fd)
     {
       u32 len = vec_len (im->rx_buffers);
 
-
-      u8 index = vlib_buffer_pool_get_default_for_numa (vm,0);
-      len = vlib_buffer_alloc_from_pool(vm,
-                    &im->rx_buffers[len], NUM_BUFFERS_TO_ALLOC,
-                    index);
+      u8 index = vlib_buffer_pool_get_default_for_numa (vm, 0);
+      len = vlib_buffer_alloc_from_pool (vm, &im->rx_buffers[len],
+					 NUM_BUFFERS_TO_ALLOC, index);
 
       _vec_len (im->rx_buffers) += len;
 
       if (vec_len (im->rx_buffers) < MTU_BUFFERS)
-        {
-          clib_warning ("failed to allocate buffers");
-          return 0;
-        }
+	{
+	  clib_warning ("failed to allocate buffers");
+	  return 0;
+	}
     }
 
   /* Fill buffers from the end of the list to make it easier to resize. */
   for (i = 0, j = vec_len (im->rx_buffers) - 1; i < MTU_BUFFERS; ++i, --j)
     {
-      vlib_buffer_t * b;
+      vlib_buffer_t *b;
 
       bi[i] = im->rx_buffers[j];
 
@@ -253,7 +253,8 @@ tap_rx (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * f, int fd)
   b->current_length = n_bytes;
 
   /* If necessary, configure any remaining buffers in the chain. */
-  for (i = 1; n_bytes_left > 0; ++i, n_bytes_left -= VLIB_BUFFER_DEFAULT_DATA_SIZE)
+  for (i = 1; n_bytes_left > 0;
+       ++i, n_bytes_left -= VLIB_BUFFER_DEFAULT_DATA_SIZE)
     {
       b = vlib_get_buffer (vm, bi[i - 1]);
       b->current_length = VLIB_BUFFER_DEFAULT_DATA_SIZE;
@@ -268,9 +269,9 @@ tap_rx (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * f, int fd)
 
   /* Get the packet to the output node. */
   {
-    vnet_hw_interface_t * hw;
-    vlib_frame_t * new_frame;
-    u32 * to_next;
+    vnet_hw_interface_t *hw;
+    vlib_frame_t *new_frame;
+    u32 *to_next;
 
     hw = vnet_get_hw_interface (vnet_get_main (), sw_if_index);
 
@@ -286,20 +287,20 @@ tap_rx (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * f, int fd)
 }
 
 static uword
-tap_inject_rx (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * f)
+tap_inject_rx (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *f)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
-  u32 * fd;
+  tap_inject_main_t *im = tap_inject_get_main ();
+  u32 *fd;
   uword count = 0;
 
   vec_foreach (fd, im->rx_file_descriptors)
     {
       if (tap_rx (vm, node, f, *fd) != 1)
-        {
-          clib_warning ("rx failed");
-          count = 0;
-          break;
-        }
+	{
+	  clib_warning ("rx failed");
+	  count = 0;
+	  break;
+	}
       ++count;
     }
 
@@ -320,7 +321,7 @@ VLIB_REGISTER_NODE (tap_inject_rx_node) = {
  * @brief no-op lock function.
  */
 static void
-tap_inject_dpo_lock (dpo_id_t * dpo)
+tap_inject_dpo_lock (dpo_id_t *dpo)
 {
 }
 
@@ -328,12 +329,12 @@ tap_inject_dpo_lock (dpo_id_t * dpo)
  * @brief no-op unlock function.
  */
 static void
-tap_inject_dpo_unlock (dpo_id_t * dpo)
+tap_inject_dpo_unlock (dpo_id_t *dpo)
 {
 }
 
 u8 *
-format_tap_inject_dpo (u8 * s, va_list * args)
+format_tap_inject_dpo (u8 *s, va_list *args)
 {
   return (format (s, "tap-inject:[%d]", 0));
 }
@@ -355,15 +356,16 @@ const static char *const *const tap_inject_nodes[DPO_PROTO_NUM] = {
 };
 
 static clib_error_t *
-tap_inject_init (vlib_main_t * vm)
+tap_inject_init (vlib_main_t *vm)
 {
-  tap_inject_main_t * im = tap_inject_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
 
   im->rx_node_index = tap_inject_rx_node.index;
   im->tx_node_index = tap_inject_tx_node.index;
   im->neighbor_node_index = tap_inject_neighbor_node.index;
 
-  tap_inject_dpo_type = dpo_register_new_type (&tap_inject_vft, tap_inject_nodes);
+  tap_inject_dpo_type =
+    dpo_register_new_type (&tap_inject_vft, tap_inject_nodes);
 
   vec_alloc (im->rx_buffers, NUM_BUFFERS_TO_ALLOC);
   vec_reset_length (im->rx_buffers);
diff --git a/extras/router-plugin/rtinject/tap_inject_tap.c b/extras/router-plugin/rtinject/tap_inject_tap.c
index a3ec9ffef..44c494347 100644
--- a/extras/router-plugin/rtinject/tap_inject_tap.c
+++ b/extras/router-plugin/rtinject/tap_inject_tap.c
@@ -17,23 +17,23 @@
 #include "tap_inject.h"
 
 #include <fcntl.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
 #include <linux/if.h>
 #include <linux/if_arp.h>
 #include <linux/if_ether.h>
 #include <linux/if_tun.h>
 #include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <vnet/unix/tuntap.h>
 
+#include <hicn/util/sstrncpy.h>
 #include <vlib/unix/unix.h>
 
-
 static clib_error_t *
-tap_inject_tap_read (clib_file_t * f)
+tap_inject_tap_read (clib_file_t *f)
 {
-  vlib_main_t * vm = vlib_get_main ();
-  tap_inject_main_t * im = tap_inject_get_main ();
+  vlib_main_t *vm = vlib_get_main ();
+  tap_inject_main_t *im = tap_inject_get_main ();
 
   vec_add1 (im->rx_file_descriptors, f->file_descriptor);
 
@@ -45,16 +45,16 @@ tap_inject_tap_read (clib_file_t * f)
 #define TAP_INJECT_TAP_BASE_NAME "vpp"
 
 clib_error_t *
-tap_inject_tap_connect (vnet_hw_interface_t * hw)
+tap_inject_tap_connect (vnet_hw_interface_t *hw)
 {
-  vnet_main_t * vnet_main = vnet_get_main ();
-  vnet_sw_interface_t * sw = vnet_get_sw_interface (vnet_main, hw->hw_if_index);
+  vnet_main_t *vnet_main = vnet_get_main ();
+  vnet_sw_interface_t *sw = vnet_get_sw_interface (vnet_main, hw->hw_if_index);
   static const int one = 1;
   int fd;
   struct ifreq ifr;
   clib_file_t template;
   u32 tap_fd;
-  u8 * name;
+  u8 *name;
 
   memset (&ifr, 0, sizeof (ifr));
   memset (&template, 0, sizeof (template));
@@ -64,15 +64,16 @@ tap_inject_tap_connect (vnet_hw_interface_t * hw)
   /* Create the tap. */
   tap_fd = open ("/dev/net/tun", O_RDWR);
 
-  if ((int)tap_fd < 0)
+  if ((int) tap_fd < 0)
     return clib_error_return (0, "failed to open tun device");
 
   name = format (0, TAP_INJECT_TAP_BASE_NAME "%u%c", hw->hw_instance, 0);
 
-  strncpy (ifr.ifr_name, (char *) name, sizeof (ifr.ifr_name) - 1);
+  strcpy_s (ifr.ifr_name, IFNAMSIZ, (char *) name);
+  ifr.ifr_name[IFNAMSIZ - 1] = '\0';
   ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
 
-  if (ioctl (tap_fd, TUNSETIFF, (void *)&ifr) < 0)
+  if (ioctl (tap_fd, TUNSETIFF, (void *) &ifr) < 0)
     {
       close (tap_fd);
       return clib_error_return (0, "failed to create tap");
@@ -142,9 +143,8 @@ tap_inject_tap_disconnect (u32 sw_if_index)
   return 0;
 }
 
-
 u8 *
-format_tap_inject_tap_name (u8 * s, va_list * args)
+format_tap_inject_tap_name (u8 *s, va_list *args)
 {
   int fd;
   struct ifreq ifr;
diff --git a/extras/sysrepo/CMakeLists.txt b/extras/sysrepo/CMakeLists.txt
index edf78105a..803b2ae3e 100644
--- a/extras/sysrepo/CMakeLists.txt
+++ b/extras/sysrepo/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/extras/sysrepo/cmake/Modules/Packaging.cmake b/extras/sysrepo/cmake/Modules/Packaging.cmake
index 2433539c7..d7ef2c79c 100644
--- a/extras/sysrepo/cmake/Modules/Packaging.cmake
+++ b/extras/sysrepo/cmake/Modules/Packaging.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -31,5 +31,3 @@ set(sysrepo_RPM_DEPENDENCIES
     "libyang >= 1.0"
     CACHE STRING "Dependencies for deb/rpm package."
 )
-
-
diff --git a/cmake/Modules/FindUncrustify.cmake b/hicn-light/.clang-format
index f8f6b00b8..2dc5c0c54 100644
--- a/cmake/Modules/FindUncrustify.cmake
+++ b/hicn-light/.clang-format
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,11 +11,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Find uncrustify program
-#
-find_program( UNCRUSTIFY_BIN uncrustify
-                PATHS
-				$ENV{UNCRUSTIFY_HOME}
-				)
-
-message( "-- UNCRUSTIFY found in ${UNCRUSTIFY_BIN}" )
+BasedOnStyle:  Google
+SortIncludes: false
diff --git a/hicn-light/CMakeLists.txt b/hicn-light/CMakeLists.txt
index 64b93d997..337e22b7f 100644
--- a/hicn-light/CMakeLists.txt
+++ b/hicn-light/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,115 +11,109 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+##############################################################
+# Project and cmake version
+##############################################################
 cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
-
 project(hicn-light)
 
-if (NOT CMAKE_BUILD_TYPE)
-    message(STATUS "${PROJECT_NAME}: No build type selected, default to Release")
-    set(CMAKE_BUILD_TYPE "Release")
-endif()
 
+##############################################################
+# Libs and Bins names
+##############################################################
+set(LIBHICN_LIGHT hicn-light)
+set(LIBHICN_LIGHT_STATIC ${LIBHICN_LIGHT}.static)
+
+
+##############################################################
+# Packaging and versioning
+##############################################################
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/packaging.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/../versions.cmake)
+
+
+##############################################################
+# Cmake modules
+##############################################################
 set(CMAKE_MODULE_PATH
   ${CMAKE_MODULE_PATH}
   "${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Modules"
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
 )
 
+
+##############################################################
+# C Standard
+##############################################################
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 
-option(ENABLE_PUNTING "Enable punting on linux systems" ON)
-
-include( CTest )
-include( detectCacheSize )
 
-if(NOT WIN32)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
-else ()
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4996")
-endif ()
+##############################################################
+# Libs and Bins names
+##############################################################
+set(HICN_LIGHT hicn-light CACHE INTERNAL "" FORCE)
+set(HICN_LIGHT_CONTROL ${HICN_LIGHT}-control CACHE INTERNAL "" FORCE)
+set(HICN_LIGHT_SHELL ${HICN_LIGHT}-shell CACHE INTERNAL "" FORCE)
+set(HICN_LIGHT_DAEMON ${HICN_LIGHT}-daemon CACHE INTERNAL "" FORCE)
 
-if(${CMAKE_SYSTEM_NAME} STREQUAL "Android")
-  message("############ Detected cross compile for $ENV{CMAKE_SYSTEM_NAME}")
-  # Android uses static libs, so we need to link all the dependencies to the executable
-  find_package(OpenSSL REQUIRED)
-  find_package(LibEvent REQUIRED)
-  set(ANDROID_LIBRARIES ${LIBEVENT_LIBRARIES} ${OPENSSL_LIBRARIES})
-endif()
 
-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -DLIBRTA_DISABLE_VALIDATION -DPARCLibrary_DISABLE_VALIDATION")
+##############################################################
+# Dependencies and third party libs
+##############################################################
+find_package(LibEvent ${LIBEVENT_DEFAULT_VERSION} REQUIRED)
+find_package(Threads REQUIRED)
 
-include(IosMacros)
-include(WindowsMacros)
 
-find_package(Libparc REQUIRED)
+##############################################################
+# Check if building as subproject or as root project
+##############################################################
+if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+  include(CommonSetup)
+  find_package(Libhicn ${CURRENT_VERSION} REQUIRED NO_MODULE)
+  find_package(Libhicnctrl ${CURRENT_VERSION} REQUIRED NO_MODULE)
 
-set(HICN_LIGHT hicn-light CACHE INTERNAL "" FORCE)
-set(HICN_LIGHT_CONTROL ${HICN_LIGHT}-control CACHE INTERNAL "" FORCE)
-set(HICN_LIGHT_DAEMON ${HICN_LIGHT}-daemon CACHE INTERNAL "" FORCE)
+  if (DISABLE_SHARED_LIBRARIES)
+    set(LIBTYPE static)
+  else()
+    set(LIBTYPE shared)
+  endif()
 
-if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-  find_package(Libhicn REQUIRED)
+  list(APPEND HICN_LIBRARIES hicn::hicn.${LIBTYPE})
+  list(APPEND LIBHICNCTRL_LIBRARIES hicn::hicnctrl.${LIBTYPE})
 else()
   if (DISABLE_SHARED_LIBRARIES)
-    if (WIN32) 
-      set(HICN_LIBRARIES ${LIBHICN_STATIC})
+    if (WIN32)
+      set(HICN_LIBRARIES ${LIBHICN_STATIC} ${LIBHICNCTRL_STATIC})
     else ()
-      set(HICN_LIBRARIES ${LIBHICN_STATIC} log)
+      set(HICN_LIBRARIES ${LIBHICN_STATIC} ${LIBHICNCTRL_STATIC} log)
     endif ()
     list(APPEND DEPENDENCIES
       ${LIBHICN_STATIC}
+      ${LIBHICNCTRL_STATIC}
     )
   else ()
-    set(HICN_LIBRARIES ${LIBHICN_SHARED})
+    set(HICN_LIBRARIES
+      ${LIBHICN_SHARED}
+      ${LIBHICNCTRL_SHARED}
+    )
     list(APPEND DEPENDENCIES
       ${LIBHICN_SHARED}
+      ${LIBHICNCTRL_SHARED}
     )
   endif ()
 endif()
 
-include(Packaging)
-
-find_package(Threads REQUIRED)
-
-set(LIBHICN_LIGHT hicn-light)
-set(LIBHICN_LIGHT_STATIC ${LIBHICN_LIGHT}.static)
-
-set(LIBRARIES
-  ${LIBPARC_LIBRARIES}
-  ${HICN_LIBRARIES}
-  ${CMAKE_THREAD_LIBS_INIT}
-  ${WINDOWS_LIBRARIES}
-  ${ANDROID_LIBRARIES}
-)
-
-set(HICN_LIGHT_LIBRARIES_LIST "${LIBPARC_LIBRARIES};${CMAKE_THREAD_LIBS_INIT};${WINDOWS_LIBRARIES}" CACHE INTERNAL "HICN_LIGHT_LIBRARIES_LIST")
-
-
-# Include dirs -- Order does matter!
-list(APPEND HICN_LIGHT_INCLUDE_DIRS
-  ${HICN_INCLUDE_DIRS}
-  ${LIBPARC_INCLUDE_DIRS}
-  ${WINDOWS_INCLUDE_DIRS}
-)
-
-if (UNIX)
-  list(APPEND LIBRARIES
-    m
-  )
-endif()
-
-set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
-
-if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
-  set(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS} -undefined dynamic_lookup")
-	message(STATUS "Set \"-undefined dynamic_lookup\" for shared libraries")
-endif()
 
+##############################################################
+# Subdirectories
+##############################################################
 add_subdirectory(src/hicn)
 
+
+##############################################################
 # Install service file in linux systems
+##############################################################
 include(ServiceScript)
 install_service_script(
   ${CMAKE_CURRENT_SOURCE_DIR}/config/hicn-light.service
diff --git a/hicn-light/cmake/Modules/Packaging.cmake b/hicn-light/cmake/packaging.cmake
index 2b9f4a7b9..ccf567e41 100644
--- a/hicn-light/cmake/Modules/Packaging.cmake
+++ b/hicn-light/cmake/packaging.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -21,7 +21,7 @@ set(${HICN_LIGHT}_DESCRIPTION
 )
 
 set(${HICN_LIGHT}_DEB_DEPENDENCIES
-  "lib${LIBHICN} (>= stable_version), libparc (>= 1.0)"
+  "lib${LIBHICN} (= stable_version)"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
@@ -31,7 +31,7 @@ set(${HICN_LIGHT}_DEB_PACKAGE_CONTROL_EXTRA
 )
 
 set(${HICN_LIGHT}_RPM_DEPENDENCIES
-  "lib${LIBHICN} >= stable_version, libparc >= 1.0"
+  "lib${LIBHICN} = stable_version"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
diff --git a/hicn-light/config/hicn-light.service b/hicn-light/config/hicn-light.service
index f269b2f26..79d5ced93 100644
--- a/hicn-light/config/hicn-light.service
+++ b/hicn-light/config/hicn-light.service
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/hicn-light/config/post b/hicn-light/config/post
index 91f596050..f2f566426 100755
--- a/hicn-light/config/post
+++ b/hicn-light/config/post
@@ -2,4 +2,4 @@
 
 if pidof systemd; then
   systemctl enable hicn-light
-fi
+fi
\ No newline at end of file
diff --git a/hicn-light/config/postinst b/hicn-light/config/postinst
index dced2a093..f2f566426 100755
--- a/hicn-light/config/postinst
+++ b/hicn-light/config/postinst
@@ -1,3 +1,5 @@
 #!/bin/bash
 
-systemctl enable hicn-light
\ No newline at end of file
+if pidof systemd; then
+  systemctl enable hicn-light
+fi
\ No newline at end of file
diff --git a/hicn-light/config/prerm b/hicn-light/config/prerm
index 4584c7057..c1d3d55a1 100755
--- a/hicn-light/config/prerm
+++ b/hicn-light/config/prerm
@@ -1,3 +1,5 @@
 #!/bin/bash
 
-systemctl disable hicn-light
\ No newline at end of file
+if pidof systemd; then
+  systemctl disable hicn-light
+fi
\ No newline at end of file
diff --git a/hicn-light/config/preun b/hicn-light/config/preun
index 4584c7057..c1d3d55a1 100755
--- a/hicn-light/config/preun
+++ b/hicn-light/config/preun
@@ -1,3 +1,5 @@
 #!/bin/bash
 
-systemctl disable hicn-light
\ No newline at end of file
+if pidof systemd; then
+  systemctl disable hicn-light
+fi
\ No newline at end of file
diff --git a/hicn-light/src/hicn/CMakeLists.txt b/hicn-light/src/hicn/CMakeLists.txt
index 639bfa179..401ae84eb 100644
--- a/hicn-light/src/hicn/CMakeLists.txt
+++ b/hicn-light/src/hicn/CMakeLists.txt
@@ -1,55 +1,129 @@
-# Define a few configuration variables that we want accessible in the software
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 
-include(BuildMacros)
+##############################################################
+# Libraries to link
+##############################################################
+set(LIBRARIES
+  PUBLIC ${HICN_LIBRARIES}
+  PUBLIC ${LIBHICNCTRL_LIBRARIES}
+  PRIVATE ${LIBEVENT_LIBRARIES}
+  PRIVATE ${CMAKE_THREAD_LIBS_INIT}
+)
+
+if (UNIX)
+  list(APPEND LIBRARIES
+    m
+  )
+endif()
+
+
+##############################################################
+# Configuration file
+##############################################################
 configure_file(config.h.in hicn-light/config.h @ONLY)
 
-if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" AND ENABLE_PUNTING)
+
+##############################################################
+# Compiler definitions
+##############################################################
+list(APPEND COMPILER_DEFINITIONS
+  PRIVATE -DLIBRTA_DISABLE_VALIDATION
+)
+
+list(APPEND COMPILER_DEFINITIONS
+#  "-DWITH_GRO"
+#  "-DWITH_GSO"
+#  "-DWITH_ZEROCOPY"
+  PRIVATE "-DWITH_POLICY_STATS"
+  PRIVATE "-DWITH_CLI"
+#  "-DNDEBUG=1" # disable assertions
+)
+
+if (UNIX AND NOT APPLE)
   list(APPEND COMPILER_DEFINITIONS
-    "-DPUNTING"
+    "-D_GNU_SOURCE" # batching support through struct mmsghdr
   )
 endif()
 
-list(APPEND COMPILER_DEFINITIONS
-  "-DWITH_MAPME"
-  "-DWITH_POLICY"
+
+##############################################################
+# Compiler options
+##############################################################
+set(COMPILER_OPTIONS
+  ${DEFAULT_COMPILER_OPTIONS}
 )
 
+##############################################################
+# Sources
+##############################################################
 if (NOT DISABLE_EXECUTABLES)
-  add_subdirectory(command_line)
+  add_subdirectory(cli)
 endif()
 
+add_subdirectory(base)
 add_subdirectory(config)
 add_subdirectory(content_store)
 add_subdirectory(core)
 add_subdirectory(io)
-add_subdirectory(messenger)
 add_subdirectory(platforms)
-add_subdirectory(processor)
 add_subdirectory(socket)
 add_subdirectory(strategies)
 add_subdirectory(utils)
 
+list(APPEND TO_INSTALL_HEADER_FILES
+  ${HEADER_FILES}
+)
+
 list(APPEND HEADER_FILES
   ${CMAKE_CURRENT_BINARY_DIR}/hicn-light/config.h
 )
 
-list(INSERT HICN_LIGHT_INCLUDE_DIRS 0
-  ${CMAKE_CURRENT_SOURCE_DIR}/..
-  ${CMAKE_CURRENT_BINARY_DIR}/..
+
+##############################################################
+# Includes
+##############################################################
+list(APPEND HICN_LIGHT_INCLUDE_DIRS
+  PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/..>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+  PRIVATE
+    ${LIBEVENT_INCLUDE_DIRS}
+    ${WINDOWS_INCLUDE_DIRS}
 )
 
 list(APPEND TO_INSTALL_HEADER_FILES
   ${CMAKE_CURRENT_BINARY_DIR}/hicn-light/config.h
 )
 
+
+##############################################################
+# Build type
+##############################################################
+set(LIB_BUILD_TYPE STATIC)
 if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Android")
-  set(LIB_BUILD_TYPE "NO_DEV")
-else()
-  set(LIB_BUILD_TYPE "")
+  list(APPEND LIB_BUILD_TYPE
+    "NO_DEV"
+  )
 endif()
 
+
+##############################################################
+# Build forwarder library
+##############################################################
 build_library(${LIBHICN_LIGHT}
-  STATIC ${LIB_BUILD_TYPE}
+  ${LIB_BUILD_TYPE}
   SOURCES ${SOURCE_FILES}
   INSTALL_HEADERS ${TO_INSTALL_HEADER_FILES}
   LINK_LIBRARIES ${LIBRARIES}
@@ -57,6 +131,14 @@ build_library(${LIBHICN_LIGHT}
   COMPONENT ${HICN_LIGHT}
   INCLUDE_DIRS ${HICN_LIGHT_INCLUDE_DIRS}
   HEADER_ROOT_DIR hicn
-  DEFINITIONS ${COMPILER_DEFINITIONS}
+  DEFINITIONS PUBLIC ${COMPILER_DEFINITIONS}
+  COMPILE_OPTIONS ${COMPILER_OPTIONS}
 )
 
+
+##############################################################
+# Build tests
+##############################################################
+if (BUILD_TESTS)
+  add_subdirectory(test)
+endif()
diff --git a/hicn-light/src/hicn/messenger/CMakeLists.txt b/hicn-light/src/hicn/base/CMakeLists.txt
index 69a6c32d1..1180ed05b 100644
--- a/hicn-light/src/hicn/messenger/CMakeLists.txt
+++ b/hicn-light/src/hicn/base/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -12,19 +12,28 @@
 # limitations under the License.
 
 list(APPEND HEADER_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/missiveDeque.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/missive.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/missiveType.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/messenger.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/messengerRecipient.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/bitmap.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/common.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hash.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/khash.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/loop.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/pool.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/ring.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/vector.h
 )
 
 list(APPEND SOURCE_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/messenger.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/messengerRecipient.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/missive.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/missiveDeque.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/loop.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/pool.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/ring.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/vector.c
 )
 
 set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
-set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
\ No newline at end of file
+set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
+
+set(TO_INSTALL_HEADER_FILES
+  ${TO_INSTALL_HEADER_FILES}
+  ${HEADER_FILES}
+  PARENT_SCOPE
+)
diff --git a/hicn-light/src/hicn/base/bitmap.h b/hicn-light/src/hicn/base/bitmap.h
new file mode 100644
index 000000000..ed3fac2fd
--- /dev/null
+++ b/hicn-light/src/hicn/base/bitmap.h
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file bitmap.h
+ * \brief Bitmap
+ *
+ * A bitmap is implemented as a wrapper over a vector made of bit elements
+ */
+
+#ifndef UTIL_BITMAP_H
+#define UTIL_BITMAP_H
+
+#include <assert.h>
+#include <string.h>
+#include <sys/param.h>  // MIN, MAX
+
+#include <hicn/util/log.h>
+
+#include "common.h"
+#include "vector.h"
+
+typedef uint_fast32_t bitmap_t;
+
+#define BITMAP_WIDTH(bitmap) (sizeof((bitmap)[0]) * 8)
+
+/**
+ * @brief Allocate and initialize a bitmap
+ *
+ * @param[in,out] bitmap Bitmap to allocate and initialize
+ * @param[in] max_size Bitmap max_size
+ */
+#define bitmap_init(bitmap, init_size, max_size)             \
+  vector_init(                                               \
+      bitmap, next_pow2((init_size) / BITMAP_WIDTH(bitmap)), \
+      max_size == 0 ? 0 : next_pow2((max_size) / BITMAP_WIDTH(bitmap)))
+
+/*
+ * @brief Ensures a bitmap is sufficiently large to hold an element at the
+ * given position.
+ *
+ * @param[in] bitmap The bitmap for which to validate the position.
+ * @param[in] pos The position to validate.
+ *
+ * NOTE:
+ *  - This function should always be called before writing to a bitmap element
+ *  to eventually make room for it (the bitmap will eventually be resized).
+ */
+static inline int bitmap_ensure_pos(bitmap_t** bitmap, off_t pos) {
+  size_t offset = pos / BITMAP_WIDTH(*bitmap);
+  return vector_ensure_pos(*bitmap, offset);
+}
+
+/**
+ * @brief Returns the allocated size of a bitmap.
+ *
+ * @see listener_table_get_by_id
+ */
+#define bitmap_get_alloc_size(bitmap) vector_get_alloc_size(bitmap)
+
+/**
+ * @brief Retrieve the state of the i-th bit in the bitmap.
+ *
+ * @param[in] bitmap The bitmap to access.
+ * @param[in] i The bit position.
+ */
+static inline int bitmap_get(const bitmap_t* bitmap, off_t i) {
+  size_t offset = i / BITMAP_WIDTH(bitmap);
+  assert(offset < bitmap_get_alloc_size(bitmap));
+  size_t pos = i % BITMAP_WIDTH(bitmap);
+  size_t shift = BITMAP_WIDTH(bitmap) - pos - 1;
+  return (bitmap[offset] >> shift) & 1;
+}
+
+/*
+ * @brief Returns whether the i-th bit is set (equal to 1) in a bitmap.
+ *
+ * @param[in] bitmap The bitmap to access.
+ * @param[in] i The bit position.
+ *
+ * @return bool
+ */
+#define bitmap_is_set(bitmap, i) (bitmap_get((bitmap), (i)) == 1)
+#define bitmap_is_unset(bitmap, i) (bitmap_get((bitmap), (i)) == 0)
+
+/*
+ * @brief Returns whether the i-th bit is unset (equal to 0) in a bitmap.
+ *
+ * @param[in] bitmap The bitmap to access.
+ * @param[in] i The bit position.
+ *
+ * @return bool
+ */
+#define bitmap_set(bitmap, i) _bitmap_set((bitmap_t**)&bitmap, i)
+
+/*
+ * @brief Returns whether the i-th bit is unset (equal to 0) in a bitmap
+ * (helper).
+ *
+ * @param[in] bitmap The bitmap to access.
+ * @param[in] i The bit position.
+ *
+ * @return bool
+ */
+static inline int _bitmap_set(bitmap_t** bitmap, off_t i) {
+  if (bitmap_ensure_pos(bitmap, i) < 0) return -1;
+  size_t offset = i / BITMAP_WIDTH(bitmap);
+  size_t pos = i % BITMAP_WIDTH(bitmap);
+  size_t shift = BITMAP_WIDTH(bitmap) - pos - 1;
+  (*bitmap)[offset] |= (bitmap_t)1 << shift;
+  return 0;
+}
+
+static inline int bitmap_unset(bitmap_t* bitmap, off_t i) {
+  if (bitmap_ensure_pos(&bitmap, i) < 0) return -1;
+  size_t offset = i / BITMAP_WIDTH(bitmap);
+  size_t pos = i % BITMAP_WIDTH(bitmap);
+  size_t shift = BITMAP_WIDTH(bitmap) - pos - 1;
+  bitmap[offset] &= ~(1ul << shift);
+  return 0;
+}
+
+static inline int bitmap_set_range(bitmap_t* bitmap, off_t from, off_t to) {
+  assert(from <= to);
+  ssize_t offset_from = from / BITMAP_WIDTH(bitmap);
+  ssize_t offset_to = to / BITMAP_WIDTH(bitmap);
+  size_t pos_from = from % BITMAP_WIDTH(bitmap);
+  size_t pos_to = to % BITMAP_WIDTH(bitmap);
+
+  /*
+   * First block initialization is needed if <from> is not aligned with the
+   * bitmap element size or if to is within the same one.
+   */
+  if ((pos_from != 0) ||
+      ((offset_to == offset_from) && (pos_to != BITMAP_WIDTH(bitmap) - 1))) {
+    size_t from_end = MIN(to, (offset_from + 1) * BITMAP_WIDTH(bitmap));
+    for (size_t k = from; k < from_end; k++) {
+      if (bitmap_set(bitmap, k) < 0) goto END;
+    }
+  }
+
+  /*
+   * Second block is needed if <to> is not aligned with the bitmap element
+   * size
+   */
+  if ((pos_to != BITMAP_WIDTH(bitmap) - 1) && (offset_to != offset_from)) {
+    size_t to_start = MAX(from, offset_to * BITMAP_WIDTH(bitmap));
+    for (size_t k = to_start; k < (size_t)to; k++) {
+      if (bitmap_set(bitmap, k) < 0) goto END;
+    }
+  }
+
+  if (pos_from != 0) offset_from += 1;
+  if (pos_to != BITMAP_WIDTH(bitmap) - 1) offset_to -= 1;
+
+  /*
+   * We need to cover both elements at position offset_from and offset_to
+   * provided that offset_from is not bigger
+   */
+  if (offset_to >= offset_from) {
+    memset(&bitmap[offset_from], 0xFF,
+           (offset_to - offset_from + 1) * sizeof(bitmap[0]));
+  }
+
+  return 0;
+
+END:
+  ERROR("Error setting bitmap range\n");
+  return -1;
+}
+
+#define bitmap_set_to(bitmap, to) bitmap_set_range((bitmap), 0, (to))
+
+#define bitmap_free(bitmap) vector_free(bitmap)
+
+#endif /* UTIL_BITMAP_H */
diff --git a/hicn-light/src/hicn/base/common.h b/hicn-light/src/hicn/base/common.h
new file mode 100644
index 000000000..9f7e3beec
--- /dev/null
+++ b/hicn-light/src/hicn/base/common.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file array.h
+ * \brief Fixed-size pool allocator
+ */
+
+#ifndef UTIL_COMMON_H
+#define UTIL_COMMON_H
+
+#define round_pow2(x, pow2) ((x + pow2 - 1) & ~(pow2 - 1))
+
+#define _SIZEOF_ALIGNED(x, size) round_pow2(sizeof(x), size)
+#define SIZEOF_ALIGNED(x) _SIZEOF_ALIGNED(x, sizeof(void*))
+
+/* Definitions for builtins unavailable on MSVC */
+#if defined(_MSC_VER) && !defined(__clang__)
+#include <intrin.h>
+
+uint32_t __inline __builtin_ctz(uint32_t value) {
+  uint32_t trailing_zero = 0;
+  if (_BitScanForward(&trailing_zero, value))
+    return trailing_zero;
+  else
+    return 32;
+}
+
+uint32_t __inline __builtin_clz(uint32_t value) {
+  uint32_t leading_zero = 0;
+  if (_BitScanReverse(&leading_zero, value))
+    return 31 - leading_zero;
+  else
+    return 32;
+}
+
+uint32_t __inline __builtin_clzl2(uint64_t value) {
+  uint32_t leading_zero = 0;
+  if (_BitScanReverse64(&leading_zero, value))
+    return 63 - leading_zero;
+  else
+    return 64;
+}
+
+#define __builtin_clzl __builtin_clzll
+#endif
+
+#define next_pow2(x) (x <= 1 ? 1 : 1ul << (64 - __builtin_clzl(x - 1)))
+
+#endif /* UTIL_COMMON_H */
diff --git a/hicn-light/src/hicn/base/hash.h b/hicn-light/src/hicn/base/hash.h
new file mode 100644
index 000000000..3c54feb29
--- /dev/null
+++ b/hicn-light/src/hicn/base/hash.h
@@ -0,0 +1,349 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * \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
+
+#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(buf, len) hashlittle(buf, len, HASH_INITVAL)
+#define hash_struct(buf) hash(buf, sizeof(*buf))
+
+#define str_hash(str) (hash(str, strlen(str)))
+#define str_hash_eq(a, b) (str_hash(b) - str_hash(a))
+
+#endif /* UTIL_JENKINS_HASH_H */
diff --git a/hicn-light/src/hicn/base/khash.h b/hicn-light/src/hicn/base/khash.h
new file mode 100644
index 000000000..4c62b0260
--- /dev/null
+++ b/hicn-light/src/hicn/base/khash.h
@@ -0,0 +1,748 @@
+/* The MIT License
+
+   Copyright (c) 2008, 2009, 2011 by Attractive Chaos <attractor@live.co.uk>
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   "Software"), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+*/
+
+/*
+  An example:
+
+#include "khash.h"
+KHASH_MAP_INIT_INT(32, char)
+int main() {
+        int ret, is_missing;
+        khiter_t k;
+        khash_t(32) *h = kh_init(32);
+        k = kh_put(32, h, 5, &ret);
+        kh_value(h, k) = 10;
+        k = kh_get(32, h, 10);
+        is_missing = (k == kh_end(h));
+        k = kh_get(32, h, 5);
+        kh_del(32, h, k);
+        for (k = kh_begin(h); k != kh_end(h); ++k)
+                if (kh_exist(h, k)) kh_value(h, k) = 1;
+        kh_destroy(32, h);
+        return 0;
+}
+*/
+
+/*
+  2013-05-02 (0.2.8):
+
+        * Use quadratic probing. When the capacity is power of 2, stepping
+  function i*(i+1)/2 guarantees to traverse each bucket. It is better than
+  double hashing on cache performance and is more robust than linear probing.
+
+          In theory, double hashing should be more robust than quadratic
+  probing. However, my implementation is probably not for large hash tables,
+  because the second hash function is closely tied to the first hash function,
+          which reduce the effectiveness of double hashing.
+
+        Reference: http://research.cs.vt.edu/AVresearch/hashing/quadratic.php
+
+  2011-12-29 (0.2.7):
+
+    * Minor code clean up; no actual effect.
+
+  2011-09-16 (0.2.6):
+
+        * The capacity is a power of 2. This seems to dramatically improve the
+          speed for simple keys. Thank Zilong Tan for the suggestion. Reference:
+
+           - http://code.google.com/p/ulib/
+           - http://nothings.org/computer/judy/
+
+        * Allow to optionally use linear probing which usually has better
+          performance for random input. Double hashing is still the default as
+  it is more robust to certain non-random input.
+
+        * Added Wang's integer hash function (not used by default). This hash
+          function is more robust to certain non-random input.
+
+  2011-02-14 (0.2.5):
+
+    * Allow to declare global functions.
+
+  2009-09-26 (0.2.4):
+
+    * Improve portability
+
+  2008-09-19 (0.2.3):
+
+        * Corrected the example
+        * Improved interfaces
+
+  2008-09-11 (0.2.2):
+
+        * Improved speed a little in kh_put()
+
+  2008-09-10 (0.2.1):
+
+        * Added kh_clear()
+        * Fixed a compiling error
+
+  2008-09-02 (0.2.0):
+
+        * Changed to token concatenation which increases flexibility.
+
+  2008-08-31 (0.1.2):
+
+        * Fixed a bug in kh_get(), which has not been tested previously.
+
+  2008-08-31 (0.1.1):
+
+        * Added destructor
+*/
+
+#ifndef __AC_KHASH_H
+#define __AC_KHASH_H
+
+/*!
+  @header
+
+  Generic hash table library.
+ */
+
+#define AC_VERSION_KHASH_H "0.2.8"
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+/* compiler specific configuration */
+
+#if UINT_MAX == 0xffffffffu
+typedef unsigned int khint32_t;
+#elif ULONG_MAX == 0xffffffffu
+typedef unsigned long khint32_t;
+#endif
+
+#if ULONG_MAX == ULLONG_MAX
+typedef unsigned long khint64_t;
+#else
+typedef unsigned long long khint64_t;
+#endif
+
+#ifndef kh_inline
+#ifdef _MSC_VER
+#define kh_inline __inline
+#else
+#define kh_inline inline
+#endif
+#endif /* kh_inline */
+
+#ifndef klib_unused
+#if (defined __clang__ && __clang_major__ >= 3) || \
+    (defined __GNUC__ && __GNUC__ >= 3)
+#define klib_unused __attribute__((__unused__))
+#else
+#define klib_unused
+#endif
+#endif /* klib_unused */
+
+typedef khint32_t khint_t;
+typedef khint_t khiter_t;
+
+#define __ac_isempty(flag, i) ((flag[i >> 4] >> ((i & 0xfU) << 1)) & 2)
+#define __ac_isdel(flag, i) ((flag[i >> 4] >> ((i & 0xfU) << 1)) & 1)
+#define __ac_iseither(flag, i) ((flag[i >> 4] >> ((i & 0xfU) << 1)) & 3)
+#define __ac_set_isdel_false(flag, i) \
+  (flag[i >> 4] &= ~(1ul << ((i & 0xfU) << 1)))
+#define __ac_set_isempty_false(flag, i) \
+  (flag[i >> 4] &= ~(2ul << ((i & 0xfU) << 1)))
+#define __ac_set_isboth_false(flag, i) \
+  (flag[i >> 4] &= ~(3ul << ((i & 0xfU) << 1)))
+#define __ac_set_isdel_true(flag, i) (flag[i >> 4] |= 1ul << ((i & 0xfU) << 1))
+
+#define __ac_fsize(m) ((m) < 16 ? 1 : (m) >> 4)
+
+#ifndef kroundup32
+#define kroundup32(x)                                                         \
+  (--(x), (x) |= (x) >> 1, (x) |= (x) >> 2, (x) |= (x) >> 4, (x) |= (x) >> 8, \
+   (x) |= (x) >> 16, ++(x))
+#endif
+
+#ifndef kcalloc
+#define kcalloc(N, Z) calloc(N, Z)
+#endif
+#ifndef kmalloc
+#define kmalloc(Z) malloc(Z)
+#endif
+#ifndef krealloc
+#define krealloc(P, Z) realloc(P, Z)
+#endif
+#ifndef kfree
+#define kfree(P) free(P)
+#endif
+
+static const double __ac_HASH_UPPER = 0.77;
+
+#define __KHASH_TYPE(name, khkey_t, khval_t)          \
+  typedef struct kh_##name##_s {                      \
+    khint_t n_buckets, size, n_occupied, upper_bound; \
+    khint32_t *flags;                                 \
+    khkey_t *keys;                                    \
+    khval_t *vals;                                    \
+  } kh_##name##_t;
+
+#define __KHASH_PROTOTYPES(name, khkey_t, khval_t)                       \
+  extern kh_##name##_t *kh_init_##name(void);                            \
+  extern void kh_destroy_##name(kh_##name##_t *h);                       \
+  extern void kh_clear_##name(kh_##name##_t *h);                         \
+  extern khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key);     \
+  extern int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets);  \
+  extern khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret); \
+  extern void kh_del_##name(kh_##name##_t *h, khint_t x);
+
+#define __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func,    \
+                     __hash_equal)                                             \
+  SCOPE kh_##name##_t *kh_init_##name(void) {                                  \
+    return (kh_##name##_t *)kcalloc(1, sizeof(kh_##name##_t));                 \
+  }                                                                            \
+  SCOPE void kh_destroy_##name(kh_##name##_t *h) {                             \
+    if (h) {                                                                   \
+      kfree((void *)h->keys);                                                  \
+      kfree(h->flags);                                                         \
+      kfree((void *)h->vals);                                                  \
+      kfree(h);                                                                \
+    }                                                                          \
+  }                                                                            \
+  SCOPE void kh_clear_##name(kh_##name##_t *h) {                               \
+    if (h && h->flags) {                                                       \
+      memset(h->flags, 0xaa, __ac_fsize(h->n_buckets) * sizeof(khint32_t));    \
+      h->size = h->n_occupied = 0;                                             \
+    }                                                                          \
+  }                                                                            \
+  SCOPE khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key) {           \
+    if (h->n_buckets) {                                                        \
+      khint_t k, i, last, mask, step = 0;                                      \
+      mask = h->n_buckets - 1;                                                 \
+      k = __hash_func(key);                                                    \
+      i = k & mask;                                                            \
+      last = i;                                                                \
+      while (!__ac_isempty(h->flags, i) &&                                     \
+             (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) {    \
+        i = (i + (++step)) & mask;                                             \
+        if (i == last) return h->n_buckets;                                    \
+      }                                                                        \
+      return __ac_iseither(h->flags, i) ? h->n_buckets : i;                    \
+    } else                                                                     \
+      return 0;                                                                \
+  }                                                                            \
+  SCOPE int kh_resize_##name(                                                  \
+      kh_##name##_t *h,                                                        \
+      khint_t new_n_buckets) { /* This function uses 0.25*n_buckets bytes of   \
+                                  working space instead of                     \
+                                  [sizeof(key_t+val_t)+.25]*n_buckets. */      \
+    khint32_t *new_flags = 0;                                                  \
+    khint_t j = 1;                                                             \
+    {                                                                          \
+      kroundup32(new_n_buckets);                                               \
+      if (new_n_buckets < 4) new_n_buckets = 4;                                \
+      if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5))         \
+        j = 0; /* requested size is too small */                               \
+      else {   /* hash table size to be changed (shrink or expand); rehash */  \
+        new_flags = (khint32_t *)kmalloc(__ac_fsize(new_n_buckets) *           \
+                                         sizeof(khint32_t));                   \
+        if (!new_flags) return -1;                                             \
+        memset(new_flags, 0xaa,                                                \
+               __ac_fsize(new_n_buckets) * sizeof(khint32_t));                 \
+        if (h->n_buckets < new_n_buckets) { /* expand */                       \
+          khkey_t *new_keys = (khkey_t *)krealloc(                             \
+              (void *)h->keys, new_n_buckets * sizeof(khkey_t));               \
+          if (!new_keys) {                                                     \
+            kfree(new_flags);                                                  \
+            return -1;                                                         \
+          }                                                                    \
+          h->keys = new_keys;                                                  \
+          if (kh_is_map) {                                                     \
+            khval_t *new_vals = (khval_t *)krealloc(                           \
+                (void *)h->vals, new_n_buckets * sizeof(khval_t));             \
+            if (!new_vals) {                                                   \
+              kfree(new_flags);                                                \
+              return -1;                                                       \
+            }                                                                  \
+            h->vals = new_vals;                                                \
+          }                                                                    \
+        } /* otherwise shrink */                                               \
+      }                                                                        \
+    }                                                                          \
+    if (j) { /* rehashing is needed */                                         \
+      for (j = 0; j != h->n_buckets; ++j) {                                    \
+        if (__ac_iseither(h->flags, j) == 0) {                                 \
+          khkey_t key = h->keys[j];                                            \
+          khval_t val;                                                         \
+          khint_t new_mask;                                                    \
+          new_mask = new_n_buckets - 1;                                        \
+          if (kh_is_map) val = h->vals[j];                                     \
+          __ac_set_isdel_true(h->flags, j);                                    \
+          while (1) { /* kick-out process; sort of like in Cuckoo hashing */   \
+            khint_t k, i, step = 0;                                            \
+            k = __hash_func(key);                                              \
+            i = k & new_mask;                                                  \
+            while (!__ac_isempty(new_flags, i)) i = (i + (++step)) & new_mask; \
+            __ac_set_isempty_false(new_flags, i);                              \
+            if (i < h->n_buckets &&                                            \
+                __ac_iseither(h->flags, i) ==                                  \
+                    0) { /* kick out the existing element */                   \
+              {                                                                \
+                khkey_t tmp = h->keys[i];                                      \
+                h->keys[i] = key;                                              \
+                key = tmp;                                                     \
+              }                                                                \
+              if (kh_is_map) {                                                 \
+                khval_t tmp = h->vals[i];                                      \
+                h->vals[i] = val;                                              \
+                val = tmp;                                                     \
+              }                                                                \
+              __ac_set_isdel_true(                                             \
+                  h->flags, i); /* mark it as deleted in the old hash table */ \
+            } else { /* write the element and jump out of the loop */          \
+              h->keys[i] = key;                                                \
+              if (kh_is_map) h->vals[i] = val;                                 \
+              break;                                                           \
+            }                                                                  \
+          }                                                                    \
+        }                                                                      \
+      }                                                                        \
+      if (h->n_buckets > new_n_buckets) { /* shrink the hash table */          \
+        h->keys = (khkey_t *)krealloc((void *)h->keys,                         \
+                                      new_n_buckets * sizeof(khkey_t));        \
+        if (kh_is_map)                                                         \
+          h->vals = (khval_t *)krealloc((void *)h->vals,                       \
+                                        new_n_buckets * sizeof(khval_t));      \
+      }                                                                        \
+      kfree(h->flags); /* free the working space */                            \
+      h->flags = new_flags;                                                    \
+      h->n_buckets = new_n_buckets;                                            \
+      h->n_occupied = h->size;                                                 \
+      h->upper_bound = (khint_t)(h->n_buckets * __ac_HASH_UPPER + 0.5);        \
+    }                                                                          \
+    return 0;                                                                  \
+  }                                                                            \
+  SCOPE khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret) {       \
+    khint_t x;                                                                 \
+    if (h->n_occupied >= h->upper_bound) { /* update the hash table */         \
+      if (h->n_buckets > (h->size << 1)) {                                     \
+        if (kh_resize_##name(h, h->n_buckets - 1) <                            \
+            0) { /* clear "deleted" elements */                                \
+          *ret = -1;                                                           \
+          return h->n_buckets;                                                 \
+        }                                                                      \
+      } else if (kh_resize_##name(h, h->n_buckets + 1) <                       \
+                 0) { /* expand the hash table */                              \
+        *ret = -1;                                                             \
+        return h->n_buckets;                                                   \
+      }                                                                        \
+    } /* TODO: to implement automatically shrinking; resize() already support  \
+         shrinking */                                                          \
+    {                                                                          \
+      khint_t k, i, site, last, mask = h->n_buckets - 1, step = 0;             \
+      x = site = h->n_buckets;                                                 \
+      k = __hash_func(key);                                                    \
+      i = k & mask;                                                            \
+      if (__ac_isempty(h->flags, i))                                           \
+        x = i; /* for speed up */                                              \
+      else {                                                                   \
+        last = i;                                                              \
+        while (!__ac_isempty(h->flags, i) &&                                   \
+               (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) {  \
+          if (__ac_isdel(h->flags, i)) site = i;                               \
+          i = (i + (++step)) & mask;                                           \
+          if (i == last) {                                                     \
+            x = site;                                                          \
+            break;                                                             \
+          }                                                                    \
+        }                                                                      \
+        if (x == h->n_buckets) {                                               \
+          if (__ac_isempty(h->flags, i) && site != h->n_buckets)               \
+            x = site;                                                          \
+          else                                                                 \
+            x = i;                                                             \
+        }                                                                      \
+      }                                                                        \
+    }                                                                          \
+    if (__ac_isempty(h->flags, x)) { /* not present at all */                  \
+      h->keys[x] = key;                                                        \
+      __ac_set_isboth_false(h->flags, x);                                      \
+      ++h->size;                                                               \
+      ++h->n_occupied;                                                         \
+      *ret = 1;                                                                \
+    } else if (__ac_isdel(h->flags, x)) { /* deleted */                        \
+      h->keys[x] = key;                                                        \
+      __ac_set_isboth_false(h->flags, x);                                      \
+      ++h->size;                                                               \
+      *ret = 2;                                                                \
+    } else                                                                     \
+      *ret = 0; /* Don't touch h->keys[x] if present and not deleted */        \
+    return x;                                                                  \
+  }                                                                            \
+  SCOPE void kh_del_##name(kh_##name##_t *h, khint_t x) {                      \
+    if (x != h->n_buckets && !__ac_iseither(h->flags, x)) {                    \
+      __ac_set_isdel_true(h->flags, x);                                        \
+      --h->size;                                                               \
+    }                                                                          \
+  }
+
+#define KHASH_DECLARE(name, khkey_t, khval_t) \
+  __KHASH_TYPE(name, khkey_t, khval_t)        \
+  __KHASH_PROTOTYPES(name, khkey_t, khval_t)
+
+#define KHASH_INIT2(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, \
+                    __hash_equal)                                          \
+  __KHASH_TYPE(name, khkey_t, khval_t)                                     \
+  __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func,      \
+               __hash_equal)
+
+#define KHASH_INIT(name, khkey_t, khval_t, kh_is_map, __hash_func,             \
+                   __hash_equal)                                               \
+  KHASH_INIT2(name, static kh_inline klib_unused, khkey_t, khval_t, kh_is_map, \
+              __hash_func, __hash_equal)
+
+/* --- BEGIN OF HASH FUNCTIONS --- */
+
+/*! @function
+  @abstract     Integer hash function
+  @param  key   The integer [khint32_t]
+  @return       The hash value [khint_t]
+ */
+#define kh_int_hash_func(key) (khint32_t)(key)
+/*! @function
+  @abstract     Integer comparison function
+ */
+#define kh_int_hash_equal(a, b) ((a) == (b))
+/*! @function
+  @abstract     64-bit integer hash function
+  @param  key   The integer [khint64_t]
+  @return       The hash value [khint_t]
+ */
+#define kh_int64_hash_func(key) (khint32_t)((key) >> 33 ^ (key) ^ (key) << 11)
+/*! @function
+  @abstract     64-bit integer comparison function
+ */
+#define kh_int64_hash_equal(a, b) ((a) == (b))
+/*! @function
+  @abstract     const char* hash function
+  @param  s     Pointer to a null terminated string
+  @return       The hash value
+ */
+static kh_inline khint_t __ac_X31_hash_string(const char *s) {
+  khint_t h = (khint_t)*s;
+  if (h)
+    for (++s; *s; ++s) h = (h << 5) - h + (khint_t)*s;
+  return h;
+}
+/*! @function
+  @abstract     Another interface to const char* hash function
+  @param  key   Pointer to a null terminated string [const char*]
+  @return       The hash value [khint_t]
+ */
+#define kh_str_hash_func(key) __ac_X31_hash_string(key)
+/*! @function
+  @abstract     Const char* comparison function
+ */
+#define kh_str_hash_equal(a, b) (strcmp(a, b) == 0)
+
+static kh_inline khint_t __ac_Wang_hash(khint_t key) {
+  key += ~(key << 15);
+  key ^= (key >> 10);
+  key += (key << 3);
+  key ^= (key >> 6);
+  key += ~(key << 11);
+  key ^= (key >> 16);
+  return key;
+}
+#define kh_int_hash_func2(key) __ac_Wang_hash((khint_t)key)
+
+/* --- END OF HASH FUNCTIONS --- */
+
+/* Other convenient macros... */
+
+/*!
+  @abstract Type of the hash table.
+  @param  name  Name of the hash table [symbol]
+ */
+#define khash_t(name) kh_##name##_t
+
+/*! @function
+  @abstract     Initiate a hash table.
+  @param  name  Name of the hash table [symbol]
+  @return       Pointer to the hash table [khash_t(name)*]
+ */
+#define kh_init(name) kh_init_##name()
+
+/*! @function
+  @abstract     Destroy a hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+ */
+#define kh_destroy(name, h) kh_destroy_##name(h)
+
+/*! @function
+  @abstract     Reset a hash table without deallocating memory.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+ */
+#define kh_clear(name, h) kh_clear_##name(h)
+
+/*! @function
+  @abstract     Resize a hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  s     New size [khint_t]
+ */
+#define kh_resize(name, h, s) kh_resize_##name(h, s)
+
+/*! @function
+  @abstract     Insert a key to the hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  k     Key [type of keys]
+  @param  r     Extra return code: -1 if the operation failed;
+                0 if the key is present in the hash table;
+                1 if the bucket is empty (never used); 2 if the element in
+                                the bucket has been deleted [int*]
+  @return       Iterator to the inserted element [khint_t]
+ */
+#define kh_put(name, h, k, r) kh_put_##name(h, k, r)
+
+/*! @function
+  @abstract     Retrieve a key from the hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  k     Key [type of keys]
+  @return       Iterator to the found element, or kh_end(h) if the element is
+  absent [khint_t]
+ */
+#define kh_get(name, h, k) kh_get_##name(h, k)
+
+/*! @function
+  @abstract     Remove a key from the hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  k     Iterator to the element to be deleted [khint_t]
+ */
+#define kh_del(name, h, k) kh_del_##name(h, k)
+
+/*! @function
+  @abstract     Test whether a bucket contains data.
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  x     Iterator to the bucket [khint_t]
+  @return       1 if containing data; 0 otherwise [int]
+ */
+#define kh_exist(h, x) (!__ac_iseither((h)->flags, (x)))
+
+/*! @function
+  @abstract     Get key given an iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  x     Iterator to the bucket [khint_t]
+  @return       Key [type of keys]
+ */
+#define kh_key(h, x) ((h)->keys[x])
+
+/*! @function
+  @abstract     Get value given an iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  x     Iterator to the bucket [khint_t]
+  @return       Value [type of values]
+  @discussion   For hash sets, calling this results in segfault.
+ */
+#define kh_val(h, x) ((h)->vals[x])
+
+/*! @function
+  @abstract     Alias of kh_val()
+ */
+#define kh_value(h, x) ((h)->vals[x])
+
+/*! @function
+  @abstract     Get the start iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       The start iterator [khint_t]
+ */
+#define kh_begin(h) (khint_t)(0)
+
+/*! @function
+  @abstract     Get the end iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       The end iterator [khint_t]
+ */
+#define kh_end(h) ((h)->n_buckets)
+
+/*! @function
+  @abstract     Get the number of elements in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       Number of elements in the hash table [khint_t]
+ */
+#define kh_size(h) ((h)->size)
+
+/*! @function
+  @abstract     Get the number of buckets in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       Number of buckets in the hash table [khint_t]
+ */
+#define kh_n_buckets(h) ((h)->n_buckets)
+
+/*! @function
+  @abstract     Iterate over the entries in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  kvar  Variable to which key will be assigned
+  @param  vvar  Variable to which value will be assigned
+  @param  code  Block of code to execute
+ */
+#define kh_foreach(h, kvar, vvar, code)                \
+  {                                                    \
+    khint_t __i;                                       \
+    for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \
+      if (!kh_exist(h, __i)) continue;                 \
+      (kvar) = kh_key(h, __i);                         \
+      (vvar) = kh_val(h, __i);                         \
+      code;                                            \
+    }                                                  \
+  }
+
+/*! @function
+  @abstract     Iterate over the values in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  vvar  Variable to which value will be assigned
+  @param  code  Block of code to execute
+ */
+#define kh_foreach_value(h, vvar, code)                \
+  {                                                    \
+    khint_t __i;                                       \
+    for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \
+      if (!kh_exist(h, __i)) continue;                 \
+      (vvar) = kh_val(h, __i);                         \
+      code;                                            \
+    }                                                  \
+  }
+
+/* More convenient interfaces */
+
+/*! @function
+  @abstract     Instantiate a hash set containing integer keys
+  @param  name  Name of the hash table [symbol]
+ */
+#define KHASH_SET_INIT_INT(name) \
+  KHASH_INIT(name, khint32_t, char, 0, kh_int_hash_func, kh_int_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing integer keys
+  @param  name  Name of the hash table [symbol]
+  @param  khval_t  Type of values [type]
+ */
+#define KHASH_MAP_INIT_INT(name, khval_t) \
+  KHASH_INIT(name, khint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash set containing 64-bit integer keys
+  @param  name  Name of the hash table [symbol]
+ */
+#define KHASH_SET_INIT_INT64(name) \
+  KHASH_INIT(name, khint64_t, char, 0, kh_int64_hash_func, kh_int64_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing 64-bit integer keys
+  @param  name  Name of the hash table [symbol]
+  @param  khval_t  Type of values [type]
+ */
+#define KHASH_MAP_INIT_INT64(name, khval_t)                   \
+  KHASH_INIT(name, khint64_t, khval_t, 1, kh_int64_hash_func, \
+             kh_int64_hash_equal)
+
+typedef const char *kh_cstr_t;
+/*! @function
+  @abstract     Instantiate a hash map containing const char* keys
+  @param  name  Name of the hash table [symbol]
+ */
+#define KHASH_SET_INIT_STR(name) \
+  KHASH_INIT(name, kh_cstr_t, char, 0, kh_str_hash_func, kh_str_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing const char* keys
+  @param  name  Name of the hash table [symbol]
+  @param  khval_t  Type of values [type]
+ */
+#define KHASH_MAP_INIT_STR(name, khval_t) \
+  KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal)
+
+/******************************************************************************
+ * 											Custom
+ *high-level interface
+ ******************************************************************************/
+
+#define _kh_var(x) _kh_var_##x
+
+/**
+ * @brief Return the value corresponding to a key in the hashtable.
+ * @return The value associated with the key or null if not found
+ */
+#define kh_get_val(kname, hashtable, key, default_val)               \
+  ({                                                                 \
+    khiter_t _kh_var(k) = kh_get(kname, hashtable, key);             \
+    (_kh_var(k) != kh_end(hashtable) ? kh_val(hashtable, _kh_var(k)) \
+                                     : default_val);                 \
+  })
+
+/**
+ * @brief Add key/value pair in the hashtable.
+ * @return 0 if an existing value (corresponding to the provided key)
+ * has been replaced; 1 if a new key/value pair has been added
+ * (the key was not already present in the hash table);
+ * 2 if a new key/value pair has been added in correspondence
+ * of a key previously deleted key
+ */
+#define kh_put_val(kname, hashtable, key, val)                          \
+  ({                                                                    \
+    int _kh_var(ret);                                                   \
+    khiter_t _kh_var(k) = kh_put(kname, hashtable, key, &_kh_var(ret)); \
+    kh_value(hashtable, _kh_var(k)) = val;                              \
+    _kh_var(ret);                                                       \
+  })
+
+/**
+ * @brief Remove a key/value pair from the hashtable.
+ * @return void
+ */
+#define kh_remove_val(kname, hashtable, key)             \
+  ({                                                     \
+    khiter_t _kh_var(k) = kh_get(kname, hashtable, key); \
+    if (_kh_var(k) != kh_end(hashtable)) {               \
+      free((void *)kh_key(hashtable, _kh_var(k)));       \
+      kh_del(kname, hashtable, _kh_var(k));              \
+    }                                                    \
+  })
+
+/**
+ * @brief Free the hashtable.
+ * @return void
+ */
+#define kh_free(kname, hashtable)                                             \
+  ({                                                                          \
+    const void *_kh_var(key);                                                 \
+    unsigned _kh_var(val);                                                    \
+    (void)_kh_var(val);                                                       \
+                                                                              \
+    kh_foreach(hashtable, _kh_var(key), _kh_var(val),                         \
+               { free((void *)_kh_var(key)); }) kh_destroy(kname, hashtable); \
+  })
+
+#endif /* __AC_KHASH_H */
diff --git a/hicn-light/src/hicn/base/loop.c b/hicn-light/src/hicn/base/loop.c
new file mode 100644
index 000000000..68970ed3a
--- /dev/null
+++ b/hicn-light/src/hicn/base/loop.c
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file loop.c
+ * @brief Implementation of event loop based on libevent
+ */
+
+#include <assert.h>
+#include <event2/event.h>
+#include <event2/event_struct.h>
+#include <event2/thread.h>
+#include <fcntl.h>  // fcntl
+#ifdef WITH_THREAD
+#include <pthread.h>
+#endif /* WITH_THREAD */
+#include <hicn/util/log.h>
+#include <stdlib.h>
+#include <unistd.h>  // fcntl
+
+#include "loop.h"
+
+loop_t *MAIN_LOOP = NULL;
+
+/**
+ * \brief Holds all callback parameters
+ */
+typedef struct {
+  void *owner;
+  fd_callback_t callback;
+  void *data;
+} cb_wrapper_args_t;
+
+typedef enum {
+  EVTYPE_TIMER,
+  EVTYPE_FD,
+} event_type_t;
+
+struct loop_s {
+  /* Libevent-based implementation */
+  struct event_base *event_base;
+};
+
+struct event_s {
+  /* Reference to loop */
+  loop_t *loop;
+
+  /* Event type*/
+  event_type_t event_type;
+
+  /* Raw event */
+  struct event raw_event;
+
+  /* Callback on event */
+  cb_wrapper_args_t callback;
+};
+
+loop_t *loop_create() {
+  loop_t *loop = malloc(sizeof(loop_t));
+
+  if (!loop) {
+    ERROR("[loop_create] Failed to allocate memory");
+    goto ERR_MALLOC;
+  }
+
+#ifdef WITH_THREAD
+  evthread_use_pthreads();
+#endif /* WITH_THREAD */
+
+  loop->event_base = event_base_new();
+  if (!loop->event_base) goto ERR_EVENT;
+
+  event_set_log_callback(NULL);
+
+  return loop;
+
+ERR_EVENT:
+ERR_MALLOC:
+  return NULL;
+}
+
+void loop_free(loop_t *loop) {
+  event_base_free(loop->event_base);
+  free(loop);
+}
+
+int _loop_dispatch(loop_t *loop, int flags) {
+  event_base_loop(loop->event_base, flags);
+  return 0;
+}
+
+int loop_dispatch(loop_t *loop) {
+  return _loop_dispatch(loop, EVLOOP_NO_EXIT_ON_EMPTY);
+}
+
+int loop_break(loop_t *loop) { return event_base_loopbreak(loop->event_base); }
+
+int loop_undispatch(loop_t *loop) { return 0; }
+
+void cb_wrapper(evutil_socket_t fd, short what, void *arg) {
+  cb_wrapper_args_t *cb_wrapper_args = arg;
+  cb_wrapper_args->callback(cb_wrapper_args->owner, fd, cb_wrapper_args->data);
+}
+
+static inline void _event_create(event_t **event, loop_t *loop,
+                                 event_type_t type, void *callback_owner,
+                                 fd_callback_t callback, void *callback_data) {
+  *event = malloc(sizeof(event_t));
+  (*event)->callback = (cb_wrapper_args_t){
+      .owner = callback_owner,
+      .callback = callback,
+      .data = callback_data,
+  };
+  (*event)->event_type = type;
+  (*event)->loop = loop;
+}
+
+int loop_fd_event_create(event_t **event, loop_t *loop, int fd,
+                         void *callback_owner, fd_callback_t callback,
+                         void *callback_data) {
+  _event_create(event, loop, EVTYPE_FD, callback_owner, callback,
+                callback_data);
+
+  evutil_make_socket_nonblocking(fd);
+  event_assign(&(*event)->raw_event, loop->event_base, fd, EV_READ | EV_PERSIST,
+               cb_wrapper, &(*event)->callback);
+
+  return 0;
+}
+
+int loop_fd_event_register(event_t *event) {
+  assert(event->event_type == EVTYPE_FD);
+
+  if (event_add(&event->raw_event, NULL) < 0) {
+    ERROR("[loop_fd_event_register] event_add");
+    goto ERR_EVENT_ADD;
+  }
+
+  return 0;
+
+ERR_EVENT_ADD:
+  return -1;
+}
+
+int loop_event_unregister(event_t *event) {
+  event_del(&event->raw_event);
+  return 0;
+}
+
+int loop_timer_create(event_t **timer, loop_t *loop, void *callback_owner,
+                      fd_callback_t callback, void *callback_data) {
+  _event_create(timer, loop, EVTYPE_TIMER, callback_owner, callback,
+                callback_data);
+
+  evtimer_assign(&(*timer)->raw_event, loop->event_base, cb_wrapper,
+                 &(*timer)->callback);
+
+  return 0;
+}
+
+static inline void _ms_to_timeval(unsigned delay_ms, struct timeval *tv) {
+  tv->tv_sec = delay_ms / 1000;
+  tv->tv_usec = (delay_ms % 1000) * 1000;
+}
+
+int loop_timer_register(event_t *timer, unsigned delay_ms) {
+  assert(timer->event_type == EVTYPE_TIMER);
+
+  struct timeval tv;
+  _ms_to_timeval(delay_ms, &tv);
+
+  if (tv.tv_sec == 0 && tv.tv_usec == 0) {
+    event_active(&timer->raw_event, EV_TIMEOUT, 0);
+  } else {
+    event_add(&timer->raw_event, &tv);
+  }
+
+  return 0;
+}
+
+int loop_timer_is_enabled(event_t *timer) {
+  return evtimer_pending(&timer->raw_event, NULL) != 0;
+}
+
+int loop_event_free(event_t *event) {
+  int ret = loop_event_unregister(event);
+  free(event);
+  return ret;
+}
diff --git a/hicn-light/src/hicn/base/loop.h b/hicn-light/src/hicn/base/loop.h
new file mode 100644
index 000000000..f81af333b
--- /dev/null
+++ b/hicn-light/src/hicn/base/loop.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file loop.h
+ * \brief Face manager main loop
+ */
+
+#ifndef UTIL_LOOP_H
+#define UTIL_LOOP_H
+
+/* fd & timer callbacks */
+
+typedef int (*fd_callback_t)(void *owner, int fd, void *data);
+
+typedef struct {
+  int fd;
+  void *owner;
+  fd_callback_t callback;
+  void *data;
+} fd_callback_data_t;
+
+/* loop */
+
+typedef struct loop_s loop_t;
+typedef struct event_s event_t;
+
+extern loop_t *MAIN_LOOP;
+
+/**
+ * \brief Creates a main loop
+ * \return Pointer to the newly created loop, or NULL in case of error
+ */
+loop_t *loop_create();
+
+/**
+ * \brief Releases a loop instance and frees all associated memory
+ * \param [in] loop - Pointer to the loop instance to free
+ */
+void loop_free(loop_t *loop);
+
+/**
+ * \brief Runs the loop instance to process events (helper).
+ * \param [in] loop - Pointer to the loop instance
+ * \param [in] flags - Loop mode: EVLOOP_ONCE, EVLOOP_NONBLOCK or
+ * EVLOOP_NO_EXIT_ON_EMPTY \return 0 if successful, -1 otherwise
+ */
+int _loop_dispatch(loop_t *loop, int flags);
+
+/**
+ * \brief Runs the loop instance to process events.
+ * \param [in] loop - Pointer to the loop instance
+ * \return 0 if successful, -1 otherwise
+ */
+int loop_dispatch(loop_t *loop);
+
+/**
+ * \brief Terminates the dispatching of events
+ * \param [in] loop - Pointer to the loop instance
+ */
+int loop_break(loop_t *loop);
+
+int loop_undispatch(loop_t *loop);
+
+/** Create new event associated with given fd.
+ * \param [out] event - Struct representing new fd event
+ * \param [in] loop - Loop running events
+ * \param [in] fd - fd to register
+ * \param [in] callback_owner - Pointer to the owner of the callack (first
+ *      parameter of callback function)
+ * \param [in] callback - Callback function
+ * \param [in] callback_data - User data to pass alongside callback invocation
+ * \return 0 in case of success, -1 otherwise
+ */
+int loop_fd_event_create(event_t **event, loop_t *loop, int fd,
+                         void *callback_owner, fd_callback_t callback,
+                         void *callback_data);
+
+/**
+ * Register event in corresponding event loop.
+ * \param [in] event - Struct representing fd event
+ * \return 0 in case of success, -1 otherwise
+ */
+int loop_fd_event_register(event_t *event);
+
+/**
+ * Unregister event from corresponding event loop.
+ * \param [in] event - Struct representing fd event
+ * \return 0 in case of success, -1 otherwise
+ */
+int loop_event_unregister(event_t *event);
+
+/**
+ * Free event object.
+ * \param [in] event - Struct representing the event
+ * \return 0 in case of success, -1 otherwise
+ */
+int loop_event_free(event_t *event);
+
+/** Create new timer event.
+ * \param [out] event - Struct representing new timer event
+ * \param [in] loop - Loop running events
+ * \param [in] callback_owner - Pointer to the owner of the callack (first
+ *      parameter of callback function)
+ * \param [in] callback - Callback function
+ * \param [in] callback_data - User data to pass alongside callback invocation
+ * \return 0 in case of success, -1 otherwise
+ */
+int loop_timer_create(event_t **timer, loop_t *loop, void *callback_owner,
+                      fd_callback_t callback, void *callback_data);
+
+/**
+ * Register event in corresponding event loop.
+ * \param [in] timer - Struct representing timer event
+ * \return 0 in case of success, -1 otherwise
+ */
+int loop_timer_register(event_t *timer, unsigned delay_ms);
+
+/**
+ * Check if timer is enabled.
+ * \param [in] timer - Struct representing timer event
+ * \return 1 if enabled, 0 otherwise
+ */
+int loop_timer_is_enabled(event_t *timer);
+
+#endif /* UTIL_LOOP_H */
diff --git a/hicn-light/src/hicn/base/pool.c b/hicn-light/src/hicn/base/pool.c
new file mode 100644
index 000000000..ba2a14c5f
--- /dev/null
+++ b/hicn-light/src/hicn/base/pool.c
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file pool.c
+ * \brief Implementation of fixed-size pool allocator.
+ *
+ * NOTE:
+ *  - Ideally, we should have a single realloc per resize, that would encompass
+ *  both the free indices vector and bitmap, by nesting data structures. Because
+ *  of the added complexity, and by lack of evidence of the need for this, we
+ *  currently rely on a simpler implementation.
+ */
+
+#include <assert.h>
+#include <stdlib.h>  // calloc
+
+#include "common.h"
+#include "pool.h"
+
+#include <stdio.h>  // XXX
+
+void _pool_init(void** pool_ptr, size_t elt_size, size_t init_size,
+                size_t max_size) {
+  assert(pool_ptr);
+  assert(elt_size);
+
+  init_size = next_pow2(init_size);
+
+  if (max_size && init_size > max_size) goto ERR_MAX_SIZE;
+
+  /* The initial pool size is rounded to the next power of two */
+  size_t alloc_size = next_pow2(init_size);
+
+  pool_hdr_t* ph = calloc(POOL_HDRLEN + alloc_size * elt_size, 1);
+  if (!ph) goto ERR_MALLOC;
+
+  ph->elt_size = elt_size;
+  ph->alloc_size = alloc_size;
+  ph->max_size = max_size;
+
+  /* Free indices */
+  off_t* free_indices;
+  vector_init(free_indices, init_size, max_size);
+  for (unsigned i = 0; i < init_size; i++)
+    free_indices[i] = (init_size - 1) - i;
+  vector_len(free_indices) = init_size;
+  ph->free_indices = free_indices;
+
+  /* Free bitmap */
+  uint_fast32_t* fb = ph->free_bitmap;
+  bitmap_init(fb, init_size, max_size);
+  bitmap_set_to(fb, init_size);
+  ph->free_bitmap = fb;
+
+  *pool_ptr = (uint8_t*)ph + POOL_HDRLEN;
+
+  return;
+
+ERR_MALLOC:
+ERR_MAX_SIZE:
+  *pool_ptr = NULL;
+  return;
+}
+
+void _pool_free(void** pool_ptr) {
+  pool_hdr_t* ph = pool_hdr(*pool_ptr);
+  vector_free(ph->free_indices);
+  bitmap_free(ph->free_bitmap);
+
+  free(pool_hdr(*pool_ptr));
+  *pool_ptr = NULL;
+}
+
+bool _pool_validate_id(void** pool_ptr, off_t id) {
+  pool_hdr_t* ph = pool_hdr(*pool_ptr);
+  size_t pool_size = pool_get_alloc_size(*pool_ptr);
+  if (id >= pool_size || !bitmap_is_unset(ph->free_bitmap, id)) return false;
+
+  return true;
+}
+
+void _pool_resize(void** pool_ptr, size_t elt_size) {
+  pool_hdr_t* ph = pool_hdr(*pool_ptr);
+  size_t old_size = ph->alloc_size;
+  size_t new_size = old_size * 2;
+
+  TRACE("pool_resize to %lu", new_size);
+
+  if (ph->max_size && new_size > ph->max_size) goto ERR_MAX_SIZE;
+
+  /* Double pool storage */
+  ph = realloc(ph, POOL_HDRLEN + new_size * elt_size);
+  if (!ph) goto ERR_REALLOC;
+  ph->elt_size = elt_size;
+  ph->alloc_size = new_size;
+
+  /*
+   * After resize, the pool will have new free indices, ranging from
+   * old_size to (new_size - 1)
+   */
+  vector_ensure_pos(ph->free_indices, old_size);
+  for (unsigned i = 0; i < old_size; i++)
+    ph->free_indices[i] = new_size - 1 - i;
+  vector_len(ph->free_indices) = old_size;
+
+  /* We also need to update the bitmap */
+  bitmap_ensure_pos(&(ph->free_bitmap), new_size - 1);
+  bitmap_set_range(ph->free_bitmap, old_size, new_size - 1);
+
+  /* Reassign pool pointer */
+  *pool_ptr = (uint8_t*)ph + POOL_HDRLEN;
+
+  return;
+
+ERR_REALLOC:
+ERR_MAX_SIZE:
+  *pool_ptr = NULL;
+  return;
+}
+
+off_t _pool_get(void** pool_ptr, void** elt, size_t elt_size) {
+  pool_hdr_t* ph = pool_hdr(*pool_ptr);
+  uint64_t l = vector_len(ph->free_indices);
+  if (l == 0) {
+    _pool_resize(pool_ptr, elt_size);
+    ph = pool_hdr(*pool_ptr);
+    l = vector_len(ph->free_indices);
+  }
+  off_t free_id = ph->free_indices[l - 1];
+  vector_len(ph->free_indices)--;
+  bitmap_unset(ph->free_bitmap, free_id);
+  *elt = *pool_ptr + free_id * elt_size;
+  memset(*elt, 0, elt_size);
+  return free_id;
+}
+
+void _pool_put(void** pool_ptr, void** elt, size_t elt_size) {
+  pool_hdr_t* ph = pool_hdr(*pool_ptr);
+  uint64_t l = vector_len(ph->free_indices);
+  vector_ensure_pos(ph->free_indices, l);
+  off_t freed_id = (*elt - *pool_ptr) / elt_size;
+  ph->free_indices[l] = freed_id;
+  vector_len(ph->free_indices)++;
+  bitmap_set(ph->free_bitmap, freed_id);
+}
diff --git a/hicn-light/src/hicn/base/pool.h b/hicn-light/src/hicn/base/pool.h
new file mode 100644
index 000000000..b6573195c
--- /dev/null
+++ b/hicn-light/src/hicn/base/pool.h
@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file pool.h
+ * \brief Fixed-size pool allocator.
+ *
+ * This memory pool allocates a single block of memory that is used to
+ * efficiently allocate/deallocate fixed-size blocks for high churn data
+ * structures.
+ *
+ * Internally this data structure leverages a vector for managing elements (and
+ * it thus resizeable if needed), as well as a list of free indices (in the
+ * form of another vector) and a bitmap marking free indices also (for fast
+ * iteration).
+ *
+ * The internal API manipulates a pointer to the vector that that is can be
+ * seamlessly resized, and a more convenient user interface is provided through
+ * macros.
+ *
+ * The vector of free indices is managed as a stack where elements indices are
+ * retrieved from and put back to the end of the vector. In the bitmap,
+ * available elements are set to 1, and unset to 0 when in use.
+ *
+ * The pool is not currently resized down when releasing elements.
+ *
+ * It is freely inspired (and simplified) from the VPP infra infrastructure
+ * library.
+ */
+
+#ifndef UTIL_POOL_H
+#define UTIL_POOL_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "bitmap.h"
+#include "vector.h"
+
+/* Pool header */
+
+typedef struct {
+  size_t elt_size;
+  size_t alloc_size;
+  size_t max_size;
+  bitmap_t *free_bitmap; /* bitmap of free indices */
+  off_t *free_indices;   /* vector of free indices */
+} pool_hdr_t;
+
+#define POOL_HDRLEN SIZEOF_ALIGNED(pool_hdr_t)
+
+/* This header actually prepends the actual content of the pool. */
+#define pool_hdr(pool) ((pool_hdr_t *)((uint8_t *)(pool)-POOL_HDRLEN))
+
+/******************************************************************************/
+/* Helpers */
+
+/** Local variable naming macro. */
+#define _pool_var(v) _pool_##v
+
+/**
+ * @brief Allocate and initialize a pool data structure (helper).
+ *
+ * @param[in,out] pool_ptr Pointer to the pool data structure.
+ * @param[in] elt_size Size of elements in vector.
+ * @param[in] max_size Maximum size.
+ *
+ * NOTE: that an empty pool might be equal to NULL.
+ */
+void _pool_init(void **pool_ptr, size_t elt_size, size_t init_size,
+                size_t max_size);
+
+/**
+ * @brief Free a pool data structure (helper).
+ *
+ * @param[in] pool_ptr Pointer to the pool data structure.
+ */
+void _pool_free(void **pool_ptr);
+
+/**
+ * @brief Resize a pool data structure (helper).
+ *
+ * @param pool_ptr Pointer to the pool data structure.
+ *
+ * This function should only be called internally, as the resize is implicitly
+ * done (if allowed by the maximum size) when the user tries to get a new slot.
+ */
+void _pool_resize(void **pool_ptr, size_t elt_size);
+
+/**
+ * @brief Get a free element from the pool data structure (helper).
+ *
+ * @param[in] pool Pointer to the pool data structure to use.
+ * @param[in,out] elt Pointer to an empty element that will be used to return
+ * the allocated one from the pool.
+ *
+ * NOTES:
+ *  - The memory chunk is cleared upon attribution
+ */
+off_t _pool_get(void **pool, void **elt, size_t elt_size);
+
+/**
+ * @brief Put an element back into the pool data structure (helper).
+ *
+ * @param[in] pool_ptr Pointer to the pool data structure to use.
+ * @param[in] elt Pointer to the pool element to put back.
+ */
+void _pool_put(void **pool, void **elt, size_t elt_size);
+
+/**
+ * @brief Validate a pool element by index (helper).
+ *
+ * @param[in] pool The pool data structure to use.
+ * @param[in] id The index of the element to validate.
+ *
+ * @return bool A flag indicating whether the index is valid or not.
+ */
+bool _pool_validate_id(void **pool_ptr, off_t id);
+/******************************************************************************/
+/* Public API */
+
+/**
+ * @brief Allocate and initialize a pool data structure.
+ *
+ * @param[in,out] pool Pointer to the pool data structure.
+ * @param[in] elt_size Size of elements in pool.
+ * @param[in] max_size Maximum size.
+ *
+ * NOTE: that an empty pool might be equal to NULL.
+ */
+#define pool_init(pool, init_size, max_size) \
+  _pool_init((void **)&pool, sizeof(pool[0]), init_size, max_size);
+
+/**
+ * @brief Free a pool data structure.
+ *
+ * @param[in] pool The pool data structure to free.
+ */
+#define pool_free(pool) _pool_free((void **)&pool);
+
+/**
+ * @brief Get a free element from the pool data structure.
+ *
+ * @param[in] pool The pool data structure to use.
+ * @param[in,out] elt An empty element that will be used to return the
+ * allocated one from the pool.
+ *
+ * NOTES:
+ *  - The memory chunk is cleared upon attribution
+ */
+#define pool_get(pool, elt) \
+  _pool_get((void **)&pool, (void **)&elt, sizeof(*elt))
+
+/**
+ * @brief Put an element back into the pool data structure.
+ *
+ * @param[in] pool The pool data structure to use.
+ * @param[in] elt The pool element to put back.
+ */
+#define pool_put(pool, elt) \
+  _pool_put((void **)&pool, (void **)&elt, sizeof(*elt))
+
+/**
+ * @brief Validate a pool element by index.
+ *
+ * @param[in] pool The pool data structure to use.
+ * @param[in] id The index of the element to validate.
+ *
+ * @return bool A flag indicating whether the index is valid or not.
+ */
+#define pool_validate_id(pool, id) _pool_validate_id((void **)&pool, (id))
+
+#define pool_get_free_indices_size(pool) \
+  vector_len(pool_hdr(pool)->free_indices)
+
+/**
+ * @brief Returns the current length of the pool.
+ *
+ * @param[in] pool The pool data structure for which to return the length.
+ *
+ * @return size_t The current length of the pool.
+ *
+ * NOTE:
+ *  - The pool length corresponds to the number of allocated elements, not the
+ *  size of the pool.
+ */
+#define pool_len(pool) \
+  (pool_hdr(pool)->alloc_size - pool_get_free_indices_size(pool))
+
+/**
+ * @brief Enumerate elements from a pool.
+ *
+ * @param[in] pool The pool data structure to enumerate.
+ * @param[in, out] i An integer that will be used for enumeration.
+ * @param[in, out] eltp A pointer to the element type that will be used for
+ * enumeration.
+ * @param[in] BODY Block to execute during enumeration.
+ *
+ * Enumeration will iteratively execute BODY with (i, eltp) corresponding
+ * respectively to the index and element found in the pool.
+ *
+ * NOTE: i stars at 0.
+ */
+#define pool_enumerate(pool, i, eltp, BODY)                 \
+  do {                                                      \
+    pool_hdr_t *_pool_var(ph) = pool_hdr(pool);             \
+    bitmap_t *_pool_var(fb) = _pool_var(ph)->free_bitmap;   \
+    for ((i) = 0; (i) < _pool_var(ph)->alloc_size; (i)++) { \
+      if (bitmap_is_set(_pool_var(fb), (i))) continue;      \
+      eltp = (pool) + (i);                                  \
+      do {                                                  \
+        BODY;                                               \
+      } while (0);                                          \
+    }                                                       \
+  } while (0)
+
+/**
+ * @brief  Iterate over elements in a pool.
+ *
+ * @param[in] pool The pool data structure to iterate over.
+ * @param[in,out] eltp A pointer to the element type that will be used for
+ * iteration.
+ * @param[in] BODY Block to execute during iteration.
+ *
+ * Iteration will execute BODY with eltp corresponding successively to all
+ * elements found in the pool. It is implemented using the more generic
+ * enumeration function.
+ */
+#define pool_foreach(pool, eltp, BODY)                  \
+  do {                                                  \
+    unsigned _pool_var(i);                              \
+    pool_enumerate((pool), _pool_var(i), (eltp), BODY); \
+  } while (0)
+
+#define pool_get_alloc_size(pool) pool_hdr(pool)->alloc_size
+
+#ifdef WITH_TESTS
+#define pool_get_free_indices(pool) pool_hdr(pool)->free_indices
+#define pool_get_free_bitmap(pool) pool_hdr(pool)->free_bitmap
+#endif /* WITH_TESTS */
+
+#endif /* UTIL_POOL_H */
diff --git a/hicn-light/src/hicn/base/ring.c b/hicn-light/src/hicn/base/ring.c
new file mode 100644
index 000000000..29727886a
--- /dev/null
+++ b/hicn-light/src/hicn/base/ring.c
@@ -0,0 +1,45 @@
+
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file ring.c
+ * \brief Implementation of ring buffer.
+ */
+
+#include <stdlib.h>
+
+#include "ring.h"
+
+void _ring_init(void** ring_ptr, size_t elt_size, size_t max_size) {
+  assert(ring_ptr);
+  assert(elt_size > 0);
+  // we use a static array, not a vector (for now)
+  assert(max_size != 0);
+
+  ring_hdr_t* rh = malloc(RING_HDRLEN + max_size * elt_size);
+
+  rh->roff = 0;
+  rh->woff = 0;
+  rh->size = 0;
+  rh->max_size = max_size;
+
+  *ring_ptr = (uint8_t*)rh + RING_HDRLEN;
+}
+
+void _ring_free(void** ring_ptr) {
+  free(ring_hdr(*ring_ptr));
+  *ring_ptr = NULL;
+}
diff --git a/hicn-light/src/hicn/base/ring.h b/hicn-light/src/hicn/base/ring.h
new file mode 100644
index 000000000..492a8fdac
--- /dev/null
+++ b/hicn-light/src/hicn/base/ring.h
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file ring.h
+ * \brief Fixed-size pool allocator.
+ */
+
+#ifndef UTIL_RING_H
+#define UTIL_RING_H
+
+#include <assert.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/param.h>  // MIN
+#include <sys/types.h>
+
+#include <stdio.h>  // XXX debug
+
+#include "common.h"
+
+/******************************************************************************/
+/* Ring header */
+
+typedef struct {
+  size_t roff;
+  size_t woff;
+  size_t size;
+  size_t max_size;
+} ring_hdr_t;
+
+/* Make sure elements following the header are aligned */
+#define RING_HDRLEN SIZEOF_ALIGNED(ring_hdr_t)
+
+/* This header actually prepends the actual content of the vector */
+#define ring_hdr(ring) ((ring_hdr_t *)((uint8_t *)ring - RING_HDRLEN))
+
+/******************************************************************************/
+/* Helpers */
+
+/** Local variable naming macro. */
+#define _ring_var(v) _ring_##v
+
+/**
+ * @brief Allocate and initialize a ring data structure (helper function).
+ *
+ * @param[in,out] ring_ptr Ring buffer to allocate and initialize.
+ * @param[in] elt_size Size of a ring element.
+ * @param[in] max_size Maximum vector size (O = unlimited).
+ */
+void _ring_init(void **ring_ptr, size_t elt_size, size_t max_size);
+
+/**
+ * @brief Free a ring data structure.
+ *
+ * @param ring_ptr[in] Pointer to the ring data structure to free.
+ */
+void _ring_free(void **ring_ptr);
+
+static inline int _ring_add(void **ring_ptr, size_t elt_size, void *eltp) {
+  assert(*ring_ptr);
+  ring_hdr_t *rh = ring_hdr(*ring_ptr);
+
+  /* We always write ! */
+  memcpy((uint8_t *)*ring_ptr + rh->woff * elt_size, eltp, elt_size);
+  rh->woff++;
+  if (rh->woff == rh->max_size) rh->woff = 0;
+  if (rh->size < rh->max_size) {
+    rh->size++;
+  } else {
+    /* One packet was dropped */
+    rh->roff++;
+    if (rh->roff == rh->max_size) rh->roff = 0;
+  }
+  return 0;
+}
+
+static inline unsigned _ring_get_fullness(void **ring_ptr) {
+  assert(*ring_ptr);
+  ring_hdr_t *rh = ring_hdr(*ring_ptr);
+  return rh->size * 100 / rh->max_size;
+}
+
+static inline unsigned _ring_is_full(void **ring_ptr) {
+  assert(*ring_ptr);
+  ring_hdr_t *rh = ring_hdr(*ring_ptr);
+  return rh->size == rh->max_size;
+}
+
+static inline size_t _ring_get_size(void **ring_ptr) {
+  assert(*ring_ptr);
+  ring_hdr_t *rh = ring_hdr(*ring_ptr);
+  return rh->size;
+}
+
+static inline int _ring_advance(void **ring_ptr, unsigned n) {
+  assert(*ring_ptr);
+  ring_hdr_t *rh = ring_hdr(*ring_ptr);
+  assert(n <= rh->size);
+
+  rh->roff += n;
+  rh->size -= n;
+  while (rh->roff >= rh->max_size) rh->roff -= rh->max_size;
+  return 0;
+}
+
+static inline int _ring_get(void **ring_ptr, size_t elt_size, unsigned i,
+                            void *eltp) {
+  assert(*ring_ptr);
+  ring_hdr_t *rh = ring_hdr(*ring_ptr);
+  assert(i <= rh->size);
+  size_t pos = rh->roff + i;
+  if (pos >= rh->max_size) pos -= rh->max_size;
+  memcpy(eltp, (uint8_t *)*ring_ptr + pos * elt_size, elt_size);
+  return 0;
+}
+
+/******************************************************************************/
+/* Public API */
+
+/**
+ * @brief Allocate and initialize a ring data structure.
+ *
+ * @param[in,out] ring Ring to allocate and initialize.
+ * @param[in] max_size Maximum ring size (nonzero).
+ *
+ * NOTE:
+ *  - Allocated memory is set to 0 (used by bitmap)
+ */
+
+#define ring_init(RING, MAX_SIZE) \
+  _ring_init((void **)&(RING), sizeof((RING)[0]), (MAX_SIZE))
+
+#define ring_free(RING) _ring_free((void **)&(RING))
+
+#define ring_get_fullness(RING) _ring_get_fullness((void **)&(RING))
+
+#define ring_is_full(RING) _ring_is_full((void **)&(RING))
+
+#define ring_get_size(RING) _ring_get_size((void **)&(RING))
+
+#define ring_add(RING, ELT) _ring_add((void **)&(RING), sizeof(RING[0]), ELT)
+
+#define ring_add_value(RING, VALUE)                              \
+  do {                                                           \
+    typeof(VALUE) _ring_var(v) = VALUE;                          \
+    _ring_add((void **)&(RING), sizeof(RING[0]), &_ring_var(v)); \
+  } while (0)
+
+#define ring_advance(RING, N) _ring_advance((void **)&(RING), (N))
+
+#define ring_get(RING, I, ELTP) \
+  _ring_get((void **)&RING, sizeof(RING[0]), (I), (ELTP))
+
+/**
+ * @brief Helper function used by ring_foreach().
+ */
+#define ring_enumerate_n(RING, I, ELTP, COUNT, BODY)                \
+  ({                                                                \
+    for ((I) = 0; (I) < MIN(ring_get_size(RING), (COUNT)); (I)++) { \
+      ring_get((RING), (I), (ELTP));                                \
+      { BODY; }                                                     \
+    }                                                               \
+  })
+
+#define ring_enumerate(ring, i, eltp, BODY) \
+  ring_enumerate_n((ring), (i), (eltp), 1, (BODY))
+
+/**
+ * @brief Iterate over elements in a ring.
+ *
+ * @param[in] pool The ring data structure to iterate over
+ * @param[in, out] eltp A pointer to the element that will be used for
+ * iteration
+ * @param[in] BODY Block to execute during iteration
+ *
+ * @note Iteration will execute BODY with eltp corresponding successively to all
+ * elements found in the ring. It is implemented using the more generic
+ * enumeration function.
+ */
+#define ring_foreach_n(ring, eltp, count, BODY)                    \
+  ({                                                               \
+    unsigned _ring_var(i);                                         \
+    ring_enumerate_n((ring), _ring_var(i), (eltp), (count), BODY); \
+  })
+
+#define ring_foreach(ring, eltp, BODY) ring_foreach_n((ring), (eltp), 1, (BODY))
+
+#endif /* UTIL_RING_H */
diff --git a/hicn-light/src/hicn/base/vector.c b/hicn-light/src/hicn/base/vector.c
new file mode 100644
index 000000000..36d808932
--- /dev/null
+++ b/hicn-light/src/hicn/base/vector.c
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file vector.c
+ * \brief Implementation of resizeable static array
+ */
+
+#include <assert.h>
+#include <stddef.h>  // size_t
+#include <stdlib.h>  // calloc
+#include <stdio.h>
+
+#include "vector.h"
+
+#define DEFAULT_VECTOR_SIZE 64
+
+void _vector_init(void** vector_ptr, size_t elt_size, size_t init_size,
+                  size_t max_size) {
+  assert(vector_ptr);
+  assert(max_size == 0 || init_size < max_size);
+
+  if (init_size == 0) init_size = DEFAULT_VECTOR_SIZE;
+
+  *vector_ptr = NULL;
+  _vector_resize(vector_ptr, elt_size, init_size);
+
+  vector_hdr_t* vh = vector_hdr(*vector_ptr);
+  vh->cur_size = 0;
+  vh->max_size = max_size;
+}
+
+void _vector_free(void** vector_ptr) {
+  free(vector_hdr(*vector_ptr));
+  *vector_ptr = NULL;
+}
+
+int _vector_resize(void** vector_ptr, size_t elt_size, off_t pos) {
+  vector_hdr_t* vh;
+
+  size_t old_size;
+
+  if (*vector_ptr) {
+    vh = vector_hdr(*vector_ptr);
+    old_size = vh->alloc_size;
+  } else {
+    vh = NULL;
+    old_size = 0;
+  }
+
+  /* Round the allocated size to the next power of 2 of the requested position
+   */
+  size_t new_size = next_pow2(pos);
+
+  /* Don't grow the vector back */
+  if (new_size < old_size) return 0;
+
+  /* Don't exceed maximum size (for init, check is done beforehand) */
+  if (vh && vh->max_size && new_size > vh->max_size) return -1;
+
+  vh = realloc(vh, VECTOR_HDRLEN + new_size * elt_size);
+  if (!vh) return -1;
+  vh->alloc_size = new_size;
+
+  /* Zero out the newly allocated memory (except headers) */
+  memset((uint8_t*)vh + VECTOR_HDRLEN + old_size * elt_size, 0,
+         (new_size - old_size) * elt_size);
+
+  /* Reassign vector pointer */
+  *vector_ptr = (uint8_t*)vh + VECTOR_HDRLEN;
+
+  return 0;
+}
diff --git a/hicn-light/src/hicn/base/vector.h b/hicn-light/src/hicn/base/vector.h
new file mode 100644
index 000000000..0b7a74aeb
--- /dev/null
+++ b/hicn-light/src/hicn/base/vector.h
@@ -0,0 +1,327 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file vector.h
+ * \brief Resizeable static array
+ *
+ * A vector is a resizeable area of contiguous memory that contains elements of
+ * fixed size. It is mostly useful to serve as the basis for more advanced data
+ * structures such as memory pools.
+ *
+ * The internal API manipulates a pointer to the vector so that it can be
+ * seamlessly resized, and a more convenient user interface is provided through
+ * macros.
+ *
+ * A vector starts at index 0, and is typed according to the elements it
+ * contains. For that matter, the data structure header precedes the returned
+ * pointer which corresponds to the storage area.
+ *
+ * A vector is by default used as a stack where an end marker is maintained and
+ * new elements are pushed right after this end marker (an indication of
+ * the size of the vector) after ensuring the vector is sufficiently large.
+ *
+ * A user should not store any pointer to vector elements as this might change
+ * during reallocations, but should use indices instead.
+ *
+ * NOTE: a maximum size is currently not implemented.
+ *
+ * It is freely inspired (and simplified) from the VPP infra infrastructure
+ * library.
+ */
+
+#ifndef UTIL_VECTOR_H
+#define UTIL_VECTOR_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/types.h>
+
+#include "common.h"
+
+/******************************************************************************/
+/* Vector header */
+
+typedef struct {
+  size_t cur_size;   /** Vector current size (corresponding to the highest used
+                        element). */
+  size_t alloc_size; /** The currently allocated size. */
+  size_t max_size;   /** The maximum allowed size (0 = no limit) */
+} vector_hdr_t;
+
+/* Make sure elements following the header are aligned */
+#define VECTOR_HDRLEN SIZEOF_ALIGNED(vector_hdr_t)
+
+/* This header actually prepends the actual content of the vector */
+#define vector_hdr(vector) ((vector_hdr_t *)((uint8_t *)vector - VECTOR_HDRLEN))
+
+/******************************************************************************/
+/* Helpers */
+
+/** Local variable naming macro. */
+#define _vector_var(v) _vector_##v
+
+/**
+ * @brief Allocate and initialize a vector data structure (helper function).
+ *
+ * @param[in,out] vector_ptr Vector to allocate and initialize.
+ * @param[in] elt_size Size of a vector element.
+ * @param[in] init_size Initial vector size.
+ * @param[in] max_size Maximum vector size (O = unlimited).
+ */
+void _vector_init(void **vector_ptr, size_t elt_size, size_t init_size,
+                  size_t max_size);
+
+/**
+ * @brief Free a vector data structure.
+ *
+ * @param vector_ptr[in] Pointer to the vector data structure to free.
+ */
+void _vector_free(void **vector_ptr);
+
+/**
+ * @brief Resize a vector data structure.
+ *
+ * @param[in] vector_ptr A pointer to the vector data structure to resize.
+ * @param[in] elt_size The size of a vector element.
+ * @param[in] pos The position at which the vector should be able to hold an
+ * element.
+ *
+ * @return int Flag indicating whether the vector has been correctly resized.
+ *
+ * NOTE:
+ *  - The resize operation does not specify the final size of the vector but
+ * instead ensure that it is large enough to hold an element at the specified
+ * position. This allows the caller not to care about doing successive calls to
+ * this API while the vector is growing in size.
+ */
+int _vector_resize(void **vector_ptr, size_t elt_size, off_t pos);
+
+/**
+ * @brief Ensures a vector is sufficiently large to hold an element at the
+ * given position.
+ *
+ * @param[in] vector_ptr A pointer to the vector data structure to resize.
+ * @param[in] elt_size The size of a vector element.
+ * @param[in] pos The position to validate.
+ *
+ * @return int Flag indicating whether the vector is available.
+ *
+ * NOTE:
+ *  - This function should always be called before writing to a vector element
+ *  to eventually make room for it (the vector will eventually be resized).
+ *  - This function can fail if the vector is full and for any reason it cannot
+ *  be resized.
+ */
+static inline int _vector_ensure_pos(void **vector_ptr, size_t elt_size,
+                                     off_t pos) {
+  vector_hdr_t *vh = vector_hdr(*vector_ptr);
+  if (pos >= (off_t)vh->alloc_size)
+    return _vector_resize(vector_ptr, elt_size, pos + 1);
+  return 0;
+}
+
+/**
+ * @brief Push an element at the end of a vector.
+ *
+ * @param[in] vector_ptr A pointer to the vector data structure to resize.
+ * @param[in] elt_size The size of a vector element.
+ * @param[in] elt The element to insert.
+ *
+ * NOTE:
+ *  - This function ensures there is sufficient room for inserting the element,
+ *  and evenutually resizes the vector to make room for it (if allowed by
+ *  maximum size).
+ */
+static inline int _vector_push(void **vector_ptr, size_t elt_size, void *elt) {
+  vector_hdr_t *vh = vector_hdr(*vector_ptr);
+  if (_vector_ensure_pos(vector_ptr, elt_size, vh->cur_size) < 0) return -1;
+
+  /* Always get header after a potential resize */
+  vh = vector_hdr(*vector_ptr);
+  memcpy((uint8_t *)*vector_ptr + vh->cur_size * elt_size, elt, elt_size);
+  vh = vector_hdr(*vector_ptr);
+  vh->cur_size++;
+  return 0;
+}
+
+/**
+ * @brief Remove all the occurrencies of an element from the vector.
+ * The order of the elements is NOT maintained.
+ *
+ * @param[in, out] vector The vector data structure to resize
+ * @param[in] elt_size The size of a vector element
+ * @param[in] elt The element to remove
+ * @return int Number of elemets (equal to 'elt') removed from the vector
+ */
+static inline int _vector_remove_unordered(void *vector, size_t elt_size,
+                                           void *elt) {
+  size_t num_removed = 0;
+  vector_hdr_t *vh = vector_hdr(vector);
+  for (size_t i = 0; i < vector_hdr(vector)->cur_size; i++) {
+    if (memcmp((uint8_t *)vector + i * elt_size, elt, elt_size) == 0) {
+      vh->cur_size--;
+      memcpy((uint8_t *)vector + i * elt_size,
+             (uint8_t *)vector + vh->cur_size * elt_size, elt_size);
+      num_removed++;
+    }
+  }
+  return num_removed;
+}
+
+/******************************************************************************/
+/* Public API */
+
+/**
+ * @brief Allocate and initialize a vector data structure.
+ *
+ * @param[in,out] vector Vector to allocate and initialize.
+ * @param[in] init_size Initial vector size.
+ * @param[in] max_size Maximum vector size (nonzero).
+ *
+ * NOTE:
+ *  - Allocated memory is set to 0 (used by bitmap)
+ */
+
+#define vector_init(vector, init_size, max_size) \
+  _vector_init((void **)&vector, sizeof(vector[0]), init_size, max_size)
+
+/**
+ * @brief Free a vector data structure.
+ *
+ * @param[in] vector The vector data structure to free.
+ */
+#define vector_free(vector) _vector_free((void **)&vector)
+
+/**
+ * @brief Resize a vector data structure.
+ *
+ * @param[in] vector The vector data structure to resize.
+ * @param[in] pos The position at which the vector should be able to hold an
+ * element.
+ *
+ * @return int Flag indicating whether the vector has been correctly resized.
+ *
+ * NOTE:
+ *  - The resize operation does not specify the final size of the vector but
+ * instead ensure that it is large enough to hold an element at the specified
+ * position. This allows the caller not to care about doing successive calls to
+ * this API while the vector is growing in size.
+ *  - If the new size is smaller than the current size, the content of the
+ *  vector will be truncated.
+ * - Newly allocated memory is set to 0 (used by bitmap)
+ */
+#define vector_resize(vector) \
+  _vector_resize((void **)&(vector), sizeof((vector)[0]), 0)
+
+/**
+ * @brief Ensures a vector is sufficiently large to hold an element at the
+ * given position.
+ *
+ * @param[in] vector The vector for which to validate the position.
+ * @param[in] pos The position to validate.
+ *
+ * NOTE:
+ *  - This function should always be called before writing to a vector element
+ *  to eventually make room for it (the vector will eventually be resized).
+ */
+#define vector_ensure_pos(vector, pos) \
+  _vector_ensure_pos((void **)&(vector), sizeof((vector)[0]), pos);
+
+/**
+ * @brief Push an element at the end of a vector.
+ *
+ * @param[in] vector The vector in which to insert the element.
+ * @param[in] elt The element to insert.
+ *
+ * NOTE:
+ *  - This function ensures there is sufficient room for inserting the element,
+ *  and evenutually resizes the vector to make room for it (if allowed by
+ *  maximum size).
+ */
+#define vector_push(vector, elt)                                         \
+  ({                                                                     \
+    typeof(elt) x = elt;                                                 \
+    _vector_push((void **)&(vector), sizeof((vector)[0]), (void *)(&x)); \
+  })
+
+/**
+ * @brief Remove all the occurrencies of an element from the vector.
+ * The order of the elements is NOT maintained.
+ *
+ * @param[in, out] vector The vector data structure to resize
+ * @param[in] elt The element to remove
+ * @return int Number of elemets (equal to 'elt') removed from the vector
+ */
+#define vector_remove_unordered(vector, elt)                        \
+  ({                                                                \
+    typeof(elt) x = elt;                                            \
+    _vector_remove_unordered((void *)(vector), sizeof((vector)[0]), \
+                             (void *)(&x));                         \
+  })
+
+/**
+ * @brief Returns the length of a vector.
+ *
+ * @param[in] vector The vector from which to get the size.
+ *
+ * @see vector_ensure_pos
+ *
+ * NOTE:
+ *  - The size of the vector corresponds to the highest accessed index (for
+ * example as specified in the resize operation) and not the currently
+ * allocated size which will typically be bigger to amortize allocations.
+ *  - A user should always call vector_ensure_pos to ensure the vector is
+ *  sufficiently large to hold an element at the specified position.
+ */
+#define vector_len(vector) vector_hdr(vector)->cur_size
+
+/**
+ * @brief Returns the allocated size of a vector.
+ */
+#define vector_get_alloc_size(vector) vector_hdr(vector)->alloc_size
+
+/**
+ * @brief Iterate over elements in a vector.
+ *
+ * @param[in] pool The vector data structure to iterate over
+ * @param[in, out] eltp A pointer to the element that will be used for
+ * iteration
+ * @param[in] BODY Block to execute during iteration
+ *
+ * @note Iteration will execute BODY with eltp corresponding successively to all
+ * elements found in the vector. It is implemented using the more generic
+ * enumeration function.
+ */
+#define vector_foreach(vector, eltp, BODY)                    \
+  ({                                                          \
+    unsigned _vector_var(i);                                  \
+    vector_enumerate((vector), _vector_var(i), (eltp), BODY); \
+  })
+
+/**
+ * @brief Helper function used by vector_foreach().
+ */
+#define vector_enumerate(vector, i, eltp, BODY)      \
+  ({                                                 \
+    for ((i) = 0; (i) < vector_len(vector); (i)++) { \
+      eltp = (vector) + (i);                         \
+      { BODY; }                                      \
+    }                                                \
+  })
+
+#endif /* UTIL_VECTOR_H */
diff --git a/hicn-light/src/hicn/cli/CMakeLists.txt b/hicn-light/src/hicn/cli/CMakeLists.txt
new file mode 100644
index 000000000..39581e6ad
--- /dev/null
+++ b/hicn-light/src/hicn/cli/CMakeLists.txt
@@ -0,0 +1,93 @@
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+if (NOT DISABLE_EXECUTABLES)
+##############################################################
+# Force libhicn library to whole archive mode
+##############################################################
+  if (APPLE)
+    set(
+      LIBHICN_LIGHT_WHOLE_ARCHIVE
+      "-Wl,-force_load"
+      "${LIBHICN_LIGHT_STATIC}"
+    )
+  else()
+    set(
+      LIBHICN_LIGHT_WHOLE_ARCHIVE
+      "-Wl,--whole-archive"
+      "${LIBHICN_LIGHT_STATIC}"
+      "-Wl,--no-whole-archive"
+    )
+  endif()
+
+##############################################################
+# Sources
+##############################################################
+  list(APPEND CONTROLLER_SRC
+      color.c
+      hicnc.c
+  )
+
+
+##############################################################
+# Build hicn-light-control
+##############################################################
+  build_executable(${HICN_LIGHT_CONTROL}
+    SOURCES ${CONTROLLER_SRC}
+    LINK_LIBRARIES ${LIBHICN_LIGHT_WHOLE_ARCHIVE}
+    DEPENDS ${LIBHICN_LIGHT_STATIC}
+    COMPONENT ${HICN_LIGHT}
+    DEFINITIONS ${COMPILER_DEFINITIONS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS}
+  )
+
+
+##############################################################
+# Build hicn-light-shell
+##############################################################
+  list(APPEND SHELL_SRC
+    color.c
+    hicns.c
+  )
+
+  build_executable(${HICN_LIGHT_SHELL}
+    SOURCES ${SHELL_SRC}
+    LINK_LIBRARIES ${LIBHICN_LIGHT_WHOLE_ARCHIVE}
+    DEPENDS ${LIBHICN_LIGHT_STATIC}
+    COMPONENT ${HICN_LIGHT}
+    DEFINITIONS ${COMPILER_DEFINITIONS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS}
+  )
+
+
+##############################################################
+# Build hicn-light-shell
+##############################################################
+  list(APPEND DAEMON_SRC
+    color.c
+    hicnd.c
+  )
+
+  # hicn-light-daemon does not compile under Android due to bindSocket
+  if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Android")
+    build_executable(${HICN_LIGHT_DAEMON}
+      SOURCES ${DAEMON_SRC}
+      LINK_LIBRARIES ${LIBHICN_LIGHT_WHOLE_ARCHIVE}
+      DEPENDS ${LIBHICN_LIGHT_STATIC}
+      COMPONENT ${HICN_LIGHT}
+      DEFINITIONS ${COMPILER_DEFINITIONS}
+      COMPILE_OPTIONS ${COMPILER_OPTIONS}
+    )
+  endif ()
+endif ()
diff --git a/hicn-light/src/hicn/cli/color.c b/hicn-light/src/hicn/cli/color.c
new file mode 100644
index 000000000..aed22e302
--- /dev/null
+++ b/hicn-light/src/hicn/cli/color.c
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include "color.h"
+
+#ifndef _WIN32
+
+void vprintfc(color_t color, const char* fmt, va_list ap) {
+  char* color_s;
+  switch (color) {
+#define _(x, y, z) \
+  case COLOR_##x:  \
+    color_s = y;   \
+    break;
+    foreach_color
+#undef _
+
+        case COLOR_UNDEFINED : case COLOR_N : default :  // XXX
+                                                         color_s = "";
+    break;
+  }
+  printf("%s", color_s);
+  vprintf(fmt, ap);
+}
+#else
+void vprintfc(color_t color, const char* fmt, va_list ap) {
+  int color_id;
+  switch (color) {
+#define _(x, y, z) \
+  case COLOR_##x:  \
+    color_id = z;  \
+    break;
+    foreach_color
+#undef _
+
+        case COLOR_UNDEFINED : case COLOR_N : color_id = 0;
+    break;
+  }
+  HANDLE hConsole = NULL;
+  WORD currentConsoleAttr;
+  CONSOLE_SCREEN_BUFFER_INFO csbi;
+  hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+  if (GetConsoleScreenBufferInfo(hConsole, &csbi))
+    currentConsoleAttr = csbi.wAttributes;
+  if (color_id != 0) SetConsoleTextAttribute(hConsole, color_id);
+  fprintf("%s", color);
+  vfprintf(fmt, ap);
+  SetConsoleTextAttribute(hConsole, currentConsoleAttr);
+}
+#endif
+
+void printfc(color_t color, const char* fmt, ...) {
+  va_list ap;
+
+  va_start(ap, fmt);
+  vprintfc(color, fmt, ap);
+  va_end(ap);
+}
diff --git a/hicn-light/src/hicn/core/connectionState.h b/hicn-light/src/hicn/cli/color.h
index 9daa15c9c..a9b71c047 100644
--- a/hicn-light/src/hicn/core/connectionState.h
+++ b/hicn-light/src/hicn/cli/color.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,25 +13,30 @@
  * limitations under the License.
  */
 
-/**
- * @file connection_state.h
- * @brief Represents the state of a connection
- *
- */
+#ifndef HICNLIGHT_COLOR
+#define HICNLIGHT_COLOR
 
-#ifndef connection_state_h
-#define connection_state_h
+#include <stdarg.h>
 
-#define foreach_connection_state        \
-    _(UNDEFINED)                        \
-    _(DOWN)                             \
-    _(UP)                               \
-    _(N)
+/*
+ * Format : color_name, escape sequence, windows id
+ */
+#define foreach_color     \
+  _(RED, "\033[0;31m", 4) \
+  _(WHITE, "\033[0m", 7)
 
 typedef enum {
-#define _(x) CONNECTION_STATE_ ## x,
-foreach_connection_state
+  COLOR_UNDEFINED,
+#define _(x, y, z) COLOR_##x,
+  foreach_color
 #undef _
-} connection_state_t;
+      COLOR_N,
+} color_t;
+
+#define IS_VALID_COLOR(color) ((color != COLOR_UNDEFINED) && (color != COLOR_N))
+
+void vprintfc(color_t color, const char* fmt, va_list ap);
+
+void printfc(color_t color, const char* fmt, ...);
 
-#endif /* connection_state_h */
+#endif /* HICNLIGHT_COLOR */
diff --git a/hicn-light/src/hicn/cli/hicnc.c b/hicn-light/src/hicn/cli/hicnc.c
new file mode 100644
index 000000000..d14093b6b
--- /dev/null
+++ b/hicn-light/src/hicn/cli/hicnc.c
@@ -0,0 +1,390 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <limits.h>  // LONG_MAX, LONG_MIN
+#include <signal.h>
+#include <hicn/ctrl.h>
+
+#ifndef _WIN32
+#include <getopt.h>
+#endif
+
+#include "color.h"
+#include "../config/parse.h"
+#include <hicn/util/log.h>
+#include <hicn/util/sstrncpy.h>
+
+#define PORT 9695
+
+static struct option longFormOptions[] = {{"help", no_argument, 0, 'h'},
+                                          {"server", required_argument, 0, 'S'},
+                                          {"port", required_argument, 0, 'P'},
+                                          {0, 0, 0, 0}};
+
+static void usage(char *prog) {
+  printf("%s: portable hICN forwarder\n", prog);
+  printf("\n");
+  printf("Usage: %s COMMAND [PARAMETERS]\n", prog);
+  printf("\n");
+  printf("       %s -h        This help screen.\n", prog);
+  printf("       %s help      Obtain a list of available commands.\n", prog);
+  printf("\n");
+}
+
+static bool stop = false;
+void signal_handler(int sig) {
+  fprintf(stderr, "Received ^C... quitting !\n");
+  stop = true;
+}
+
+int main(int argc, char *const *argv) {
+  log_conf.log_level = LOG_INFO;
+
+  // Handle termination signal
+  struct sigaction sa;
+  memset(&sa, 0, sizeof(sa));
+  sa.sa_handler = signal_handler;
+  sigaction(SIGINT, &sa, NULL);
+
+  /* Parse commandline */
+  char *server_ip = NULL;
+  uint16_t server_port = 0;
+
+  for (;;) {
+    // getopt_long stores the option index here.
+    int optind = 0;
+
+    int c = getopt_long(argc, argv, "hS:P:", longFormOptions, &optind);
+    if (c == -1) break;
+
+    switch (c) {
+      case 'S':
+        server_ip = optarg;
+        break;
+
+      case 'P': {
+        char *endptr;
+        long val = strtol(optarg, &endptr, 10);
+
+        errno = 0; /* To distinguish success/failure after call */
+
+        if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN)) ||
+            (errno != 0 && val == 0)) {
+          perror("strtol");
+          exit(EXIT_FAILURE);
+        }
+
+        if (endptr == optarg) {
+          fprintf(stderr, "No digits were found.\n");
+          exit(EXIT_FAILURE);
+        }
+
+        if (*endptr != '\0') {
+          fprintf(stderr, "Spurious characters after number: %s.\n", endptr);
+          exit(EXIT_FAILURE);
+        }
+
+        if ((val < 1) || (val > 65535)) {
+          fprintf(stderr, "Invalid port number: %ld.\n", val);
+          exit(EXIT_FAILURE);
+        }
+
+        server_port = val;
+        break;
+      }
+
+      case 'h':
+        usage(argv[0]);
+        exit(EXIT_SUCCESS);
+
+      default:
+        fprintf(stderr, "Invalid argument.\n");
+        usage(argv[0]);
+        exit(EXIT_FAILURE);
+    }
+  }
+
+  /* Parse */
+  char *param = argv[optind];
+  for (; optind < argc - 1; optind++) {
+    char *arg = argv[optind];
+    arg[strlen(arg)] = ' ';
+  }
+
+  if (!param) {
+    usage(argv[0]);
+    goto ERR_PARAM;
+  }
+
+  if (strncmp(param, "help", 4) == 0) {
+    if (help(param) < 0) {
+      usage(argv[0]);
+      exit(EXIT_FAILURE);
+    }
+    exit(EXIT_SUCCESS);
+  }
+
+  hc_command_t command = {};
+  if (parse(param, &command) < 0) {
+    fprintf(stderr, "Error parsing command : '%s'\n", param);
+    goto ERR_PARSE;
+  }
+
+  hc_sock_t *s;
+  if (server_ip) {
+    if (server_port == 0) server_port = PORT;
+#define BUFSIZE 255
+    char url[BUFSIZE];
+    snprintf(url, BUFSIZE, "tcp://%s:%d/", server_ip, server_port);
+    s = hc_sock_create_forwarder_url(HICNLIGHT_NG, url);
+  } else {
+    s = hc_sock_create_forwarder(HICNLIGHT_NG);
+  }
+  if (!s) {
+    fprintf(stderr, "Could not create socket.\n");
+    goto ERR_SOCK;
+  }
+
+  if (hc_sock_connect(s) < 0) {
+    fprintf(stderr, "Could not establish connection to forwarder.\n");
+    goto ERR_CONNECT;
+  }
+
+  if (!IS_VALID_OBJECT_TYPE(command.object.type) ||
+      !IS_VALID_ACTION(command.action)) {
+    fprintf(stderr, "Unsupported command");
+    goto ERR_PARAM;
+  }
+
+  int rc = UNSUPPORTED_CMD_ERROR;
+  hc_data_t *data = NULL;
+  char buf_listener[MAXSZ_HC_LISTENER];
+  char buf_connection[MAXSZ_HC_CONNECTION];
+  char buf_route[MAXSZ_HC_ROUTE];
+  char buf[MAX_LEN];
+  switch (command.object.type) {
+    case OBJECT_ROUTE:
+      switch (command.action) {
+        case ACTION_CREATE:
+          rc = hc_route_create(s, &command.object.route);
+          break;
+
+        case ACTION_DELETE:
+          rc = hc_route_delete(s, &command.object.route);
+          break;
+
+        case ACTION_LIST:
+          rc = hc_route_list(s, &data);
+          if (rc < 0) break;
+
+          INFO("Routes:");
+          foreach_route(r, data) {
+            if (hc_route_snprintf(buf_route, MAXSZ_HC_ROUTE, r) >=
+                MAXSZ_HC_ROUTE)
+              ERROR("Display error");
+            INFO("%s", buf_route);
+          }
+          break;
+
+        default:
+          break;
+      }
+      break;
+
+    case OBJECT_LISTENER:
+      switch (command.action) {
+        case ACTION_CREATE:
+          rc = hc_listener_create(s, &command.object.listener);
+          break;
+
+        case ACTION_DELETE:
+          rc = hc_listener_delete(s, &command.object.listener);
+          break;
+
+        case ACTION_LIST:
+          rc = hc_listener_list(s, &data);
+          if (rc < 0) break;
+
+          INFO("Listeners:");
+          foreach_listener(l, data) {
+            if (hc_listener_snprintf(buf_listener, MAXSZ_HC_LISTENER + 17, l) >=
+                MAXSZ_HC_LISTENER)
+              ERROR("Display error");
+            INFO("[%d] %s", l->id, buf_listener);
+          }
+          break;
+
+        default:
+          break;
+      }
+      break;
+
+    case OBJECT_CONNECTION:
+      switch (command.action) {
+        case ACTION_CREATE:
+          rc = hc_connection_create(s, &command.object.connection);
+          break;
+
+        case ACTION_DELETE:
+          rc = hc_connection_delete(s, &command.object.connection);
+          break;
+
+        case ACTION_LIST:
+          rc = hc_connection_list(s, &data);
+          if (rc < 0) break;
+
+          INFO("Connections:");
+          foreach_connection(c, data) {
+            if (hc_connection_snprintf(buf_connection, MAXSZ_HC_CONNECTION,
+                                       c) >= MAXSZ_HC_CONNECTION)
+              ERROR("Display error");
+            INFO("[%d] %s", c->id, buf_connection);
+          }
+          break;
+
+        default:
+          break;
+      }
+      break;
+
+    case OBJECT_CACHE:
+      switch (command.action) {
+        case ACTION_SERVE:
+          rc = hc_cache_set_serve(s, &command.object.cache);
+          break;
+
+        case ACTION_STORE:
+          rc = hc_cache_set_store(s, &command.object.cache);
+          break;
+
+        case ACTION_CLEAR:
+          rc = hc_cache_clear(s, &command.object.cache);
+          break;
+
+        case ACTION_LIST:
+          rc = hc_cache_list(s, &data);
+          if (rc < 0) break;
+
+          hc_cache_snprintf(buf, MAX_LEN, (hc_cache_info_t *)data->buffer);
+          printf("%s\n", buf);
+          break;
+
+        default:
+          break;
+      }
+      break;
+
+    case OBJECT_STRATEGY:
+      switch (command.action) {
+        case ACTION_SET:
+          rc = hc_strategy_set(s, &command.object.strategy);
+          break;
+
+        default:
+          break;
+      }
+      break;
+
+    case OBJECT_MAPME:
+      switch (command.action) {
+        case ACTION_UPDATE:
+          rc = hc_mapme_send_update(s, &command.object.mapme);
+          break;
+        case ACTION_SET:
+          if (command.object.mapme.target == MAPME_TARGET_ENABLE) {
+            rc = hc_mapme_set(s, &command.object.mapme);
+          } else if (command.object.mapme.target == MAPME_TARGET_DISCOVERY) {
+            rc = hc_mapme_set_discovery(s, &command.object.mapme);
+          } else if (command.object.mapme.target == MAPME_TARGET_TIMESCALE) {
+            rc = hc_mapme_set_timescale(s, &command.object.mapme);
+          } else if (command.object.mapme.target == MAPME_TARGET_RETX) {
+            rc = hc_mapme_set_retx(s, &command.object.mapme);
+          }
+          break;
+
+        default:
+          break;
+      }
+      break;
+
+    case OBJECT_LOCAL_PREFIX:
+      switch (command.action) {
+        case ACTION_CREATE:
+          rc = hc_strategy_add_local_prefix(s, &command.object.strategy);
+          break;
+
+        default:
+          break;
+      }
+      break;
+
+    case OBJECT_SUBSCRIPTION:
+      // Disable socket recv timeout
+      hc_sock_set_recv_timeout_ms(s, 0);
+
+      rc = hc_subscription_create(s, &command.object.subscription);
+      if (rc < 0) break;
+      INFO("Subscription sent");
+
+      while (!stop) {
+        int rc = hc_sock_callback(s, &data);
+        if (rc < 0 && !stop) ERROR("Notification error");
+
+        if (!stop) {
+          event_type_t event_type = rc;
+          INFO("Notification recevied %s [%d]", event_str(event_type),
+               event_type);
+
+          if (event_type == EVENT_INTERFACE_UPDATE) {
+            hc_event_interface_update_t *event =
+                (hc_event_interface_update_t *)(data->buffer);
+            INFO("Interface update event received: %u", event->interface_type);
+          }
+        }
+      }
+
+      INFO("Unsubscribing...");
+      rc = hc_subscription_delete(s, &command.object.subscription);
+      break;
+
+    default:
+      break;
+  }
+  hc_data_free(data);
+
+  if (rc < -1) {
+    if (rc == INPUT_ERROR) ERROR("Wrong input parameters");
+    if (rc == UNSUPPORTED_CMD_ERROR) ERROR("Unsupported command");
+    goto ERR_CMD;
+  }
+  if (rc < 0) ERROR("Error executing command");
+
+  // Remove the connection created to send the command
+  command.object.connection.id = 0;
+  rc = strcpy_s(command.object.connection.name,
+                sizeof(command.object.connection.name), "SELF");
+  if (rc != EOK || hc_connection_delete(s, &command.object.connection) < 0)
+    fprintf(stderr, "Error removing local connection to forwarder\n");
+
+  exit(EXIT_SUCCESS);
+
+ERR_CMD:
+ERR_CONNECT:
+  hc_sock_free(s);
+ERR_SOCK:
+ERR_PARSE:
+ERR_PARAM:
+  exit(EXIT_FAILURE);
+}
diff --git a/hicn-light/src/hicn/cli/hicnd.c b/hicn-light/src/hicn/cli/hicnd.c
new file mode 100644
index 000000000..e73517e4c
--- /dev/null
+++ b/hicn-light/src/hicn/cli/hicnd.c
@@ -0,0 +1,311 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+#include <errno.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#include <hicn/util/log.h>
+
+#include "logo.h"
+#include "../base/loop.h"
+#include "../core/forwarder.h"
+#include "../config/configuration.h"  // XXX needed ?
+#include "../config/configuration_file.h"
+
+static void usage(const char *prog) {
+  printf(
+      "Usage: %s [--port port]"
+#ifndef _WIN32
+      " [--daemon]"
+#endif
+      " [--capacity objectStoreSize] [--log level]"
+      "[--log-file filename] [--config file]\n",
+      prog);
+  printf("\n");
+  printf(
+      "hicn-light run as a daemon is the program to launch the forwarder, "
+      "either as a console program\n");
+  printf(
+      "or a background daemon (detatched from console).  Once running, use the "
+      "program controller to\n");
+  printf("configure hicn-light.\n");
+  printf("\n");
+  printf(
+      "The configuration file contains configuration lines as per "
+      "controller\n");
+  printf(
+      "If logging level or content store capacity is set in the configuraiton "
+      "file, it overrides the command_line\n");
+  printf(
+      "When a configuration file is specified, no default listeners on 'port' "
+      "are setup.  Only 'add listener' lines\n");
+  printf("in the configuration file matter.\n");
+  printf("\n");
+  printf(
+      "If no configuration file is specified, daemon will listen on TCP and "
+      "UDP ports specified by\n");
+  printf(
+      "the --port flag (or default port).  It will listen on both IPv4 and "
+      "IPv6 if available.\n");
+  printf("\n");
+  printf("Options:\n");
+  printf("%-30s = tcp port for in-bound connections\n", "--port <tcp_port>");
+#ifndef _WIN32
+  printf("%-30s = start as daemon process\n", "--daemon");
+#endif
+  printf(
+      "%-30s = maximum number of content objects to cache. To disable the "
+      "cache objectStoreSize must be 0.\n",
+      "--capacity <objectStoreSize>");
+  printf("%-30s   Default vaule for objectStoreSize is  100000\n", "");
+  printf(
+      "%-30s = sets the log level. Available levels: trace, debug, info, warn, "
+      "error, fatal\n",
+      "--log <level>");
+  printf("%-30s = file to write log messages to  (required in daemon mode)\n",
+         "--log-file <output_logfile>");
+  printf("%-30s = configuration filename\n", "--config <config_path>");
+  printf("\n");
+}
+
+#ifndef _WIN32
+static int daemonize(int logfile_fd) {
+  /* Check whether we already are a daemon */
+  if (getppid() == 1) return 0;
+
+  int rc = fork();
+  if (rc < 0) {
+    ERROR("Fork error");
+    goto ERR_FORK;
+  } else if (rc > 0) {
+    /* Parent exits successfully */
+    exit(EXIT_SUCCESS);
+  }
+
+  /* Child daemon detaches */
+  DEBUG("child continuing, pid = %u\n", getpid());
+
+  /* get a new process group independent from old parent */
+  setsid();
+
+  /* close all descriptors (apart from the logfile) */
+#ifdef __ANDROID__
+  for (int i = sysconf(_SC_OPEN_MAX); i >= 0; --i) close(i);
+#else
+  for (int i = getdtablesize(); i >= 0; --i) {
+    if (i != logfile_fd) close(i);
+  }
+#endif
+
+  /*
+   * Reset errno because it might be seg to EBADF from the close calls above
+   */
+  errno = 0;
+  /* Redirect stdin and stdout and stderr to /dev/null */
+  const char *devnull = "/dev/null";
+  int nullfile = open(devnull, O_RDWR);
+  if (nullfile < 0) {
+    ERROR("Error opening file '%s': (%d) %s", devnull, errno, strerror(errno));
+    goto ERR_DEVNULL;
+  }
+
+  /* Redirect stdout and stderr to the logfile */
+  rc = dup2(logfile_fd, STDOUT_FILENO);
+  if (rc != STDOUT_FILENO) {
+    ERROR("Error duping fd 1 got %d file: (%d) %s", rc, errno, strerror(errno));
+    goto ERR_DUP1;
+  }
+  rc = dup2(logfile_fd, STDERR_FILENO);
+  if (rc != STDERR_FILENO) {
+    ERROR("Error duping fd 2 got %d file: (%d) %s", rc, errno, strerror(errno));
+    goto ERR_DUP2;
+  }
+
+  /* Forwarder will capture signals */
+  return 0;
+
+ERR_DUP2:
+ERR_DUP1:
+ERR_DEVNULL:
+ERR_FORK:
+  return -1;
+}
+#endif
+
+static void signal_cb(int sig) {
+  switch (sig) {
+    case SIGTERM:
+    case SIGINT:
+      INFO("caught an interrupt signal, exiting cleanly");
+      break;
+#ifndef _WIN32
+    case SIGUSR1:
+      // dump stats
+      break;
+#endif
+    default:
+      break;
+  }
+
+  if (loop_break(MAIN_LOOP) < 0) {
+    ERROR("Failed to terminate main loop");
+    _exit(1);
+  }
+}
+
+static void signal_setup() {
+#ifndef _WIN32
+  signal(SIGUSR1, signal_cb);
+
+  /* ignore child */
+  signal(SIGCHLD, SIG_IGN);
+
+  /* ignore tty signals */
+  signal(SIGTSTP, SIG_IGN);
+  signal(SIGTTOU, SIG_IGN);
+  signal(SIGTTIN, SIG_IGN);
+#endif
+  signal(SIGINT, signal_cb);
+  signal(SIGTERM, signal_cb);
+}
+
+configuration_t *parse_commandline(int argc, const char *argv[]) {
+  if (argc == 2 && strcasecmp(argv[1], "-h") == 0) {
+    usage(argv[0]);
+    exit(EXIT_SUCCESS);  // XXX redundant
+  }
+
+  configuration_t *configuration = configuration_create();
+
+  // XXX use getoptlong ????
+  for (int i = 0; i < argc; i++) {
+    if (argv[i][0] == '-') {
+      if (strcmp(argv[i], "--config") == 0) {
+        const char *fn_config = argv[i + 1];
+        configuration_set_fn_config(configuration, fn_config);
+        i++;
+      } else if (strcmp(argv[i], "--port") == 0) {
+        uint16_t port = atoi(argv[i + 1]);
+        configuration_set_port(configuration, port);
+        i++;
+#ifndef _WIN32
+      } else if (strcmp(argv[i], "--daemon") == 0) {
+        configuration_set_daemon(configuration, true);
+#endif
+      } else if (strcmp(argv[i], "--capacity") == 0 ||
+                 strcmp(argv[i], "-c") == 0) {
+        int capacity = atoi(argv[i + 1]);
+        configuration_set_cs_size(configuration, capacity);
+        i++;
+      } else if (strcmp(argv[i], "--log") == 0) {
+        int loglevel = loglevel_from_str(argv[i + 1]);
+        configuration_set_loglevel(configuration, loglevel);
+        i++;
+      } else if (strcmp(argv[i], "--log-file") == 0) {
+        if (configuration_get_logfile(configuration)) {
+          fprintf(stderr, "Cannot specify --log-file more than once\n");
+          usage(argv[0]);
+          exit(EXIT_FAILURE);
+        }
+
+        const char *logfile = argv[i + 1];
+        configuration_set_logfile(configuration, logfile);
+        i++;
+      } else {
+        usage(argv[0]);
+        exit(EXIT_FAILURE);
+      }
+    }
+  }
+
+  return configuration;
+}
+
+int main(int argc, const char *argv[]) {
+  signal_setup();
+  logo();
+
+  configuration_t *configuration = parse_commandline(argc, argv);
+  const char *logfile = configuration_get_logfile(configuration);
+  bool daemon = configuration_get_daemon(configuration);
+
+  // set restrictive umask, in case we create any files
+  umask(027);
+
+#ifndef _WIN32
+  if (daemon && (logfile == NULL)) {
+    fprintf(stderr, "Must specify a logfile when running in daemon mode\n");
+    usage(argv[0]);
+    exit(EXIT_FAILURE);
+  }
+
+  /* In daemon mode, parent will exit and child will continue */
+  if (daemon && daemonize(configuration_get_logfile_fd(configuration)) < 0) {
+    ERROR("Could not daemonize process");
+    exit(EXIT_FAILURE);
+  }
+#endif
+
+  /*
+   * The loop should be created before the forwarder instance as it is needed
+   * for timers
+   */
+  MAIN_LOOP = loop_create();
+
+  forwarder_t *forwarder = forwarder_create(configuration);
+  if (!forwarder) {
+    ERROR(
+        "Forwarder initialization failed. Are you running it with sudo "
+        "privileges?");
+    return -1;
+  }
+
+  forwarder_setup_local_listeners(forwarder,
+                                  configuration_get_port(configuration));
+
+  /* If specified, process the configuration file */
+  const char *fn_config = configuration_get_fn_config(configuration);
+  if (fn_config) configuration_file_process(forwarder, fn_config);
+  INFO("%s running port %d configuration-port %d", argv[0],
+       configuration_get_port(configuration),
+       configuration_get_configuration_port(configuration));
+
+  /* Main loop */
+  if (loop_dispatch(MAIN_LOOP) < 0) {
+    ERROR("Failed to run main loop");
+    return EXIT_FAILURE;
+  }
+
+  INFO("loop stopped");
+  forwarder_free(forwarder);
+  loop_free(MAIN_LOOP);
+  MAIN_LOOP = NULL;
+
+#ifdef _WIN32
+  WSACleanup();  // XXX why is this needed here ?
+#endif
+
+  configuration_flush_log();
+  return 0;
+}
diff --git a/hicn-light/src/hicn/cli/hicns.c b/hicn-light/src/hicn/cli/hicns.c
new file mode 100644
index 000000000..2f7a360f8
--- /dev/null
+++ b/hicn-light/src/hicn/cli/hicns.c
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <limits.h>  // LONG_MAX, LONG_MIN
+#include <hicn/ctrl.h>
+
+#ifndef _WIN32
+#include <getopt.h>
+#endif
+
+#include "logo.h"
+#include "../config/parse.h"
+#include <hicn/util/sstrncpy.h>
+
+#define PORT 9695
+
+static struct option longFormOptions[] = {{"help", no_argument, 0, 'h'},
+                                          {"server", required_argument, 0, 'S'},
+                                          {"port", required_argument, 0, 'P'},
+                                          {0, 0, 0, 0}};
+
+static void usage(char *prog) {
+  printf("%s: interactive shell for hicn-light\n", prog);
+  printf("\n");
+  printf("Usage: %s", prog);
+  printf("\n");
+  printf("       %s -h        This help screen.\n", prog);
+  printf("\n");
+}
+
+void prompt(void) {
+  fputs("hicn> ", stdout);
+  fflush(stdout);
+}
+
+int shell(hc_sock_t *s) {
+  char *line = NULL;
+  size_t len = 0;
+  hc_data_t *data = NULL;
+  ssize_t nread;
+
+  hc_data_t *connections;
+
+  prompt();
+  while ((nread = getline(&line, &len, stdin)) != -1) {
+    hc_command_t command = {0};
+
+    char *pos;
+    if ((pos = strchr(line, '\n')) != NULL) {
+      *pos = '\0';
+    } else {
+      fprintf(stderr, "Error while reading command.\n");
+      goto CONTINUE;
+    }
+
+    if (strlen(line) == 0) goto CONTINUE;
+
+    if (strncmp(line, "exit", 4) == 0) break;
+    if (strncmp(line, "quit", 4) == 0) break;
+
+    if (parse(line, &command) < 0) {
+      fprintf(stderr, "Unknown command '%s'\n", line);
+      goto CONTINUE;
+    }
+
+    /* XXX connection list */
+    if (hc_connection_list(s, &connections) < 0) {
+      fprintf(stderr, "Error running command.\n");
+      goto CONTINUE;
+    }
+    // data = command.object.data;
+
+    char buf[MAXSZ_HC_CONNECTION];  // XXX
+    foreach_connection(c, data) {
+      /* XXX connection print */
+      int rc = hc_connection_snprintf(buf, MAXSZ_HC_CONNECTION, c);
+      if (rc < 0) {
+        strcpy_s(buf, sizeof(buf), "(Error)");
+      } else if (rc >= MAXSZ_HC_CONNECTION) {
+        buf[MAXSZ_HC_CONNECTION - 1] = '\0';
+        buf[MAXSZ_HC_CONNECTION - 2] = '.';
+        buf[MAXSZ_HC_CONNECTION - 3] = '.';
+        buf[MAXSZ_HC_CONNECTION - 4] = '.';
+      }
+      printf("%s\n", buf);
+    }
+
+    hc_data_free(data);
+  CONTINUE:
+    prompt();
+  }
+
+  return 0;
+}
+
+int main(int argc, char *const *argv) {
+  logo();
+  printf("Type 'help' for a list of available commands\n");
+  printf("\n");
+  printf("\n");
+
+  /* Parse commandline */
+  char *server_ip = NULL;
+  uint16_t server_port = 0;
+
+  for (;;) {
+    // getopt_long stores the option index here.
+    int optind = 0;
+
+    int c = getopt_long(argc, argv, "hS:P:", longFormOptions, &optind);
+    if (c == -1) break;
+
+    switch (c) {
+      case 'S':
+        server_ip = optarg;
+        break;
+
+      case 'P': {
+        char *endptr;
+        long val = strtol(optarg, &endptr, 10);
+
+        errno = 0; /* To distinguish success/failure after call */
+
+        if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN)) ||
+            (errno != 0 && val == 0)) {
+          perror("strtol");
+          exit(EXIT_FAILURE);
+        }
+
+        if (endptr == optarg) {
+          fprintf(stderr, "No digits were found.\n");
+          exit(EXIT_FAILURE);
+        }
+
+        if (*endptr != '\0') {
+          fprintf(stderr, "Spurious characters after number: %s.\n", endptr);
+          exit(EXIT_FAILURE);
+        }
+
+        if ((val < 1) || (val > 65535)) {
+          fprintf(stderr, "Invalid port number: %ld.\n", val);
+          exit(EXIT_FAILURE);
+        }
+
+        server_port = (uint16_t)val;
+        break;
+      }
+
+      case 'h':
+        usage(argv[0]);
+        exit(EXIT_SUCCESS);
+
+      default:
+        fprintf(stderr, "Invalid argument.\n");
+        usage(argv[0]);
+        exit(EXIT_FAILURE);
+    }
+  }
+
+  if (optind != argc) {
+    fprintf(stderr, "Invalid parameters.\n");
+    usage(argv[0]);
+    exit(EXIT_FAILURE);
+  }
+
+  hc_sock_t *s;
+  if (server_ip) {
+    if (server_port == 0) server_port = PORT;
+#define BUFSIZE 255
+    char url[BUFSIZE];
+    snprintf(url, BUFSIZE, "tcp://%s:%d/", server_ip, server_port);
+    s = hc_sock_create_forwarder_url(HICNLIGHT_NG, url);
+  } else {
+    s = hc_sock_create_forwarder(HICNLIGHT_NG);
+  }
+  if (!s) {
+    fprintf(stderr, "Could not create socket.\n");
+    goto ERR_SOCK;
+  }
+
+  if (hc_sock_connect(s) < 0) {
+    fprintf(stderr, "Could not establish connection to forwarder.\n");
+    goto ERR_CONNECT;
+  }
+
+  int rc = shell(s);
+
+  exit((rc < 0) ? EXIT_FAILURE : EXIT_SUCCESS);
+
+ERR_CONNECT:
+  hc_sock_free(s);
+ERR_SOCK:
+  exit(EXIT_FAILURE);
+}
diff --git a/hicn-light/src/hicn/cli/logo.h b/hicn-light/src/hicn/cli/logo.h
new file mode 100644
index 000000000..a69097f91
--- /dev/null
+++ b/hicn-light/src/hicn/cli/logo.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HICNLIGHT_LOGO
+#define HICNLIGHT_LOGO
+
+#include "color.h"
+
+static void logo(void) {
+  printfc(COLOR_RED, "   ____ ___      _       ");
+  printfc(COLOR_WHITE, "  __    _               __ _        __   __\n");
+  printfc(COLOR_RED, "  / __// _ \\    (_)___  ");
+  printfc(COLOR_WHITE, "  / /   (_)____ ___ ____/ /(_)___ _ / /  / /_\n");
+  printfc(COLOR_RED, " / _/ / // /_  / // _ \\ ");
+  printfc(COLOR_WHITE, " / _ \\ / // __// _ \\___/ // // _ `// _ \\/ __/\n");
+  printfc(COLOR_RED, "/_/  /____/(_)/_/ \\___/ ");
+  printfc(COLOR_WHITE, "/_//_//_/ \\__//_//_/  /_//_/ \\_, //_//_/\\__/\n");
+  printfc(
+      COLOR_WHITE,
+      "                                                    /___/            "
+      "\n");
+  printf("\n");
+}
+
+#endif /* HICNLIGHT_LOGO */
diff --git a/hicn-light/src/hicn/command_line/CMakeLists.txt b/hicn-light/src/hicn/command_line/CMakeLists.txt
deleted file mode 100644
index 16c23dc5c..000000000
--- a/hicn-light/src/hicn/command_line/CMakeLists.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-add_subdirectory(controller)
-add_subdirectory(daemon)
diff --git a/hicn-light/src/hicn/command_line/controller/CMakeLists.txt b/hicn-light/src/hicn/command_line/controller/CMakeLists.txt
deleted file mode 100644
index 4cbd49220..000000000
--- a/hicn-light/src/hicn/command_line/controller/CMakeLists.txt
+++ /dev/null
@@ -1,35 +0,0 @@
-# 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 CONTROLLER_SRC
-  hicnLightControl_main.c
-)
-
-if (WIN32)
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /NODEFAULTLIB:\"LIBCMT\"" )
-endif()
-
-if (NOT DISABLE_EXECUTABLES)
-  if (${CMAKE_SYSTEM_NAME} MATCHES Android)
-    set(LINK_FLAGS "-Wl,--unresolved-symbols=ignore-in-object-files")
-  endif()
-
-  build_executable(${HICN_LIGHT_CONTROL}
-    SOURCES ${CONTROLLER_SRC}
-    LINK_LIBRARIES ${LIBHICN_LIGHT_STATIC}
-    DEPENDS ${LIBHICN_LIGHT_STATIC}
-    COMPONENT ${HICN_LIGHT}
-    DEFINITIONS ${COMPILER_DEFINITIONS}
-    LINK_FLAGS ${LINK_FLAGS}
-  )
-endif ()
diff --git a/hicn-light/src/hicn/command_line/controller/hicnLightControl_main.c b/hicn-light/src/hicn/command_line/controller/hicnLightControl_main.c
deleted file mode 100644
index e6a97c4e2..000000000
--- a/hicn-light/src/hicn/command_line/controller/hicnLightControl_main.c
+++ /dev/null
@@ -1,382 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <hicn/utils/utils.h>
-
-
-#ifndef _WIN32
-#include <arpa/inet.h>
-#include <getopt.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <sys/uio.h>
-#include <unistd.h>
-#include <arpa/inet.h>
-#endif
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-#include <string.h>
-
-#include <parc/security/parc_IdentityFile.h>
-#include <parc/security/parc_Security.h>
-
-#include <parc/algol/parc_ArrayList.h>
-#include <parc/algol/parc_List.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_SafeMemory.h>
-
-#include <hicn/core/dispatcher.h>
-#include <hicn/core/forwarder.h>
-
-#include <errno.h>
-#include <hicn/config/controlRoot.h>
-#include <hicn/config/controlState.h>
-
-#include <hicn/utils/commands.h>
-
-
-
-size_t commandOutputLen = 0;  // preserve the number of structs composing
-                              // payload in case on not interactive call.
-
-// REMINDER: when a new_command is added, the following array has to be updated
-// with the sizeof(new_command). It allows to allocate the buffer for receiving
-// the payload of the DAEMON RESPONSE after the header has beed read. Each
-// command identifier (typedef enum command_id) corresponds to a position in the
-// following array.
-static int payloadLengthController[LAST_COMMAND_VALUE] = {
-    sizeof(add_listener_command),
-    sizeof(add_connection_command),
-    sizeof(list_connections_command),  // needed when get response from FWD
-    sizeof(add_route_command),
-    sizeof(list_routes_command),  // needed when get response from FWD
-    sizeof(remove_connection_command),
-    sizeof(remove_listener_command),
-    sizeof(remove_route_command),
-    sizeof(cache_store_command),
-    sizeof(cache_serve_command),
-    0,  // cache clear
-    sizeof(set_strategy_command),
-    sizeof(set_wldr_command),
-    sizeof(add_punting_command),
-    sizeof(list_listeners_command),  // needed when get response from FWD
-    sizeof(mapme_activator_command),
-    sizeof(mapme_activator_command),
-    sizeof(mapme_timing_command),
-    sizeof(mapme_timing_command),
-    sizeof(mapme_send_update_command),
-    sizeof(connection_set_admin_state_command),
-#ifdef WITH_POLICY
-    sizeof(add_policy_command),
-    sizeof(list_policies_command),
-    sizeof(remove_policy_command),
-    sizeof(update_connection_command),
-    sizeof(connection_set_priority_command),
-    sizeof(connection_set_tags_command),
-#endif
-};
-
-typedef struct controller_main_state {
-  ControlState *controlState;
-} ControlMainState;
-
-static void _printRed(const char *output) {
-#ifndef _WIN32
-  printf("\033[0;31m%s", output);
-#else
-  HANDLE hConsole = NULL;
-  WORD currentConsoleAttr;
-  CONSOLE_SCREEN_BUFFER_INFO csbi;
-  hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
-  if (GetConsoleScreenBufferInfo(hConsole, &csbi))
-    currentConsoleAttr = csbi.wAttributes;
-  SetConsoleTextAttribute(hConsole, 4);
-  printf("%s", output);
-  SetConsoleTextAttribute(hConsole, currentConsoleAttr);
-#endif
-}
-
-static void _printWhite(const char *output) {
-#ifndef _WIN32
-  printf("\033[0m%s", output);
-#else
-  HANDLE hConsole = NULL;
-  WORD currentConsoleAttr;
-  CONSOLE_SCREEN_BUFFER_INFO csbi;
-  hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
-  if (GetConsoleScreenBufferInfo(hConsole, &csbi))
-    currentConsoleAttr = csbi.wAttributes;
-  SetConsoleTextAttribute(hConsole, 7);
-  printf("%s", output);
-  SetConsoleTextAttribute(hConsole, currentConsoleAttr);
-#endif
-}
-
-static void _displayForwarderLogo(void) {
-  _printRed("   ____ ___      _       ");
-  _printWhite("  __    _               __ _        __   __\n");
-  _printRed("  / __// _ \\    (_)___  ");
-  _printWhite("  / /   (_)____ ___ ____/ /(_)___ _ / /  / /_\n");
-  _printRed(" / _/ / // /_  / // _ \\ ");
-  _printWhite(" / _ \\ / // __// _ \\___/ // // _ `// _ \\/ __/\n");
-  _printRed("/_/  /____/(_)/_/ \\___/ ");
-  _printWhite("/_//_//_/ \\__//_//_/  /_//_/ \\_, //_//_/\\__/\n");
-  _printWhite(
-      "                                                    /___/            "
-      "\n");
-  printf("\n");
-}
-
-static void _displayUsage(char *programName) {
-  printf("Usage: %s -h\n", programName);
-  printf(
-      "hicn-light is the 1.0 source, which runs on each end system and as a "
-      "software source\n");
-  printf(
-      "on intermediate systems.  controller is the program to configure the "
-      "source, daemon.\n");
-  printf("\n");
-  printf("Options:\n");
-  printf("-h              = This help screen\n");
-  printf(
-      "commands        = configuration line to send to hicn-light (use 'help' "
-      "for list)\n");
-  printf("\n");
-}
-
-static int _parseArgs(int argc, char *argv[], char **server_ip,
-                      uint16_t *server_port, PARCList *commandList){
-  static struct option longFormOptions[] = {
-      {"help", no_argument, 0, 'h'},
-      {"server", required_argument, 0, 'S'},
-      {"port", required_argument, 0, 'P'},
-      {0, 0, 0, 0}};
-
-  int c;
-
-  while (1) {
-    // getopt_long stores the option index here.
-    int optionIndex = 0;
-
-    c = getopt_long(argc, argv, "hS:P:", longFormOptions, &optionIndex);
-
-    // Detect the end of the options.
-    if (c == -1) {
-      break;
-    }
-
-    switch (c) {
-      case 'S':
-        {
-          *server_ip = optarg;
-          struct sockaddr_in sa;
-          int result = inet_pton(AF_INET, *server_ip, &(sa.sin_addr));
-          //inet_pton() returns 1 on success
-          if(result != 1){
-            return 0;
-          }
-          break;
-        }
-      case 'P':
-        {
-          char * port_str = optarg;
-          if(utils_IsNumber(port_str)){
-            *server_port = (uint16_t) strtol(port_str, NULL, 10);
-          } else {
-            return 0;
-          }
-          break;
-        }
-      case 'h':
-      default:
-        return 0;
-    }
-  }
-
-  if (optind < argc) {
-    while (optind < argc) {
-      parcList_Add(commandList, argv[optind]);
-      optind++;
-    }
-  }
-
-  return 1;
-}
-
-struct iovec *_writeAndReadMessage(ControlState *state, struct iovec *msg) {
-  parcAssertNotNull(msg, "Parameter msg must be non-null");
-  int sockfd = controlState_GetSockfd(state);
-
-  // check if request has a payload
-  if (((header_control_message *)msg[0].iov_base)->length >
-      0) {  // command with payload
-    // write header + payload (compatibility issue: two write needed instead of
-    // the writev)
-#ifndef _WIN32
-    if (write(sockfd, msg[0].iov_base, (unsigned int)msg[0].iov_len) < 0 ||
-        write(sockfd, msg[1].iov_base, (unsigned int)msg[1].iov_len) < 0) {
-#else
-    if (send(sockfd, msg[0].iov_base, (int)msg[0].iov_len, 0) == SOCKET_ERROR ||
-        send(sockfd, msg[1].iov_base, (int)msg[1].iov_len, 0) == SOCKET_ERROR) {
-#endif
-      printf("\nError while sending the Message: cannot write on socket \n");
-      exit(EXIT_FAILURE);
-    }
-    parcMemory_Deallocate(&msg[1].iov_base);
-  } else {  // command without payload, e.g. 'list'
-            // write header only
-#ifndef _WIN32
-    if (write(sockfd, msg[0].iov_base, msg[0].iov_len) < 0) {
-#else
-    int result = send(sockfd, msg[0].iov_base, (int)msg[0].iov_len, 0);
-    if (result == SOCKET_ERROR) {
-#endif
-      printf("\nError while sending the Message: cannot write on socket \n");
-      exit(EXIT_FAILURE);
-    }
-  }
-  parcMemory_Deallocate(&msg[0].iov_base);
-
-  // ======= RECEIVE =======
-
-  header_control_message *headerResponse =
-      (header_control_message *)parcMemory_AllocateAndClear(
-          sizeof(header_control_message));
-  if (recv(sockfd, (char *)headerResponse, sizeof(header_control_message), 0) <
-      0) {
-    printf("\nError in Receiving the Message \n");
-    exit(EXIT_FAILURE);
-  }
-
-  if (headerResponse->messageType < RESPONSE_LIGHT ||
-      headerResponse->messageType >= LAST_MSG_TYPE_VALUE) {
-    char *checkFinMsg = parcMemory_Reallocate(headerResponse, 32);
-#ifndef _WIN32
-    if (recv(sockfd, checkFinMsg, sizeof(checkFinMsg),
-             MSG_PEEK | MSG_DONTWAIT) == 0) {
-#else
-    if (recv(sockfd, checkFinMsg, sizeof(checkFinMsg), MSG_PEEK) == 0) {
-#endif
-      // if recv returns zero, that means the connection has been closed:
-      close(sockfd);
-      printf("\nConnection terminated by the Daemon. Exiting... \n");
-      exit(EXIT_SUCCESS);
-    } else {
-      printf("\nError: Unrecognized message type received \n");
-      exit(EXIT_FAILURE);
-    }
-  }
-
-  void *payloadResponse = NULL;
-
-  if ((commandOutputLen = headerResponse->length) > 0) {
-    payloadResponse = parcMemory_AllocateAndClear(
-        payloadLengthController[headerResponse->commandID] *
-        headerResponse->length);
-
-    if (recv(sockfd, payloadResponse,
-             payloadLengthController[headerResponse->commandID] *
-                 headerResponse->length,
-             0) < 0) {
-      printf("\nError in Receiving the Message \n");
-      exit(EXIT_FAILURE);
-    }
-  }
-
-  struct iovec *response =
-      parcMemory_AllocateAndClear(sizeof(struct iovec) * 2);
-
-  response[0].iov_base = headerResponse;
-  response[0].iov_len = sizeof(header_control_message);
-  response[1].iov_base = payloadResponse;
-  response[1].iov_len = payloadLengthController[headerResponse->commandID] *
-                        headerResponse->length;
-
-  return response;
-}
-
-int main(int argc, char *argv[]) {
-  _displayForwarderLogo();
-
-#ifdef _WIN32
-  WSADATA wsaData;
-  WSAStartup(MAKEWORD(2, 2), &wsaData);
-#endif
-
-  if (argc == 2 && strcmp("-h", argv[1]) == 0) {
-    _displayUsage(argv[0]);
-    exit(EXIT_SUCCESS);
-  }
-
-  PARCList *commands =
-      parcList(parcArrayList_Create(NULL), PARCArrayListAsPARCList);
-
-  char *server_ip = SRV_CTRL_IP;
-  uint16_t server_port = SRV_CTRL_PORT;
-  if (!_parseArgs(argc, argv, &server_ip,
-            &server_port, commands)) {
-    _displayUsage(argv[0]);
-    parcList_Release(&commands);
-    exit(EXIT_FAILURE);
-  }
-
-  ControlMainState mainState;
-  mainState.controlState =
-      controlState_Create(&mainState, _writeAndReadMessage, true,
-                          server_ip, server_port);
-  if (mainState.controlState == NULL) {
-      exit(EXIT_FAILURE);
-  }
-
-  controlState_RegisterCommand(mainState.controlState,
-                               controlRoot_HelpCreate(mainState.controlState));
-  controlState_RegisterCommand(mainState.controlState,
-                               controlRoot_Create(mainState.controlState));
-
-  if (parcList_Size(commands) > 0) {
-    controlState_SetInteractiveFlag(mainState.controlState, false);
-    char output[8192];
-    controlState_DispatchCommand(mainState.controlState, commands, output, sizeof(output));
-    printf("%s", output);
-    char **commandOutputMain =
-        controlState_GetCommandOutput(mainState.controlState);
-    if (commandOutputMain != NULL && commandOutputLen > 0) {
-#if 0
-      for (size_t j = 0; j < commandOutputLen; j++) {
-        printf("Output %zu: %s \n", j, commandOutputMain[j]);
-      }
-#endif
-      controlState_ReleaseCommandOutput(mainState.controlState,
-                                        commandOutputMain, commandOutputLen);
-    }
-    // release
-
-  } else {
-    controlState_Interactive(mainState.controlState);
-  }
-
-  parcList_Release(&commands);
-
-  controlState_Destroy(&mainState.controlState);
-#ifdef _WIN32
-  WSACleanup();
-#endif
-  return EXIT_SUCCESS;
-}
diff --git a/hicn-light/src/hicn/command_line/daemon/hicnLightDaemon_main.c b/hicn-light/src/hicn/command_line/daemon/hicnLightDaemon_main.c
deleted file mode 100644
index ab7039f5e..000000000
--- a/hicn-light/src/hicn/command_line/daemon/hicnLightDaemon_main.c
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
- * 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 _WIN32
-#include <unistd.h>
-#endif
-#include <errno.h>
-#include <fcntl.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-
-#include <hicn/hicn-light/config.h>
-#include <parc/algol/parc_FileOutputStream.h>
-#include <parc/logging/parc_LogLevel.h>
-#include <parc/logging/parc_LogReporterFile.h>
-#include <parc/logging/parc_LogReporterTextStdout.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <hicn/core/dispatcher.h>
-#include <hicn/core/forwarder.h>
-
-static void _printRed(const char *output) {
-#ifndef _WIN32
-  printf("\033[0;31m%s", output);
-#else
-  HANDLE hConsole = NULL;
-  WORD currentConsoleAttr;
-  CONSOLE_SCREEN_BUFFER_INFO csbi;
-  hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
-  if (GetConsoleScreenBufferInfo(hConsole, &csbi))
-    currentConsoleAttr = csbi.wAttributes;
-  SetConsoleTextAttribute(hConsole, 4);
-  printf("%s", output);
-  SetConsoleTextAttribute(hConsole, currentConsoleAttr);
-#endif
-}
-
-static void _printWhite(const char *output) {
-#ifndef _WIN32
-  printf("\033[0m%s", output);
-#else
-  HANDLE hConsole = NULL;
-  WORD currentConsoleAttr;
-  CONSOLE_SCREEN_BUFFER_INFO csbi;
-  hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
-  if (GetConsoleScreenBufferInfo(hConsole, &csbi))
-    currentConsoleAttr = csbi.wAttributes;
-  SetConsoleTextAttribute(hConsole, 7);
-  printf("%s", output);
-  SetConsoleTextAttribute(hConsole, currentConsoleAttr);
-#endif
-}
-
-static void _displayForwarderLogo(void) {
-  _printRed("   ____ ___      _       ");
-  _printWhite("  __    _               __ _        __   __\n");
-  _printRed("  / __// _ \\    (_)___  ");
-  _printWhite("  / /   (_)____ ___ ____/ /(_)___ _ / /  / /_\n");
-  _printRed(" / _/ / // /_  / // _ \\ ");
-  _printWhite(" / _ \\ / // __// _ \\___/ // // _ `// _ \\/ __/\n");
-  _printRed("/_/  /____/(_)/_/ \\___/ ");
-  _printWhite("/_//_//_/ \\__//_//_/  /_//_/ \\_, //_//_/\\__/\n");
-  _printWhite(
-      "                                                    /___/            "
-      "\n");
-  printf("\n");
-}
-
-static void _usage(int exitCode) {
-#ifndef _WIN32
-  printf(
-      "Usage: hicn-light-daemon [--port port] [--capacity objectStoreSize] "
-      "[--log facility=level] [--log-file filename] [--config file]\n");
-#else
-  printf(
-      "Usage: hicn-light-daemon.exe [--port port] [--daemon] [--capacity objectStoreSize] "
-      "[--log facility=level] [--log-file filename] [--config file]\n");
-#endif
-  printf("\n");
-  printf(
-      "hicn-light run as a daemon is the program to launch the forwarder, "
-      "either as a console program\n");
-  printf(
-      "or a background daemon (detatched from console).  Once running, use the "
-      "program controller to\n");
-  printf("configure hicn-light.\n");
-  printf("\n");
-  printf(
-      "The configuration file contains configuration lines as per "
-      "controller\n");
-  printf(
-      "If logging level or content store capacity is set in the configuraiton "
-      "file, it overrides the command_line\n");
-  printf(
-      "When a configuration file is specified, no default listeners on 'port' "
-      "are setup.  Only 'add listener' lines\n");
-  printf("in the configuration file matter.\n");
-  printf("\n");
-  printf(
-      "If no configuration file is specified, daemon will listen on TCP and "
-      "UDP ports specified by\n");
-  printf(
-      "the --port flag (or default port).  It will listen on both IPv4 and "
-      "IPv6 if available.\n");
-  printf("\n");
-  printf("Options:\n");
-  printf("--port            = tcp port for in-bound connections\n");
-#ifndef _WIN32
-  printf("--daemon          = start as daemon process\n");
-#endif
-  printf("--objectStoreSize = maximum number of content objects to cache\n");
-  printf(
-      "--log             = sets a facility to a given log level.  You can have "
-      "multiple of these.\n");
-  printf(
-      "                    facilities: all, config, core, io, message, "
-      "processor\n");
-  printf(
-      "                    levels: debug, info, notice, warning, error, "
-      "critical, alert, off\n");
-  printf("                    example: daemon --log io=debug --log core=off\n");
-  printf(
-      "--log-file        = file to write log messages to (required in daemon "
-      "mode)\n");
-  printf("--config           = configuration filename\n");
-  printf("\n");
-  exit(exitCode);
-}
-
-static void _setLogLevelToLevel(int logLevelArray[LoggerFacility_END],
-                                LoggerFacility facility,
-                                const char *levelString) {
-  PARCLogLevel level = parcLogLevel_FromString(levelString);
-
-  if (level < PARCLogLevel_All) {
-    // we have a good facility and level
-    logLevelArray[facility] = level;
-  } else {
-    printf("Invalid log level string %s\n", levelString);
-    _usage(EXIT_FAILURE);
-  }
-}
-
-/**
- * string: "facility=level"
- * Set the right thing in the logger
- */
-static void _setLogLevel(int logLevelArray[LoggerFacility_END],
-                         const char *string) {
-  char *tofree = parcMemory_StringDuplicate(string, strlen(string));
-  char *p = tofree;
-
-  char *facilityString = strtok(p, "=");
-  if (facilityString) {
-    char *levelString = strtok(NULL, "=");
-
-    if (strcasecmp(facilityString, "all") == 0) {
-      for (LoggerFacility facility = 0; facility < LoggerFacility_END;
-           facility++) {
-        _setLogLevelToLevel(logLevelArray, facility, levelString);
-      }
-    } else {
-      LoggerFacility facility;
-      for (facility = 0; facility < LoggerFacility_END; facility++) {
-        if (strcasecmp(facilityString, logger_FacilityString(facility)) == 0) {
-          break;
-        }
-      }
-
-      if (facility < LoggerFacility_END) {
-        _setLogLevelToLevel(logLevelArray, facility, levelString);
-      } else {
-        printf("Invalid facility string %s\n", facilityString);
-        _usage(EXIT_FAILURE);
-      }
-    }
-  }
-
-  parcMemory_Deallocate((void **)&tofree);
-}
-
-#ifndef _WIN32
-static void _daemonize(void) {
-  if (getppid() == 1) {
-    // already a daemon
-    return;
-  }
-
-  int forkReturn = fork();
-  parcTrapUnexpectedStateIf(forkReturn < 0, "Fork error")
-
-  if (forkReturn > 0) {
-    // parent exits
-    exit(EXIT_SUCCESS);
-  }
-
-  // Child daemon detaches
-  printf("child continuing, pid = %u\n", getpid());
-
-  // get a new process group independent from old parent
-  setsid();
-
-  /* close all descriptors */
-#ifdef __ANDROID__
-  for (int i = sysconf(_SC_OPEN_MAX); i >= 0; --i) {
-    close(i);
-  }
-#else
-  for (int i = getdtablesize(); i >= 0; --i) {
-    close(i);
-  }
-#endif
-  // reset errno because it might be seg to EBADF from the close calls above
-  errno = 0;
-
-  // Redirect stdin and stdout and stderr to /dev/null
-  const char *devnull = "/dev/null";
-  int nullfile = open(devnull, O_RDWR);
-  parcAssertTrue(nullfile >= 0, "Error opening file '%s': (%d) %s", devnull,
-                 errno, strerror(errno));
-
-  int ret;
-  ret = dup(nullfile);
-  parcAssertTrue(ret == 1, "Error duping fd 1 got %d file: (%d) %s", ret, errno,
-                 strerror(errno));
-  ret = dup(nullfile);
-  parcAssertTrue(ret == 2, "Error duping fd 2, got %d file: (%d) %s", ret,
-                 errno, strerror(errno));
-
-  // forwarder will capture signals
-}
-#endif
-
-static Logger *_createLogfile(const char *logfile) {
-#ifndef _WIN32
-  int logfd = open(logfile, O_WRONLY | O_APPEND | O_CREAT, S_IWUSR | S_IRUSR);
-#else
-  int logfd =
-      _open(logfile, _O_WRONLY | _O_APPEND | _O_CREAT, _S_IWRITE | _S_IREAD);
-#endif
-  if (logfd < 0) {
-    fprintf(stderr, "Error opening %s for writing: (%d) %s\n", logfile, errno,
-            strerror(errno));
-    exit(EXIT_FAILURE);
-  }
-
-#ifndef _WIN32
-  chmod(logfile, S_IRWXU);
-#endif
-
-  PARCFileOutputStream *fos = parcFileOutputStream_Create(logfd);
-  PARCOutputStream *pos = parcFileOutputStream_AsOutputStream(fos);
-  PARCLogReporter *reporter = parcLogReporterFile_Create(pos);
-
-  Logger *logger = logger_Create(reporter, parcClock_Wallclock());
-
-  parcOutputStream_Release(&pos);
-  parcLogReporter_Release(&reporter);
-
-  return logger;
-}
-
-int main(int argc, const char *argv[]) {
-  _displayForwarderLogo();
-#ifndef _WIN32
-  bool daemon = false;
-#else
-  WSADATA wsaData = {0};
-  WSAStartup(MAKEWORD(2, 2), &wsaData);
-#endif
-
-  uint16_t port = PORT_NUMBER;
-  uint16_t configurationPort = 2001;
-  int capacity = -1;
-  const char *configFileName = NULL;
-
-  char *logfile = NULL;
-
-  if (argc == 2 && strcasecmp(argv[1], "-h") == 0) {
-    _usage(EXIT_SUCCESS);
-  }
-
-  int logLevelArray[LoggerFacility_END];
-  for (int i = 0; i < LoggerFacility_END; i++) {
-    logLevelArray[i] = -1;
-  }
-
-  for (int i = 0; i < argc; i++) {
-    if (argv[i][0] == '-') {
-      if (strcmp(argv[i], "--config") == 0) {
-        configFileName = argv[i + 1];
-        i++;
-      } else if (strcmp(argv[i], "--port") == 0) {
-        port = atoi(argv[i + 1]);
-        i++;
-#ifndef _WIN32
-      } else if (strcmp(argv[i], "--daemon") == 0) {
-        daemon = true;
-#endif
-      } else if (strcmp(argv[i], "--capacity") == 0 ||
-                 strcmp(argv[i], "-c") == 0) {
-        capacity = atoi(argv[i + 1]);
-        i++;
-      } else if (strcmp(argv[i], "--log") == 0) {
-        _setLogLevel(logLevelArray, argv[i + 1]);
-        i++;
-      } else if (strcmp(argv[i], "--log-file") == 0) {
-        if (logfile) {
-          // error cannot repeat
-          fprintf(stderr, "Cannot specify --log-file more than once\n");
-          _usage(EXIT_FAILURE);
-        }
-
-        logfile = parcMemory_StringDuplicate(argv[i + 1], strlen(argv[i + 1]));
-        i++;
-      } else {
-        _usage(EXIT_FAILURE);
-      }
-    }
-  }
-
-  // set restrictive umask, in case we create any files
-  umask(027);
-
-#ifndef _WIN32
-  if (daemon && (logfile == NULL)) {
-    fprintf(stderr, "Must specify a logfile when running in daemon mode\n");
-    _usage(EXIT_FAILURE);
-  }
-
-  if (daemon) {
-    // inside this call, parent will EXIT_SUCCESS and child will continue
-    _daemonize();
-  }
-#endif
-
-  Logger *logger = NULL;
-  if (logfile) {
-    logger = _createLogfile(logfile);
-    parcMemory_Deallocate((void **)&logfile);
-  } else {
-    PARCLogReporter *stdoutReporter = parcLogReporterTextStdout_Create();
-    logger = logger_Create(stdoutReporter, parcClock_Wallclock());
-    parcLogReporter_Release(&stdoutReporter);
-  }
-
-  for (int i = 0; i < LoggerFacility_END; i++) {
-    if (logLevelArray[i] > -1) {
-      logger_SetLogLevel(logger, i, logLevelArray[i]);
-    }
-  }
-
-  // this will update the clock to the tick clock
-  Forwarder *forwarder = forwarder_Create(logger);
-
-  if (forwarder == NULL) {
-    logger_Log(logger, LoggerFacility_Core, PARCLogLevel_Error, "daemon",
-               "Forwarder initialization failed. Are you running it with sudo "
-               "privileges?");
-    logger_Release(&logger);
-    return -1;
-  }
-
-  Configuration *configuration = forwarder_GetConfiguration(forwarder);
-
-  if (capacity > -1) {
-    configuration_SetObjectStoreSize(configuration, capacity);
-  }
-
-  forwarder_SetupLocalListeners(forwarder, port);
-  if (configFileName) {
-    forwarder_SetupFromConfigFile(forwarder, configFileName);
-  }
-
-  Dispatcher *dispatcher = forwarder_GetDispatcher(forwarder);
-
-  logger_Log(logger, LoggerFacility_Core, PARCLogLevel_Alert, "daemon",
-             "hicn-light running port %d configuration-port %d", port,
-             configurationPort);
-
-  dispatcher_Run(dispatcher);
-
-  logger_Log(logger, LoggerFacility_Core, PARCLogLevel_Alert, "daemon",
-             "hicn-light exiting port %d", port);
-
-  forwarder_Destroy(&forwarder);
-
-#ifndef _WIN32
-  //sleep(2);
-#else
-  //Sleep(2000);
-  WSACleanup();
-#endif
-
-  logger_Release(&logger);
-  return 0;
-}
diff --git a/hicn-light/src/hicn/config.h.in b/hicn-light/src/hicn/config.h.in
index 90ab8e83f..6c2915b7e 100644
--- a/hicn-light/src/hicn/config.h.in
+++ b/hicn-light/src/hicn/config.h.in
@@ -2,7 +2,8 @@
 #define LEVEL1_DCACHE_LINESIZE @LEVEL1_DCACHE_LINESIZE@
 
 #ifndef _WIN32
-#define _GNU_SOURCE
+// This is now in CMakeLists.txt
+//#define _GNU_SOURCE
 #else
 #include <hicn/platforms/windows/win_portability.h>
 #endif
diff --git a/hicn-light/src/hicn/config/CMakeLists.txt b/hicn-light/src/hicn/config/CMakeLists.txt
index 104026355..00ee24077 100644
--- a/hicn-light/src/hicn/config/CMakeLists.txt
+++ b/hicn-light/src/hicn/config/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -12,95 +12,28 @@
 # limitations under the License.
 
 list(APPEND HEADER_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/commandOps.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/commandParser.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/configuration.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/commandReturn.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/symbolicNameTable.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlState.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRoot.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlAddConnection.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlAdd.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/configurationFile.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/configurationListeners.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlAddRoute.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlAddPolicy.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlAddListener.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlListConnections.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlList.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlListListeners.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlListRoutes.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlListPolicies.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlQuit.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRemove.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRemoveListener.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRemoveConnection.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRemoveRoute.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRemovePolicy.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlSet.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlUnset.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlSetDebug.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlUnsetDebug.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlMapMe.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlMapMeEnable.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlMapMeDiscovery.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlMapMeTimescale.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlCacheServe.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlCacheStore.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlCacheClear.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlCache.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlSetStrategy.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlSetWldr.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlAddPunting.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRemovePunting.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlUpdate.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlUpdateConnection.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/configuration.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/command.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/commands.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/parse.h
 )
 
 list(APPEND SOURCE_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/commandOps.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/commandParser.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/configuration.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/configurationFile.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/configurationListeners.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlState.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/symbolicNameTable.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlAdd.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlAddConnection.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlAddRoute.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlAddPolicy.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlAddListener.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlList.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlListConnections.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlListListeners.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlListRoutes.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlListPolicies.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlQuit.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRemove.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRemoveListener.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRemoveConnection.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRemoveRoute.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRemovePolicy.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRoot.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlSet.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlSetDebug.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlUnset.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlUnsetDebug.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlMapMe.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlMapMeEnable.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlMapMeDiscovery.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlMapMeTimescale.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlMapMeRetx.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlCacheServe.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlCacheStore.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlCacheClear.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlCache.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlSetStrategy.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlSetWldr.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlAddPunting.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlRemovePunting.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlUpdate.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/controlUpdateConnection.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/configuration.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/configuration_file.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/command_cache.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/command_connection.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/command_face.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/command_listener.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/command_mapme.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/command_policy.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/command_punting.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/command_route.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/command_strategy.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/command_subscription.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/command.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/commands.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/parse.c
 )
 
 set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
diff --git a/hicn-light/src/hicn/config/command.c b/hicn-light/src/hicn/config/command.c
new file mode 100644
index 000000000..bee0d2663
--- /dev/null
+++ b/hicn-light/src/hicn/config/command.c
@@ -0,0 +1,119 @@
+
+/**
+ * @file command.c
+ * @brief Implementation of commands.
+ */
+
+#include <search.h> /* tfind, tdestroy, twalk */
+#include <stdio.h>
+#include <ctype.h>
+#include "command.h"
+#include "parse.h"
+
+/* Commands are registered in the following tree. */
+static void *commands_root = NULL; /**< Tree ordered by name */
+
+#ifdef __linux__
+static void nothing_to_free() {}
+
+__attribute__((destructor)) static void command_clear() {
+  tdestroy(commands_root, nothing_to_free);
+}
+#endif /* __linux__ */
+
+static int _command_compare(const command_parser_t *c1,
+                            const command_parser_t *c2) {
+  if (c1->object != c2->object) return c2->object - c1->object;
+  if (c1->action != c2->action) return c2->action - c1->action;
+  if (c1->nparams != c2->nparams) return c2->nparams - c1->nparams;
+  return 0;
+}
+
+#define command_compare (int (*)(const void *, const void *))(_command_compare)
+
+void command_register(const command_parser_t *command) {
+  // Insert the command in the tree if the keys does not exist yet
+  tsearch(command, &commands_root, command_compare);
+}
+
+const command_parser_t *command_search(const hc_action_t action,
+                                       hc_object_type_t object,
+                                       unsigned nparams) {
+  command_parser_t **command, search;
+
+  search.action = action;
+  search.object = object;
+  search.nparams = nparams;
+  command = tfind(&search, &commands_root, command_compare);
+
+  return command ? *command : NULL;
+}
+
+static inline void to_lowercase(char *p) {
+  for (; *p; ++p) *p = tolower(*p);
+}
+
+typedef struct {
+  hc_object_type_t object;
+  hc_action_t action;
+} cmd_search_params_t;
+
+static hc_object_type_t prev_obj = OBJECT_UNDEFINED;
+static hc_action_t prev_action = ACTION_UNDEFINED;
+static void traversal_action(const void *nodep, VISIT which,
+                             void *cmd_params0) {
+  cmd_search_params_t *cmd_params = cmd_params0;
+
+  // Execute this function during inorder traversal
+  if (which != postorder && which != leaf) return;
+
+  command_parser_t *datap;
+  datap = *(command_parser_t **)nodep;
+  char *obj_str = strdup(object_str(datap->object));
+  to_lowercase(obj_str);
+
+  // List all objects
+  if (cmd_params->object == OBJECT_UNDEFINED &&
+      cmd_params->action == ACTION_UNDEFINED) {
+    if (datap->object == prev_obj) goto FREE_STR;
+    prev_obj = datap->object;
+
+    printf("\thelp %s\n", obj_str);
+    goto FREE_STR;
+  }
+
+  // List actions for specific object
+  if (datap->object != cmd_params->object) goto FREE_STR;
+  if (cmd_params->action == ACTION_UNDEFINED) {
+    if (datap->action == prev_action) goto FREE_STR;
+    prev_action = datap->action;
+
+    printf("\thelp %s %s\n", obj_str, action_to_cmd_action(datap->action));
+    goto FREE_STR;
+  }
+
+  // List commands for specific object and action
+  if (datap->action != cmd_params->action) goto FREE_STR;
+  printf("   %s %s ", action_to_cmd_action(datap->action), obj_str);
+  for (int i = 0; i < datap->nparams; i++)
+    printf("<%s> ", datap->parameters[i].name);
+  printf("\n\n");
+  // List options' details
+  if (datap->nparams == 0) goto FREE_STR;
+  for (int i = 0; i < datap->nparams; i++)
+    printf("%16s: %s\n", datap->parameters[i].name, datap->parameters[i].help);
+  printf("\n");
+
+FREE_STR:
+  free(obj_str);
+}
+
+void command_list(hc_object_type_t object, hc_action_t action) {
+#if defined(__linux__) && !defined(__ANDROID__)
+  cmd_search_params_t cmd_params = {.object = object, .action = action};
+  twalk_r(commands_root, traversal_action, &cmd_params);
+#else
+  fprintf(stderr, "twalk_r() function only available on linux");
+  (void)traversal_action;
+#endif
+}
diff --git a/hicn-light/src/hicn/config/command.h b/hicn-light/src/hicn/config/command.h
new file mode 100644
index 000000000..73d8edb1f
--- /dev/null
+++ b/hicn-light/src/hicn/config/command.h
@@ -0,0 +1,179 @@
+#ifndef HICNLIGHT_CONFIG_COMMAND
+#define HICNLIGHT_CONFIG_COMMAND
+
+/**
+ * @file command.h
+ * @brief Commands.
+ */
+
+#include <stddef.h>  // offsetof
+#include <hicn/util/ip_address.h>
+
+#include <hicn/ctrl/api.h>
+
+/* Update sscanf accordingly in parse_cmd.c */
+#define MAX_PARAMETERS 10
+#define MAX_SCANF_PARAM_LEN 100
+
+typedef int (*parser_hook_t)(void *arg);
+
+typedef enum {
+  TYPENAME_UNDEFINED,
+  TYPENAME_INT,
+  TYPENAME_UINT,
+  TYPENAME_STR,
+  TYPENAME_SYMBOLIC_OR_ID,
+  TYPENAME_INTERFACE_NAME,
+  TYPENAME_IP_ADDRESS,
+  TYPENAME_IP_PREFIX,
+  TYPENAME_ON_OFF,
+  TYPENAME_ENUM,
+  TYPENAME_POLICY_STATE,
+} parser_typename_t;
+
+typedef struct {
+  parser_typename_t name;
+  union {
+    struct {
+      size_t max_size;
+    } str;
+    struct {
+      int min;
+      int max;
+    } sint;
+    struct {
+      int min;
+      int max;
+    } uint;
+    struct {
+      int (*from_str)(const char *str);
+    } enum_;
+    struct {
+      policy_tag_t tag;
+    } policy_state;
+  };
+} parser_type_t;
+
+typedef struct {
+  const char *name;
+  const char *help;
+  parser_type_t type;
+  size_t offset;
+  /*
+   * quick hack to let the functions update two or more parameters, like for
+   * IP_ADDRESS or IP_PREFIX types
+   */
+  size_t offset2;
+  size_t offset3;
+} command_parameter_t;
+
+typedef struct {
+  hc_action_t action;
+  hc_object_type_t object;
+  unsigned nparams;
+  command_parameter_t parameters[MAX_PARAMETERS];
+  parser_hook_t post_hook;
+} command_parser_t;
+
+#define TYPE_STRN(N)      \
+  (parser_type_t) {       \
+    .name = TYPENAME_STR, \
+    .str = {              \
+        .max_size = N,    \
+    },                    \
+  }
+#define TYPE_FMT_STRN(N) "%s"
+
+#define TYPE_INT(MIN, MAX) \
+  (parser_type_t) {        \
+    .name = TYPENAME_INT,  \
+    .sint = {              \
+        .min = (MIN),      \
+        .max = (MAX),      \
+    },                     \
+  }
+#define TYPE_FMT_INT "%d"
+
+#define TYPE_UINT(min, max) \
+  (parser_type_t) {         \
+    .name = TYPENAME_UINT,  \
+    .uint = {               \
+        .min = min,         \
+        .max = max,         \
+    },                      \
+  }
+#define TYPE_FMT_UINT "%u"
+
+#define TYPE_SYMBOLIC_OR_ID TYPE_STRN(SYMBOLIC_NAME_LEN)
+#define TYPE_FMT_SYMBOLIC_OR_ID "%s"
+
+#define TYPE_INTERFACE_NAME TYPE_STRN(INTERFACE_LEN)
+#define TYPE_FMT_INTERFACE_NAME "%s"
+
+#define TYPE_IP_ADDRESS \
+  (parser_type_t) { .name = TYPENAME_IP_ADDRESS, }
+#define TYPE_FMT_IP_ADDRESS "%s"
+
+#define TYPE_IP_PREFIX \
+  (parser_type_t) { .name = TYPENAME_IP_PREFIX, }
+#define TYPE_FMT_IP_PREFIX "%s"
+
+#define TYPE_ON_OFF \
+  (parser_type_t) { .name = TYPENAME_ON_OFF, }
+#define TYPE_FMT_ON_OFF "%s"
+
+#define TYPE_ENUM(x)                                     \
+  (parser_type_t) {                                      \
+    .name = TYPENAME_ENUM,                               \
+    .enum_ = {                                           \
+        .from_str = (int (*)(const char *))x##_from_str, \
+    },                                                   \
+  }
+/* We need to allocate room for the intermediate string */
+#define TYPE_FMT_ENUM "%s"
+
+#define TYPE_POLICY_STATE(TAG)     \
+  (parser_type_t) {                \
+    .name = TYPENAME_POLICY_STATE, \
+    .policy_state = {              \
+        .tag = TAG,                \
+    },                             \
+  }
+/* We need to allocate room for the intermediate string */
+#define TYPE_FMT_POLICY_STATE "%s"
+
+/**
+ * \brief Register a protocol
+ * \param protocol Pointer to a protocol_t structure describing the protocol to
+ * register \return None
+ */
+
+void command_register(const command_parser_t *command);
+
+/**
+ * \brief Search a registered protocol in the library according to its name
+ * \param[in] action The action of the command.
+ * \param[in] object The object of the command.
+ * \param[in] nparams The number of parameters expected in the command.
+ * \return A pointer to the corresponding command if any, NULL othewise
+ */
+const command_parser_t *command_search(hc_action_t action,
+                                       hc_object_type_t object,
+                                       unsigned nparams);
+
+/**
+ * @brief List the commands associated with the specified object and/or action.
+ * Use OBJECT_UNDEFINED and ACTION_UNDEFINED to list all the available objects.
+ * Use ACTION_UNDEFINED to list all the actions associated to the specified
+ * object.
+ *
+ * @param object The action of the command
+ * @param action The object of the command
+ */
+void command_list(hc_object_type_t object, hc_action_t action);
+
+#define COMMAND_REGISTER(MOD)                                  \
+  static void __init_##MOD(void) __attribute__((constructor)); \
+  static void __init_##MOD(void) { command_register(&MOD); }
+
+#endif /* HICNLIGHT_CONFIG_COMMAND */
diff --git a/hicn-light/src/hicn/config/commandOps.c b/hicn-light/src/hicn/config/commandOps.c
deleted file mode 100644
index dd8e148d0..000000000
--- a/hicn-light/src/hicn/config/commandOps.c
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifndef __ANDROID__
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#else
-#ifndef _WIN32
-extern int errno;
-#endif
-#endif
-#endif
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/config/commandOps.h>
-#include <hicn/config/commandParser.h>
-
-CommandOps *commandOps_Create(void *closure, const char *command,
-                              void (*init)(CommandParser *parser,
-                                           CommandOps *ops),
-                              CommandReturn (*execute)(CommandParser *parser,
-                                                       CommandOps *ops,
-                                                       PARCList *args,
-                                                       char *output,
-                                                       size_t output_size),
-                              void (*destroyer)(CommandOps **opsPtr)) {
-  parcAssertNotNull(command, "Parameter command must be non-null");
-  parcAssertNotNull(execute, "Parameter execute must be non-null");
-  CommandOps *ops = parcMemory_AllocateAndClear(sizeof(CommandOps));
-  parcAssertNotNull(ops, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(CommandOps));
-
-  ops->closure = closure;
-  ops->command = parcMemory_StringDuplicate(command, strlen(command) + 1);
-  ops->init = init;
-  ops->execute = execute;
-  ops->destroyer = destroyer;
-  return ops;
-}
-
-void commandOps_Destroy(CommandOps **opsPtr) {
-  parcAssertNotNull(opsPtr, "Parameter opsPtr must be non-null");
-  parcAssertNotNull(*opsPtr,
-                    "Parameter opsPtr must dereference to non-null pointer");
-
-  CommandOps *ops = *opsPtr;
-  parcMemory_Deallocate((void **)&(ops->command));
-  // DO NOT call ops->destroyer, we are one!
-  parcMemory_Deallocate((void **)&ops);
-
-  *opsPtr = NULL;
-}
diff --git a/hicn-light/src/hicn/config/commandOps.h b/hicn-light/src/hicn/config/commandOps.h
deleted file mode 100644
index 784b91eb8..000000000
--- a/hicn-light/src/hicn/config/commandOps.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * 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 command_Ops.h
- * @brief The function structure defining a CLI command
- *
- * The function structure that defines a CLI command.  Each command will return
- * one of these which defines how to run the command.
- *
- */
-
-#ifndef command_Ops_h
-#define command_Ops_h
-
-#include <parc/algol/parc_List.h>
-
-#include <hicn/config/commandReturn.h>
-
-// forward reference
-struct command_parser;
-
-struct command_ops;
-typedef struct command_ops CommandOps;
-
-/**
- * @typedef CommandOps
- * @abstract Each command implements a CommandOps
- * @constant closure is a user-specified pointer for any state the user needs
- * @constant command The text string of the command, must be the spelled out
- * string, e.g. "help list routes"
- * @constant init A function to call to initialize the command at program
- * startup
- * @constant execute A function to call to execute the command
- * @constant destroyer A function to call to release the command
- * @discussion
- *     Typically, the root of the thee has an Init function that then initilizes
- * the rest of the tree.  For example:
- *
- * @code
- *    const CommandOps control_Root = {
- *      .closure = NULL,
- *      .command = "", // empty string for root
- *      .init    = control_Root_Init,
- *      .execute = control_Root_Execute
- *      .destroyer = NULL
- *    };
- * @endcode
- *
- * The control_Root_Init function will then begin adding the subtree under root.
- * For example:
- *
- * @code
- *  const CommandOps control_Add = {
- *      .closure = NULL,
- *      .command = "add",
- *      .init    = control_Add_Init,
- *      .execute = control_Add_Execute,
- *      .destroyer = NULL
- *  };
- *
- *  static void
- *  control_Root_Init(ControlState *state, CommandOps *ops)
- *  {
- *      controlState_RegisterCommand(state, &control_Add);
- *  }
- * @endcode
- */
-struct command_ops {
-  void *closure;
-  char *command;
-  void (*init)(struct command_parser *parser, CommandOps *ops);
-  CommandReturn (*execute)(struct command_parser *parser,
-                 CommandOps *ops,
-                 PARCList *args,
-                 char *output,
-                 size_t output_size);
-  void (*destroyer)(CommandOps **opsPtr);
-};
-
-/**
- * A helper function to create the pubically defined CommandOps.
- *
- * Retruns allocated memory of the command
- *
- * @param [in] command The string is copied
- *
- * @retval <#value#> <#explanation#>
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-CommandOps *commandOps_Create(
-    void *closure, const char *command,
-    void (*init)(struct command_parser *parser, CommandOps *ops),
-    CommandReturn (*execute)(struct command_parser *parser,
-                             CommandOps *ops,
-                             PARCList *args,
-                             char *output,
-                             size_t output_size),
-    void (*destroyer)(CommandOps **opsPtr));
-
-/**
- * De-allocates the memory of the CommandOps and the copied command string
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in out in,out#>] <#name#> <#description#>
- *
- * @retval <#value#> <#explanation#>
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void commandOps_Destroy(CommandOps **opsPtr);
-#endif  // command_Ops_h
diff --git a/hicn-light/src/hicn/config/commandParser.c b/hicn-light/src/hicn/config/commandParser.c
deleted file mode 100644
index f4652fe39..000000000
--- a/hicn-light/src/hicn/config/commandParser.c
+++ /dev/null
@@ -1,221 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <parc/assert/parc_Assert.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <parc/security/parc_Security.h>
-
-#include <parc/algol/parc_List.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Time.h>
-#include <parc/algol/parc_TreeRedBlack.h>
-
-#include <hicn/config/commandParser.h>
-
-#ifndef __ANDROID__
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#else
-#ifndef _WIN32
-extern int errno;
-#endif
-#endif
-#endif
-
-struct command_parser {
-  // key = command, value = CommandOps
-  PARCTreeRedBlack *commandTree;
-  bool debugFlag;
-};
-
-static int _stringCompare(const void *key1, const void *key2) {
-  return strcasecmp((const char *)key1, (const char *)key2);
-}
-
-CommandParser *commandParser_Create(void) {
-  CommandParser *state = parcMemory_AllocateAndClear(sizeof(CommandParser));
-  parcAssertNotNull(state, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(CommandParser));
-
-  state->commandTree = parcTreeRedBlack_Create(_stringCompare,  // key compare
-                                               NULL,            // key free
-                                               NULL,            // key copy
-                                               NULL,            // value equals
-                                               NULL,            // value free
-                                               NULL             // value copy
-  );
-  state->debugFlag = false;
-  return state;
-}
-
-void commandParser_Destroy(CommandParser **parserPtr) {
-  CommandParser *parser = *parserPtr;
-
-  // destroy every element if it has a destroyer
-  PARCArrayList *values = parcTreeRedBlack_Values(parser->commandTree);
-  if (values) {
-    for (int i = 0; i < parcArrayList_Size(values); i++) {
-      CommandOps *ops = parcArrayList_Get(values, i);
-      parcTreeRedBlack_Remove(parser->commandTree, ops->command);
-      if (ops->destroyer) {
-        ops->destroyer(&ops);
-      }
-    }
-    parcArrayList_Destroy(&values);
-  }
-
-  parcTreeRedBlack_Destroy(&parser->commandTree);
-
-  parcMemory_Deallocate((void **)&parser);
-  *parserPtr = NULL;
-}
-
-void commandParser_SetDebug(CommandParser *state, bool debugFlag) {
-  state->debugFlag = debugFlag;
-}
-
-bool commandParser_GetDebug(CommandParser *state) { return state->debugFlag; }
-
-void commandParser_RegisterCommand(CommandParser *state, CommandOps *ops) {
-  parcAssertNotNull(state, "Parameter state must be non-null");
-  parcAssertNotNull(ops, "Parameter ops must be non-null");
-  parcAssertNotNull(ops->command, "Operation command string must be non-null");
-
-  void *exists = parcTreeRedBlack_Get(state->commandTree, ops->command);
-  parcAssertNull(exists, "Command '%s' already exists in the tree %p\n",
-                 ops->command, (void *)exists);
-
-  parcTreeRedBlack_Insert(state->commandTree, (void *)ops->command,
-                          (void *)ops);
-
-  // if the command being registered asked for an init function to be called,
-  // call it
-  if (ops->init != NULL) {
-    ops->init(state, ops);
-  }
-}
-
-static PARCList *parseStringIntoTokens(const char *originalString) {
-  PARCList *list =
-      parcList(parcArrayList_Create(parcArrayList_StdlibFreeFunction),
-               PARCArrayListAsPARCList);
-
-  char *token;
-
-  char *tofree =
-      parcMemory_StringDuplicate(originalString, strlen(originalString) + 1);
-  char *string = tofree;
-
-  token = strtok(string, " \t\n");
-  while (token != NULL) {
-    if (strlen(token) > 0) {
-      parcList_Add(list, strdup(token));
-    }
-    token = strtok(NULL, " \t\n");
-  }
-
-  parcMemory_Deallocate((void **)&tofree);
-
-  return list;
-}
-
-/**
- * Matches the user arguments to available commands, returning the command or
- * NULL if not found
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in out in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-static CommandOps *commandParser_MatchCommand(CommandParser *state,
-                                              PARCList *args) {
-  // Find the longest matching prefix command.
-  // Pretty wildly inefficient
-
-  size_t longest_token_count = 0;
-  char *longest_command = NULL;
-
-  PARCArrayList *commands = parcTreeRedBlack_Keys(state->commandTree);
-  for (int i = 0; i < parcArrayList_Size(commands); i++) {
-    char *command = parcArrayList_Get(commands, i);
-    PARCList *command_tokens = parseStringIntoTokens(command);
-
-    // is it a prefix match?
-    if (parcList_Size(args) >= parcList_Size(command_tokens)) {
-      bool possible_match = true;
-      for (int i = 0; i < parcList_Size(command_tokens) && possible_match;
-           i++) {
-        const char *a = parcList_GetAtIndex(command_tokens, i);
-        const char *b = parcList_GetAtIndex(args, i);
-        if (strncasecmp(a, b, strlen(a) + 1) != 0) {
-          possible_match = false;
-        }
-      }
-
-      if (possible_match &&
-          parcList_Size(command_tokens) > longest_token_count) {
-        longest_token_count = parcList_Size(command_tokens);
-        longest_command = command;
-      }
-    }
-
-    parcList_Release(&command_tokens);
-  }
-
-  parcArrayList_Destroy(&commands);
-
-  if (longest_token_count == 0) {
-    return NULL;
-  } else {
-    CommandOps *ops = parcTreeRedBlack_Get(state->commandTree, longest_command);
-    parcAssertNotNull(ops, "Got null operations for command '%s'\n",
-                      longest_command);
-    return ops;
-  }
-}
-
-CommandReturn commandParser_DispatchCommand(CommandParser *state,
-                                            PARCList *args,
-                                            char *output,
-                                            size_t output_size) {
-  parcAssertNotNull(output, "output buffer is null\n");
-  CommandOps *ops = commandParser_MatchCommand(state, args);
-
-  if (ops == NULL) {
-    snprintf(output, output_size, "Command not found.\n");
-    return CommandReturn_Failure;
-  } else {
-    return ops->execute(state, ops, args, output, output_size);
-  }
-}
-
-bool commandParser_ContainsCommand(CommandParser *parser, const char *command) {
-  CommandOps *ops = parcTreeRedBlack_Get(parser->commandTree, command);
-  return (ops != NULL);
-}
diff --git a/hicn-light/src/hicn/config/commandParser.h b/hicn-light/src/hicn/config/commandParser.h
deleted file mode 100644
index 882d55d26..000000000
--- a/hicn-light/src/hicn/config/commandParser.h
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- * 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 command_Parser.h
- * @brief Creates a dictionary of commands and parses a command_line to match
- * against them
- *
- * A user creates individual CommandParserEntry that map a command_line to a
- * function to execute.  The CommandParser then does a longest-matching prefix
- * match of a command_line to the dictionary of commands and executes the
- * appropriate command.
- *
- */
-
-#ifndef command_parser_h
-#define command_parser_h
-
-#include <hicn/config/commandOps.h>
-#include <hicn/config/commandReturn.h>
-
-struct command_parser;
-typedef struct command_parser CommandParser;
-
-/**
- * controlState_Create
- *
- * Creates the global state for the Control program
- *
- * @return non-null A command parser
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-CommandParser *commandParser_Create(void);
-
-/**
- * Destroys the control state, closing all network connections
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in out in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void commandParser_Destroy(CommandParser **statePtr);
-
-/**
- * Registers a CommandOps with the system.
- *
- * Each command has its complete command prefix in the "command" field.
- * RegisterCommand will put these command prefixes in to a tree and then match
- * what a user types against the longest-matching prefix in the tree.  If
- * there's a match, it will call the "execute" function.
- *
- * When the parser is destroyed, each command's destroyer function will be
- * called.
- *
- * @param [in] state An allocated ControlState
- * @param [in] command The command to register with the system
- *
- * Example:
- * @code
- *      static ControlReturn
- *      control_Root_Execute(CommandParser *parser, CommandOps *ops, PARCList
- * *args)
- *      {
- *          printf("Root Command\n");
- *          return CommandReturn_Success;
- *      }
- *
- *      static ControlReturn
- *      control_FooBar_Execute(CommandParser *parser, CommandOps *ops, PARCList
- * *args)
- *      {
- *          printf("Foo Bar Command\n");
- *          return CommandReturn_Success;
- *      }
- *
- *      const CommandOps control_Root = {
- *      .closure = NULL,
- *      .command = "", // empty string for root
- *      .init    = NULL,
- *      .execute = control_Root_Execute
- *      };
- *
- *      const CommandOps control_FooBar = {
- *      .closure = NULL,
- *      .command = "foo bar", // empty string for root
- *      .init    = NULL,
- *      .execute = control_FooBar_Execute
- *      };
- *
- *   void startup(void)
- *   {
- *      ControlState *state = controlState_Create("happy", "day");
- *      controlState_RegisterCommand(state, control_FooBar);
- *      controlState_RegisterCommand(state, control_Root);
- *
- *      // this executes "root"
- *      controlState_DispatchCommand(state, "foo");
- *      controlState_Destroy(&state);
- *  }
- * @endcode
- */
-void commandParser_RegisterCommand(CommandParser *state, CommandOps *command);
-
-/**
- * Performs a longest-matching prefix of the args to the command tree
- *
- * The command tree is created with controlState_RegisterCommand.
- *
- * @param [in] state The allocated ControlState
- * @param [in] args  Each command_line word parsed to the ordered list
- * @param [in] output The allocated output string, if null, the normal printf is executed
- * @param [in] output_size the size of output array string. It is ignored if the output string is null
- *
- * @return CommandReturn_Success the command was successful
- * @return CommandReturn_Failure the command failed or was not found
- * @return CommandReturn_Exit the command indicates that the interactive mode
- * should exit
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-CommandReturn commandParser_DispatchCommand(CommandParser *state,
-                                            PARCList *args,
-                                            char *output,
-                                            size_t output_size);
-
-/**
- * Sets the Debug mode, which will print out much more information.
- *
- * Prints out much more diagnostic information about what hicn-light controller
- * is doing. yes, you would make a CommandOps to set and unset this :)
- *
- * @param [in] debugFlag true means to print debug info, false means to turn it
- * off
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void commandParser_SetDebug(CommandParser *state, bool debugFlag);
-
-/**
- * Returns the debug state of ControlState
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in out in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-bool commandParser_GetDebug(CommandParser *state);
-
-/**
- * Checks if the command is registered
- *
- * Checks if the exact command given is registered.  This is not a prefix match.
- *
- * @param [<#in out in,out#>] <#name#> <#description#>
- *
- * @return true The command is registered
- * @return false The command is not registered
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-bool commandParser_ContainsCommand(CommandParser *parser, const char *command);
-#endif  // command_parser_h
diff --git a/hicn-light/src/hicn/config/commandReturn.h b/hicn-light/src/hicn/config/commandReturn.h
deleted file mode 100644
index 16ee93db1..000000000
--- a/hicn-light/src/hicn/config/commandReturn.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * 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 command_Return.h
- * @brief The return code used by CLI commands
- *
- * This return code is used throughout the command parser and command
- * implementations to indicate success, failure, or if the program should exit.
- *
- */
-
-#ifndef command_return_h
-#define command_return_h
-
-/**
- * @typedef ControlReturn
- * @abstract A command returns one of (SUCCESS, FAILURE, EXIT)
- * @constant SUCCESS means the command succeeded
- * @constant FAILURE indicates failure
- * @constant EXIT means the command indicated that hicn-light controller should
- * exit.
- * @discussion <#Discussion#>
- */
-typedef enum command_return {
-  CommandReturn_Success,  // command returned success
-  CommandReturn_Failure,  // command failure
-  CommandReturn_Exit      // command indicates program should exit
-} CommandReturn;
-
-#endif  // command_return_h
diff --git a/hicn-light/src/hicn/config/command_cache.c b/hicn-light/src/hicn/config/command_cache.c
new file mode 100644
index 000000000..073221cf0
--- /dev/null
+++ b/hicn-light/src/hicn/config/command_cache.c
@@ -0,0 +1,54 @@
+#include <math.h>
+#include "command.h"
+
+/* Parameters */
+
+#define serve                                                            \
+  {                                                                      \
+    .name = "serve",                                                     \
+    .help =                                                              \
+        "Enables/disables replies from local content store. Either the " \
+        "string 'on' or 'off'",                                          \
+    .type = TYPE_ON_OFF, .offset = offsetof(hc_cache_t, serve),          \
+  }
+
+#define store                                                                 \
+  {                                                                           \
+    .name = "store",                                                          \
+    .help =                                                                   \
+        "enables/disables the storage of incoming data packets in the local " \
+        "content store. Either the string 'on' or 'off'",                     \
+    .type = TYPE_ON_OFF, .offset = offsetof(hc_cache_t, store),               \
+  }
+
+/* Commands */
+
+static const command_parser_t command_cache_set_serve = {
+    .action = ACTION_SERVE,
+    .object = OBJECT_CACHE,
+    .nparams = 1,
+    .parameters = {serve},
+};
+COMMAND_REGISTER(command_cache_set_serve);
+
+static const command_parser_t command_cache_set_store = {
+    .action = ACTION_STORE,
+    .object = OBJECT_CACHE,
+    .nparams = 1,
+    .parameters = {store},
+};
+COMMAND_REGISTER(command_cache_set_store);
+
+static const command_parser_t command_cache_clear = {
+    .action = ACTION_CLEAR,
+    .object = OBJECT_CACHE,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_cache_clear);
+
+static const command_parser_t command_cache_list = {
+    .action = ACTION_LIST,
+    .object = OBJECT_CACHE,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_cache_list);
diff --git a/hicn-light/src/hicn/config/command_connection.c b/hicn-light/src/hicn/config/command_connection.c
new file mode 100644
index 000000000..069bf55a6
--- /dev/null
+++ b/hicn-light/src/hicn/config/command_connection.c
@@ -0,0 +1,128 @@
+#include <math.h>
+#include "command.h"
+
+/* Parameters */
+
+#define type_hicn                                                            \
+  {                                                                          \
+    .name = "type", .help = "connection type (hICN)",                        \
+    .type = TYPE_ENUM(face_type), .offset = offsetof(hc_connection_t, type), \
+  }
+
+#define type_tcp_udp                                                         \
+  {                                                                          \
+    .name = "type", .help = "connection type [tcp | udp]",                   \
+    .type = TYPE_ENUM(face_type), .offset = offsetof(hc_connection_t, type), \
+  }
+
+#define symbolic                                                              \
+  {                                                                           \
+    .name = "symbolic",                                                       \
+    .help = "symbolic name, e.g. 'conn1' (must be unique, start with alpha)", \
+    .type = TYPE_SYMBOLIC_OR_ID, .offset = offsetof(hc_connection_t, name),   \
+  }
+
+#define local_address                                                         \
+  {                                                                           \
+    .name = "local_addr", .help = "local IP address on which to bind.",       \
+    .type = TYPE_IP_ADDRESS, .offset = offsetof(hc_connection_t, local_addr), \
+    .offset2 = offsetof(hc_connection_t, family),                             \
+  }
+
+#define local_port                                   \
+  {                                                  \
+    .name = "local_port", .help = "Local port.",     \
+    .type = TYPE_INT(1, UINT16_MAX),                 \
+    .offset = offsetof(hc_connection_t, local_port), \
+  }
+
+#define remote_address                                                         \
+  {                                                                            \
+    .name = "remote_address",                                                  \
+    .help = "The IPv4 or IPv6 or hostname of the remote system.",              \
+    .type = TYPE_IP_ADDRESS, .offset = offsetof(hc_connection_t, remote_addr), \
+    .offset2 = offsetof(hc_connection_t, family),                              \
+  }
+
+#define remote_port                                   \
+  {                                                   \
+    .name = "remote_port", .help = "Remote port.",    \
+    .type = TYPE_INT(1, UINT16_MAX),                  \
+    .offset = offsetof(hc_connection_t, remote_port), \
+  }
+
+#define interface                                              \
+  {                                                            \
+    .name = "interface", .help = "Interface on which to bind", \
+    .type = TYPE_INTERFACE_NAME,                               \
+    .offset = offsetof(hc_connection_t, interface_name),       \
+  }
+
+#define symbolic_or_id                                                      \
+  {                                                                         \
+    .name = "symbolic", .help = "The connection symbolic name or id",       \
+    .type = TYPE_SYMBOLIC_OR_ID, .offset = offsetof(hc_connection_t, name), \
+  }
+
+/* Commands */
+
+int on_connection_create(hc_connection_t* connection) {
+  connection->admin_state = FACE_STATE_UP;
+  return 0;
+}
+
+#if 0
+static command_parser_t command_connection_create4 = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_CONNECTION,
+    .nparams = 4,
+    .parameters = {type_hicn, symbolic, local_address, remote_address},
+    .post_hook = (parser_hook_t)on_connection_create,
+};
+COMMAND_REGISTER(command_connection_create4);
+
+static const command_parser_t command_connection_create5 = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_CONNECTION,
+    .nparams = 5,
+    .parameters = {type_hicn, symbolic, local_address, remote_address,
+                   interface},
+    .post_hook = (parser_hook_t)on_connection_create,
+};
+COMMAND_REGISTER(command_connection_create5);
+#endif
+
+static const command_parser_t command_connection_create6 = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_CONNECTION,
+    .nparams = 6,
+    .parameters = {type_tcp_udp, symbolic, remote_address, remote_port,
+                   local_address, local_port},
+    .post_hook = (parser_hook_t)on_connection_create,
+};
+COMMAND_REGISTER(command_connection_create6);
+
+static const command_parser_t command_connection_create7 = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_CONNECTION,
+    .nparams = 7,
+    .parameters = {type_tcp_udp, symbolic, remote_address, remote_port,
+                   local_address, local_port, interface},
+    .post_hook = (parser_hook_t)on_connection_create,
+};
+COMMAND_REGISTER(command_connection_create7);
+
+static const command_parser_t command_connection_list = {
+    .action = ACTION_LIST,
+    .object = OBJECT_CONNECTION,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_connection_list);
+
+static const command_parser_t command_connection_remove = {
+    .action = ACTION_DELETE,
+    .object = OBJECT_CONNECTION,
+    .nparams = 1,
+    .parameters = {symbolic_or_id},
+};
+COMMAND_REGISTER(command_connection_remove);
diff --git a/hicn-light/src/hicn/config/command_face.c b/hicn-light/src/hicn/config/command_face.c
new file mode 100644
index 000000000..95ec404f0
--- /dev/null
+++ b/hicn-light/src/hicn/config/command_face.c
@@ -0,0 +1,16 @@
+#if 0
+#include "command.h"
+
+/* Parameters */
+
+/* Commands */
+
+// XXX missing add
+
+static const command_parser_t command_face_list = {
+    .action = ACTION_LIST,
+    .object = OBJECT_FACE,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_face_list);
+#endif
\ No newline at end of file
diff --git a/hicn-light/src/hicn/config/command_listener.c b/hicn-light/src/hicn/config/command_listener.c
new file mode 100644
index 000000000..8ad7c94be
--- /dev/null
+++ b/hicn-light/src/hicn/config/command_listener.c
@@ -0,0 +1,111 @@
+#include <math.h>
+#include "command.h"
+
+/* Parameters */
+
+#define protocol_hicn                                                      \
+  {                                                                        \
+    .name = "protocol", .help = "Protocol [hicn].",                        \
+    .type = TYPE_ENUM(face_type), .offset = offsetof(hc_listener_t, type), \
+  }
+
+#define protocol_tcp_udp                                                   \
+  {                                                                        \
+    .name = "protocol", .help = "Protocol [tcp | udp]",                    \
+    .type = TYPE_ENUM(face_type), .offset = offsetof(hc_listener_t, type), \
+  }
+
+#define symbolic                                                          \
+  {                                                                       \
+    .name = "symbolic",                                                   \
+    .help =                                                               \
+        "User defined name for listener, must start with alpha and be "   \
+        "alphanum",                                                       \
+    .type = TYPE_SYMBOLIC_OR_ID, .offset = offsetof(hc_listener_t, name), \
+  }
+
+#define local_address                                                       \
+  {                                                                         \
+    .name = "local_addr",                                                   \
+    .help =                                                                 \
+        "IPv4 or IPv6 address (or prefix protocol = hicn) assigend to the " \
+        "local interface",                                                  \
+    .type = TYPE_IP_ADDRESS, .offset = offsetof(hc_listener_t, local_addr), \
+    .offset2 = offsetof(hc_listener_t, family),                             \
+  }
+
+#define local_port                                 \
+  {                                                \
+    .name = "local_port", .help = "Local port.",   \
+    .type = TYPE_INT(1, UINT16_MAX),               \
+    .offset = offsetof(hc_listener_t, local_port), \
+  }
+
+#define interface                                              \
+  {                                                            \
+    .name = "interface", .help = "Interface on which to bind", \
+    .type = TYPE_INTERFACE_NAME,                               \
+    .offset = offsetof(hc_listener_t, interface_name),         \
+  }
+
+#define symbolic_or_id                                                    \
+  {                                                                       \
+    .name = "symbolic", .help = "The listener symbolic name or id",       \
+    .type = TYPE_SYMBOLIC_OR_ID, .offset = offsetof(hc_listener_t, name), \
+  }
+
+/* Commands */
+
+/* The parse sets the wrong face_type_t for listener, we fix that here */
+int on_listener_create(hc_listener_t* listener) {
+  switch (listener->type) {
+    case FACE_TYPE_UDP:
+      listener->type = FACE_TYPE_UDP_LISTENER;
+      break;
+    case FACE_TYPE_TCP:
+      listener->type = FACE_TYPE_TCP_LISTENER;
+      break;
+    case FACE_TYPE_HICN:
+      listener->type = FACE_TYPE_HICN_LISTENER;
+      break;
+    default:
+      break;
+  }
+  return 0;
+}
+
+#if 0
+static const command_parser_t command_listener_create4 = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_LISTENER,
+    .nparams = 4,
+    .parameters = {protocol_hicn, symbolic, local_address, interface},
+    .post_hook = (parser_hook_t)on_listener_create,
+};
+COMMAND_REGISTER(command_listener_create4);
+#endif
+
+static const command_parser_t command_listener_create6 = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_LISTENER,
+    .nparams = 5,
+    .parameters = {protocol_tcp_udp, symbolic, local_address, local_port,
+                   interface},
+    .post_hook = (parser_hook_t)on_listener_create,
+};
+COMMAND_REGISTER(command_listener_create6);
+
+static const command_parser_t command_listener_list = {
+    .action = ACTION_LIST,
+    .object = OBJECT_LISTENER,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_listener_list);
+
+static const command_parser_t command_listener_remove = {
+    .action = ACTION_DELETE,
+    .object = OBJECT_LISTENER,
+    .nparams = 1,
+    .parameters = {symbolic_or_id},
+};
+COMMAND_REGISTER(command_listener_remove);
diff --git a/hicn-light/src/hicn/config/command_mapme.c b/hicn-light/src/hicn/config/command_mapme.c
new file mode 100644
index 000000000..a22e8b340
--- /dev/null
+++ b/hicn-light/src/hicn/config/command_mapme.c
@@ -0,0 +1,59 @@
+#include <math.h>
+#include "command.h"
+
+/* Parameters */
+
+#define target                                                                \
+  {                                                                           \
+    .name = "target",                                                         \
+    .help =                                                                   \
+        "Target for the set action, e.g. enable, discovery, timescale, retx", \
+    .type = TYPE_ENUM(mapme_target), .offset = offsetof(hc_mapme_t, target),  \
+  }
+
+#define value                                                              \
+  {                                                                        \
+    .name = "value",                                                       \
+    .help = "Value to set for the target, e.g. 'on', 'off', milliseconds", \
+    .type = TYPE_STRN(4), .offset = offsetof(hc_mapme_t, unparsed_arg),    \
+  }
+
+#define prefix                                                         \
+  {                                                                    \
+    .name = "prefix",                                                  \
+    .help = "The hicn name as IPv4 or IPv6 address (e.g 1234::0/64).", \
+    .type = TYPE_IP_PREFIX, .offset = offsetof(hc_mapme_t, address),   \
+    .offset2 = offsetof(hc_mapme_t, len),                              \
+    .offset3 = offsetof(hc_mapme_t, family),                           \
+  }
+
+/* Commands */
+
+// Parse the raw string argument into 'timescale' or 'enabled',
+// necessary since the command dispatch is based on the number
+// of arguments and not their type
+int parse_args(hc_mapme_t* mapme) {
+  mapme->timescale = atoi(mapme->unparsed_arg);
+
+  if (strcasecmp(mapme->unparsed_arg, "off") == 0) mapme->enabled = 0;
+  if (strcasecmp(mapme->unparsed_arg, "on") == 0) mapme->enabled = 1;
+
+  return 0;
+}
+
+static const command_parser_t command_mapme_set = {
+    .action = ACTION_SET,
+    .object = OBJECT_MAPME,
+    .nparams = 2,
+    .parameters = {target, value},
+    .post_hook = (parser_hook_t)parse_args,
+};
+COMMAND_REGISTER(command_mapme_set);
+
+static const command_parser_t command_mapme_update = {
+    .action = ACTION_UPDATE,
+    .object = OBJECT_MAPME,
+    .nparams = 1,
+    .parameters = {prefix},
+};
+COMMAND_REGISTER(command_mapme_update);
\ No newline at end of file
diff --git a/hicn-light/src/hicn/config/command_policy.c b/hicn-light/src/hicn/config/command_policy.c
new file mode 100644
index 000000000..1e802c3f5
--- /dev/null
+++ b/hicn-light/src/hicn/config/command_policy.c
@@ -0,0 +1,52 @@
+#if 0
+#include <hicn/policy.h>
+
+#include "command.h"
+
+/* Parameters */
+
+#define prefix                                                            \
+  {                                                                       \
+    .name = "prefix",                                                     \
+    .help = "The hicn name as IPv4 or IPv6 address (e.g 1234::0/64).",    \
+    .type = TYPE_IP_PREFIX, .offset = offsetof(hc_policy_t, remote_addr), \
+    .offset2 = offsetof(hc_policy_t, len),                                \
+    .offset3 = offsetof(hc_policy_t, family),                             \
+  }
+
+#define app_name                                                        \
+  {                                                                     \
+    .name = "app_name",                                                 \
+    .help = "The application name associated to this policy",           \
+    .type = TYPE_STR, .offset = offsetof(hc_policy_t, policy.app_name), \
+  }
+
+/* Commands */
+
+static const command_parser_t command_policy_create = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_POLICY,
+    .nparams = 2 + POLICY_TAG_N,
+    .parameters = {prefix, app_name,
+#define _(x, y)                                                            \
+  {                                                                        \
+      .name = "flag:" #x,                                                  \
+      .help =                                                              \
+          "A value among [neutral|require|prefer|avoid|prohibit] with an " \
+          "optional '!' character prefix for disabling changes",           \
+      .type = TYPE_POLICY_STATE(POLICY_TAG_##x),                           \
+      .offset = offsetof(hc_policy_t, policy.tags),                        \
+  },
+                   foreach_policy_tag
+#undef _
+    },
+};
+COMMAND_REGISTER(command_policy_create);
+
+static const command_parser_t command_policy_list = {
+    .action = ACTION_LIST,
+    .object = OBJECT_POLICY,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_policy_list);
+#endif
\ No newline at end of file
diff --git a/hicn-light/src/hicn/config/command_punting.c b/hicn-light/src/hicn/config/command_punting.c
new file mode 100644
index 000000000..8c7a6dec3
--- /dev/null
+++ b/hicn-light/src/hicn/config/command_punting.c
@@ -0,0 +1,40 @@
+#if 0
+#include "command.h"
+
+/* Parameters */
+
+#define symbolic_or_id                                                      \
+  {                                                                         \
+    .name = "symbolic_or_id",                                               \
+    .help =                                                                 \
+        "The symbolic name for an egress, or the egress punting id (see "   \
+        "'help list puntings')",                                            \
+    .type = TYPE_SYMBOLIC_OR_ID, .offset = offsetof(hc_punting_t, face_id), \
+  }
+
+#define prefix                                                        \
+  {                                                                   \
+    .name = "prefix",                                                 \
+    .help = "Prefix to add as a punting rule. (example 1234::0/64)",  \
+    .type = TYPE_IP_PREFIX, .offset = offsetof(hc_punting_t, prefix), \
+    .offset2 = offsetof(hc_punting_t, prefix_len),                    \
+    .offset3 = offsetof(hc_punting_t, family),                        \
+  }
+
+/* Commands */
+
+static const command_parser_t command_punting_create = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_PUNTING,
+    .nparams = 2,
+    .parameters = {symbolic_or_id, prefix},
+};
+COMMAND_REGISTER(command_punting_create);
+
+static const command_parser_t command_punting_list = {
+    .action = ACTION_LIST,
+    .object = OBJECT_PUNTING,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_punting_list);
+#endif
\ No newline at end of file
diff --git a/hicn-light/src/hicn/config/command_route.c b/hicn-light/src/hicn/config/command_route.c
new file mode 100644
index 000000000..dfbea101f
--- /dev/null
+++ b/hicn-light/src/hicn/config/command_route.c
@@ -0,0 +1,53 @@
+#include <math.h>
+#include "command.h"
+
+/* Parameters */
+
+#define symbolic_or_id                                                        \
+  {                                                                           \
+    .name = "symbolic_or_id",                                                 \
+    .help =                                                                   \
+        "The symbolic name for an egress, or the egress route id (see 'help " \
+        "list routes')",                                                      \
+    .type = TYPE_SYMBOLIC_OR_ID, .offset = offsetof(hc_route_t, name),        \
+  }
+
+#define prefix                                                           \
+  {                                                                      \
+    .name = "prefix",                                                    \
+    .help = "The hicn name as IPv4 or IPv6 address (e.g 1234::0/64).",   \
+    .type = TYPE_IP_PREFIX, .offset = offsetof(hc_route_t, remote_addr), \
+    .offset2 = offsetof(hc_route_t, len),                                \
+    .offset3 = offsetof(hc_route_t, family),                             \
+  }
+
+#define cost                                                        \
+  {                                                                 \
+    .name = "cost", .help = "Positive integer representing cost.",  \
+    .type = TYPE_INT(1, 255), .offset = offsetof(hc_route_t, cost), \
+  }
+
+/* Commands */
+
+static const command_parser_t command_route_create = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_ROUTE,
+    .nparams = 3,
+    .parameters = {symbolic_or_id, prefix, cost},
+};
+COMMAND_REGISTER(command_route_create);
+
+static const command_parser_t command_route_list = {
+    .action = ACTION_LIST,
+    .object = OBJECT_ROUTE,
+    .nparams = 0,
+};
+COMMAND_REGISTER(command_route_list);
+
+static const command_parser_t command_route_remove = {
+    .action = ACTION_DELETE,
+    .object = OBJECT_ROUTE,
+    .nparams = 2,
+    .parameters = {symbolic_or_id, prefix},
+};
+COMMAND_REGISTER(command_route_remove);
diff --git a/hicn-light/src/hicn/config/command_strategy.c b/hicn-light/src/hicn/config/command_strategy.c
new file mode 100644
index 000000000..2341ac830
--- /dev/null
+++ b/hicn-light/src/hicn/config/command_strategy.c
@@ -0,0 +1,47 @@
+#include "command.h"
+
+/* Parameters */
+#define prefix                                                          \
+  {                                                                     \
+    .name = "prefix",                                                   \
+    .help = "The hicn name as IPv4 or IPv6 address (e.g 1234::0/64).",  \
+    .type = TYPE_IP_PREFIX, .offset = offsetof(hc_strategy_t, address), \
+    .offset2 = offsetof(hc_strategy_t, len),                            \
+    .offset3 = offsetof(hc_strategy_t, family),                         \
+  }
+
+#define strategy                                                               \
+  {                                                                            \
+    .name = "strategy",                                                        \
+    .help =                                                                    \
+        "Strategy type (e.g. 'random', 'loadbalancer', 'low_latency', "        \
+        "'replication', 'bestpath').",                                         \
+    .type = TYPE_ENUM(strategy_type), .offset = offsetof(hc_strategy_t, type), \
+  }
+
+#define local_prefix                                                          \
+  {                                                                           \
+    .name = "local_prefix",                                                   \
+    .help = "The hicn name as IPv4 or IPv6 address (e.g 1234::0/64).",        \
+    .type = TYPE_IP_PREFIX, .offset = offsetof(hc_strategy_t, local_address), \
+    .offset2 = offsetof(hc_strategy_t, local_len),                            \
+    .offset3 = offsetof(hc_strategy_t, local_family),                         \
+  }
+
+/* Commands */
+
+static const command_parser_t command_strategy_list = {
+    .action = ACTION_SET,
+    .object = OBJECT_STRATEGY,
+    .nparams = 2,
+    .parameters = {prefix, strategy},
+};
+COMMAND_REGISTER(command_strategy_list);
+
+static const command_parser_t local_prefix_add = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_LOCAL_PREFIX,
+    .nparams = 3,
+    .parameters = {prefix, strategy, local_prefix},
+};
+COMMAND_REGISTER(local_prefix_add);
diff --git a/hicn-light/src/hicn/config/command_subscription.c b/hicn-light/src/hicn/config/command_subscription.c
new file mode 100644
index 000000000..89e3dcd98
--- /dev/null
+++ b/hicn-light/src/hicn/config/command_subscription.c
@@ -0,0 +1,23 @@
+#include "command.h"
+
+/* Parameters */
+
+#define topics                                                                 \
+  {                                                                            \
+    .name = "topics",                                                          \
+    .help =                                                                    \
+        "Topics to subscribe to, e.g. 6 (110 in binary) means topic 2 (10 in " \
+        "binary, TOPIC_CONNECTION) and topic 4 (100 in binary, "               \
+        "TOPIC_LISTENER).",                                                    \
+    .type = TYPE_INT(1, 255), .offset = offsetof(hc_subscription_t, topics),   \
+  }
+
+/* Commands */
+
+static const command_parser_t command_subscription_create = {
+    .action = ACTION_CREATE,
+    .object = OBJECT_SUBSCRIPTION,
+    .nparams = 1,
+    .parameters = {topics},
+};
+COMMAND_REGISTER(command_subscription_create);
\ No newline at end of file
diff --git a/hicn-light/src/hicn/config/commands.c b/hicn-light/src/hicn/config/commands.c
new file mode 100644
index 000000000..e99e0b8f5
--- /dev/null
+++ b/hicn-light/src/hicn/config/commands.c
@@ -0,0 +1,1530 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ *
+ * Example:
+ * @code
+ * <#example#>
+ * @endcode
+ */
+
+#ifndef _WIN32
+#include <arpa/inet.h>
+#include <unistd.h>
+#endif
+#include <ctype.h>
+#include <hicn/hicn-light/config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <hicn/core/connection.h>
+#include <hicn/core/connection_table.h>
+#include <hicn/core/forwarder.h>
+//#include <hicn/core/system.h>
+#ifdef WITH_MAPME
+#include <hicn/core/mapme.h>
+#endif /* WITH_MAPME */
+
+#include <hicn/core/listener.h>  //the listener list
+#include <hicn/core/listener_table.h>
+#include <hicn/core/subscription.h>
+#include <hicn/ctrl/hicn-light-ng.h>
+#include <hicn/utils/punting.h>
+#include <hicn/util/log.h>
+#include <hicn/validation.h>
+#include <hicn/face.h>
+
+#include "commands.h"
+#include "configuration.h"
+
+#define ETHERTYPE 0x0801
+#define DEFAULT_COST 1
+#define DEFAULT_PORT 1234
+
+#define make_ack(msg) ((msg_header_t *)msg)->header.message_type = ACK_LIGHT
+#define make_nack(msg) ((msg_header_t *)msg)->header.message_type = NACK_LIGHT
+
+#define msg_malloc_list(msg, COMMAND_ID, N, seq_number)                  \
+  do {                                                                   \
+    msg = calloc(1, sizeof((msg)->header) + N * sizeof((msg)->payload)); \
+    (msg)->header.message_type = RESPONSE_LIGHT;                         \
+    (msg)->header.command_id = (COMMAND_ID);                             \
+    (msg)->header.length = (uint16_t)(N);                                \
+    (msg)->header.seq_num = (seq_number);                                \
+  } while (0);
+
+// conn_id = UINT_MAX when symbolic_name is not found
+static inline unsigned _symbolic_to_conn_id(forwarder_t *forwarder,
+                                            const char *symbolic_or_connid,
+                                            bool allow_self,
+                                            unsigned ingress_id) {
+  unsigned conn_id;
+  const connection_table_t *table = forwarder_get_connection_table(forwarder);
+
+  if (allow_self && strcmp(symbolic_or_connid, "SELF") == 0) {
+    conn_id = ingress_id;
+  } else if (is_number(symbolic_or_connid, SYMBOLIC_NAME_LEN)) {
+    // case for conn_id as input
+    // XXX type issue ! XXX No check, see man
+    unsigned id = atoi(symbolic_or_connid);
+    if (id < 0) return CONNECTION_ID_UNDEFINED;
+    conn_id = id;
+
+    if (!connection_table_validate_id(table, conn_id)) {
+      ERROR("ConnID not found, check list connections");
+      conn_id = CONNECTION_ID_UNDEFINED;
+    }
+  } else {
+    // case for symbolic as input: check if symbolic name can be resolved
+    conn_id = connection_table_get_id_by_name(table, symbolic_or_connid);
+    if (connection_id_is_valid(conn_id)) {
+      DEBUG("Resolved symbolic name '%s' to conn_id %u", symbolic_or_connid,
+            conn_id);
+    } else {
+      WARN("Symbolic name '%s' could not be resolved", symbolic_or_connid);
+    }
+  }
+
+  return conn_id;
+}
+
+#define symbolic_to_conn_id(forwarder, symbolic) \
+  _symbolic_to_conn_id(forwarder, symbolic, false, 0)
+
+#define symbolic_to_conn_id_self(forwarder, symbolic, ingress_id) \
+  _symbolic_to_conn_id(forwarder, symbolic, true, ingress_id)
+
+connection_t *getConnectionBySymbolicOrId(forwarder_t *forwarder,
+                                          const char *symbolic_or_connid) {
+  connection_table_t *table = forwarder_get_connection_table(forwarder);
+  unsigned conn_id = symbolic_to_conn_id(forwarder, symbolic_or_connid);
+  if (!connection_id_is_valid(conn_id)) return NULL;
+
+  /* conn_id is assumed validated here */
+  return connection_table_at(table, conn_id);
+}
+
+/* Listener */
+
+uint8_t *configuration_on_listener_add(forwarder_t *forwarder, uint8_t *packet,
+                                       unsigned ingress_id,
+                                       size_t *reply_size) {
+  INFO("CMD: listener add (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_listener_add_t *msg = (msg_listener_add_t *)packet;
+  cmd_listener_add_t *control = &msg->payload;
+
+  switch (control->type) {
+    case FACE_TYPE_UDP_LISTENER:
+    case FACE_TYPE_TCP_LISTENER:
+    case FACE_TYPE_HICN_LISTENER:
+      break;
+    default:
+      goto NACK;
+  }
+
+  listener_table_t *table = forwarder_get_listener_table(forwarder);
+  assert(table);
+
+  /* Verify that the listener DOES NOT exist */
+  listener_t *listener = listener_table_get_by_name(table, control->symbolic);
+  if (listener) {
+    ERROR("Listener with name=%s already exists", control->symbolic);
+    goto NACK;
+  }
+
+  address_t address;
+  if (address_from_ip_port(&address, control->family, &control->address,
+                           control->port) < 0) {
+    WARN(
+        "Unsupported address type for HICN (ingress id %u): "
+        "must be either IPV4 or IPV6",
+        ingress_id);
+    goto NACK;
+  }
+
+  if (!face_type_is_defined(control->type)) {
+    WARN("[configuration_on_listener_add] Invalid listener type");
+    goto NACK;
+  }
+
+  listener = listener_table_get_by_address(table, control->type, &address);
+  if (listener) {
+    char addr_str[NI_MAXHOST];
+    int port;
+    address_to_string(&address, addr_str, &port);
+    ERROR("Listener for address=%s, type=%s already exists", addr_str,
+          face_type_str(control->type));
+    goto NACK;
+  }
+
+  // NOTE: interface_name is expected NULL for hICN listener
+
+  listener = listener_create(control->type, &address, control->interface_name,
+                             control->symbolic, forwarder);
+  if (!listener) goto NACK;
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+unsigned symbolic_to_listener_id(forwarder_t *forwarder,
+                                 const char *symbolic_or_listener_id) {
+  unsigned listener_id;
+  const listener_table_t *table = forwarder_get_listener_table(forwarder);
+
+  if (is_number(symbolic_or_listener_id, SYMBOLIC_NAME_LEN)) {
+    // XXX type issue ! XXX No check, see man
+    unsigned id = atoi(symbolic_or_listener_id);
+    if (id < 0) return LISTENER_ID_UNDEFINED;
+    listener_id = id;
+
+    if (!listener_table_validate_id(table, listener_id)) {
+      ERROR("Listener ID %d not found", id);
+      listener_id = LISTENER_ID_UNDEFINED;
+    }
+  } else {
+    // case for symbolic as input: check if symbolic name can be resolved
+    listener_id = listener_table_get_id_by_name(table, symbolic_or_listener_id);
+    if (listener_id_is_valid(listener_id)) {
+      DEBUG("Resolved symbolic name '%s' to conn_id %u",
+            symbolic_or_listener_id, listener_id);
+    } else {
+      WARN("Symbolic name '%s' could not be resolved", symbolic_or_listener_id);
+    }
+  }
+
+  return listener_id;
+}
+
+uint8_t *configuration_on_listener_remove(forwarder_t *forwarder,
+                                          uint8_t *packet, unsigned ingress_id,
+                                          size_t *reply_size) {
+  INFO("CMD: listener remove (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_listener_remove_t *msg = (msg_listener_remove_t *)packet;
+  cmd_listener_remove_t *control = &msg->payload;
+
+  unsigned listener_id =
+      symbolic_to_listener_id(forwarder, control->symbolicOrListenerid);
+  if (!listener_id_is_valid(listener_id)) {
+    ERROR("Invalid listener id=%u", listener_id);
+    goto NACK;
+  }
+
+  listener_table_t *listener_table = forwarder_get_listener_table(forwarder);
+  listener_t *listener = listener_table_get_by_id(listener_table, listener_id);
+  if (!listener) {
+    ERROR("Listener ID not found, check list listeners");
+    goto NACK;
+  }
+
+  // Do not remove listener if it is the one curretly used to send the command
+  connection_table_t *conn_table = forwarder_get_connection_table(forwarder);
+  connection_t *curr_connection =
+      connection_table_get_by_id(conn_table, ingress_id);
+  const address_pair_t *pair = connection_get_pair(curr_connection);
+  if (address_equals(listener_get_address(listener),
+                     address_pair_get_local(pair))) {
+    ERROR("Cannot remove current listener");
+    goto NACK;
+  }
+
+  connection_table_t *table = forwarder_get_connection_table(forwarder);
+  connection_t *connection;
+  connection_table_foreach(table, connection, {
+    const address_pair_t *pair = connection_get_pair(connection);
+    if (!address_equals(listener_get_address(listener),
+                        address_pair_get_local(pair)))
+      continue;
+
+    unsigned conn_id = connection_table_get_connection_id(table, connection);
+    /* Remove connection from the FIB */
+    forwarder_remove_connection_id_from_routes(forwarder, conn_id);
+
+    /* Remove connection */
+    connection_table_remove_by_id(table, conn_id);
+  });
+
+  /* Remove listener */
+  listener_table_remove_by_id(listener_table, listener_id);
+  listener_finalize(listener);
+  WITH_DEBUG(listener_table_print_by_key(listener_table);)
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+// TODO(eloparco): Unused forwarder param
+static inline void fill_listener_command(forwarder_t *forwarder,
+                                         listener_t *listener,
+                                         cmd_listener_list_item_t *cmd) {
+  assert(forwarder);
+  assert(listener);
+  assert(cmd);
+
+  struct sockaddr_in *sin;
+  struct sockaddr_in6 *sin6;
+
+  const address_t *addr = listener_get_address(listener);
+
+  cmd->id = (uint32_t)listener_get_id(listener);
+  cmd->type = (uint8_t)listener_get_type(listener);
+
+  switch (addr->as_ss.ss_family) {
+    case AF_INET:
+      sin = (struct sockaddr_in *)addr;
+      cmd->family = AF_INET;
+      cmd->address.v4.as_inaddr = sin->sin_addr;
+      cmd->port = sin->sin_port;
+      break;
+    case AF_INET6:
+      sin6 = (struct sockaddr_in6 *)addr;
+      cmd->family = AF_INET6;
+      cmd->address.v6.as_in6addr = sin6->sin6_addr;
+      cmd->port = sin6->sin6_port;
+      break;
+    default:
+      break;
+  }
+
+  const char *name = listener_get_name(listener);
+  snprintf(cmd->name, SYMBOLIC_NAME_LEN, "%s", name);
+  const char *interface_name = listener_get_interface_name(listener);
+  snprintf(cmd->interface_name, SYMBOLIC_NAME_LEN, "%s", interface_name);
+}
+
+uint8_t *configuration_on_listener_list(forwarder_t *forwarder, uint8_t *packet,
+                                        unsigned ingress_id,
+                                        size_t *reply_size) {
+  INFO("CMD: listener list (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  listener_table_t *table = forwarder_get_listener_table(forwarder);
+  size_t n = listener_table_len(table);
+  msg_listener_list_t *msg_received = (msg_listener_list_t *)packet;
+  uint8_t command_id = msg_received->header.command_id;
+  uint32_t seq_num = msg_received->header.seq_num;
+
+  msg_listener_list_reply_t *msg;
+  msg_malloc_list(msg, command_id, n, seq_num) if (!msg) goto NACK;
+
+  cmd_listener_list_item_t *payload = &msg->payload;
+  listener_t *listener;
+  listener_table_foreach(table, listener, {
+    fill_listener_command(forwarder, listener, payload);
+    payload++;
+  });
+
+  *reply_size = sizeof(msg->header) + n * sizeof(msg->payload);
+  return (uint8_t *)msg;
+
+NACK:
+  *reply_size = sizeof(msg_header_t);
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+/* Connection */
+
+uint8_t *configuration_on_connection_add(forwarder_t *forwarder,
+                                         uint8_t *packet, unsigned ingress_id,
+                                         size_t *reply_size) {
+  INFO("CMD: connection add (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_connection_add_t *msg = (msg_connection_add_t *)packet;
+  cmd_connection_add_t *control = &msg->payload;
+
+  switch (control->type) {
+    case FACE_TYPE_UDP:
+    case FACE_TYPE_TCP:
+    case FACE_TYPE_HICN:
+      break;
+    default:
+      goto NACK;
+  }
+
+  const char *symbolic_name = control->symbolic;
+
+  if (!face_type_is_defined(control->type)) goto NACK;
+
+  connection_table_t *table = forwarder_get_connection_table(forwarder);
+  if (connection_table_get_by_name(table, symbolic_name)) {
+    ERROR("Connection symbolic name already exists");
+    goto NACK;
+  }
+
+  address_pair_t pair;
+  if (address_pair_from_ip_port(&pair, control->family, &control->local_ip,
+                                control->local_port, &control->remote_ip,
+                                control->remote_port) < 0)
+    goto NACK;
+
+  connection_t *connection = connection_table_get_by_pair(table, &pair);
+#ifdef WITH_MAPME
+  connection_event_t event;
+#endif /* WITH_MAPME */
+
+  if (!connection) {
+    connection =
+        connection_create(control->type, symbolic_name, &pair, forwarder);
+    if (!connection) {
+      ERROR("Failed to create %s connection", face_type_str(control->type));
+      goto NACK;
+    }
+
+#ifdef WITH_MAPME
+    event = CONNECTION_EVENT_CREATE;
+#endif /* WITH_MAPME */
+  } else {
+    WARN("Connection already exists");
+
+#ifdef WITH_MAPME
+    event = CONNECTION_EVENT_UPDATE;
+#endif /* WITH_MAPME */
+  }
+
+#ifdef WITH_POLICY
+  connection_set_tags(connection, control->tags);
+  connection_set_priority(connection, control->priority);
+#endif /* WITH_POLICY */
+
+  connection_set_admin_state(connection, control->admin_state);
+
+#ifdef WITH_MAPME
+  /* Hook: new connection created through the control protocol */
+  forwarder_on_connection_event(forwarder, connection, event);
+#endif /* WITH_MAPME */
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+/**
+ * Add an IP-based tunnel.
+ *
+ * The call can fail if the symbolic name is a duplicate.  It could also fail if
+ * there's an problem creating the local side of the tunnel (i.e. the local
+ * socket address is not usable).
+ *
+ * @return true Tunnel added
+ * @return false Tunnel not added (an error)
+ */
+
+uint8_t *configuration_on_connection_remove(forwarder_t *forwarder,
+                                            uint8_t *packet,
+                                            unsigned ingress_id,
+                                            size_t *reply_size) {
+  INFO("CMD: connection remove (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_connection_remove_t *msg = (msg_connection_remove_t *)packet;
+  cmd_connection_remove_t *control = &msg->payload;
+
+  unsigned conn_id = symbolic_to_conn_id_self(
+      forwarder, control->symbolic_or_connid, ingress_id);
+  if (!connection_id_is_valid(conn_id)) {
+    ERROR("Invalid connection id=%u", conn_id);
+    goto NACK;
+  }
+
+  if (strcmp(control->symbolic_or_connid, "SELF") != 0 &&
+      conn_id == ingress_id) {
+    ERROR("Cannot remove current connection");
+    goto NACK;
+  }
+
+  /* Remove connection from the FIB */
+  forwarder_remove_connection_id_from_routes(forwarder, conn_id);
+
+  /* Remove connection */
+  connection_table_t *table = forwarder_get_connection_table(forwarder);
+  connection_t *connection = connection_table_get_by_id(table, conn_id);
+  connection_table_remove_by_id(table, conn_id);
+
+  // Don't close the fd for SELF otherwise it won't be possible
+  // to send the reply back
+  if (strcmp(control->symbolic_or_connid, "SELF") != 0)
+    connection_finalize(connection);
+  WITH_DEBUG(connection_table_print_by_pair(table);)
+
+#ifdef WITH_MAPME
+  /* Hook: new connection created through the control protocol */
+  forwarder_on_connection_event(forwarder, NULL, CONNECTION_EVENT_DELETE);
+#endif /* WITH_MAPME */
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+static inline void tolower_str(char *str) {
+  char *p = str;
+  for (; *p; p++) *p = tolower(*p);
+}
+
+// TODO(eloparco): Forwarder param not used
+static inline void fill_connections_command(forwarder_t *forwarder,
+                                            connection_t *connection,
+                                            cmd_connection_list_item_t *cmd) {
+  assert(forwarder);
+  assert(connection);
+  assert(cmd);
+
+  struct sockaddr_in *sin;
+  struct sockaddr_in6 *sin6;
+  const address_pair_t *pair = connection_get_pair(connection);
+
+  cmd->id = connection_get_id(connection),
+  cmd->state = connection_get_state(connection),
+  cmd->admin_state = connection_get_admin_state(connection),
+  cmd->type = connection_get_type(connection),
+#ifdef WITH_POLICY
+  cmd->priority = connection_get_priority(connection),
+  cmd->tags = connection_get_tags(connection),
+#endif /* WITH_POLICY */
+
+  snprintf(cmd->name, SYMBOLIC_NAME_LEN, "%s", connection_get_name(connection));
+  tolower_str(cmd->name);
+
+  snprintf(cmd->interface_name, SYMBOLIC_NAME_LEN, "%s",
+           connection_get_interface_name(connection));
+
+  switch (pair->local.as_ss.ss_family) {
+    case AF_INET:
+      cmd->family = AF_INET;
+
+      sin = (struct sockaddr_in *)(&pair->local);
+      cmd->local_port = sin->sin_port;
+      cmd->local_addr.v4.as_inaddr = sin->sin_addr;
+
+      sin = (struct sockaddr_in *)(&pair->remote);
+      cmd->remote_port = sin->sin_port;
+      cmd->remote_addr.v4.as_inaddr = sin->sin_addr;
+      break;
+
+    case AF_INET6:
+      cmd->family = AF_INET6;
+
+      sin6 = (struct sockaddr_in6 *)(&pair->local);
+      cmd->local_port = sin6->sin6_port;
+      cmd->local_addr.v6.as_in6addr = sin6->sin6_addr;
+
+      sin6 = (struct sockaddr_in6 *)(&pair->remote);
+      cmd->remote_port = sin6->sin6_port;
+      cmd->remote_addr.v6.as_in6addr = sin6->sin6_addr;
+      break;
+
+    default:
+      break;
+  }
+}
+
+uint8_t *configuration_on_connection_list(forwarder_t *forwarder,
+                                          uint8_t *packet, unsigned ingress_id,
+                                          size_t *reply_size) {
+  INFO("CMD: connection list (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  connection_table_t *table = forwarder_get_connection_table(forwarder);
+  // -1 since current connection (i.e. the one used to send
+  // the command) is not considered
+  size_t n = connection_table_len(table) - 1;
+  msg_connection_list_t *msg_received = (msg_connection_list_t *)packet;
+  uint8_t command_id = msg_received->header.command_id;
+  uint32_t seq_num = msg_received->header.seq_num;
+
+  msg_connection_list_reply_t *msg;
+  msg_malloc_list(msg, command_id, n, seq_num) if (!msg) goto NACK;
+
+  cmd_connection_list_item_t *payload = &msg->payload;
+  connection_t *connection;
+  connection_table_foreach(table, connection, {
+    if (connection->id == ingress_id) continue;
+    fill_connections_command(forwarder, connection, payload);
+    payload++;
+  });
+
+  *reply_size = sizeof(msg->header) + n * sizeof(msg->payload);
+  return (uint8_t *)msg;
+
+NACK:
+  *reply_size = sizeof(msg_header_t);
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_connection_set_admin_state(forwarder_t *forwarder,
+                                                     uint8_t *packet,
+                                                     unsigned ingress_id,
+                                                     size_t *reply_size) {
+  assert(forwarder);
+  assert(packet);
+
+  msg_connection_set_admin_state_t *msg =
+      (msg_connection_set_admin_state_t *)packet;
+  cmd_connection_set_admin_state_t *control = &msg->payload;
+
+  if ((control->admin_state != FACE_STATE_UP) &&
+      (control->admin_state != FACE_STATE_DOWN))
+    goto NACK;
+
+  connection_t *conn =
+      getConnectionBySymbolicOrId(forwarder, control->symbolic_or_connid);
+  if (!conn) goto NACK;
+
+  connection_set_admin_state(conn, control->admin_state);
+
+#ifdef WITH_MAPME
+  /* Hook: connection event */
+  forwarder_on_connection_event(forwarder, conn,
+                                control->admin_state == FACE_STATE_UP
+                                    ? CONNECTION_EVENT_SET_UP
+                                    : CONNECTION_EVENT_SET_DOWN);
+#endif /* WITH_MAPME */
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_connection_update(forwarder_t *forwarder,
+                                            uint8_t *packet,
+                                            unsigned ingress_id,
+                                            size_t *reply_size) {
+  assert(forwarder);
+  assert(packet);
+
+#ifdef WITH_POLICY
+  msg_connection_update_t *msg = (msg_connection_update_t *)packet;
+  cmd_connection_update_t *control = &msg->payload;
+
+  connection_t *conn =
+      getConnectionBySymbolicOrId(forwarder, control->symbolic_or_connid);
+  if (!conn) goto NACK;
+
+  connection_set_tags(conn, control->tags);
+  connection_set_admin_state(conn, control->admin_state);
+  if (control->priority > 0) connection_set_priority(conn, control->priority);
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+#endif /* WITH_POLICY */
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_connection_set_priority(forwarder_t *forwarder,
+                                                  uint8_t *packet,
+                                                  unsigned ingress_id,
+                                                  size_t *reply_size) {
+  assert(forwarder);
+  assert(packet);
+
+#ifdef WITH_POLICY
+  msg_connection_set_priority_t *msg = (msg_connection_set_priority_t *)packet;
+  cmd_connection_set_priority_t *control = &msg->payload;
+
+  connection_t *conn =
+      getConnectionBySymbolicOrId(forwarder, control->symbolic_or_connid);
+  if (!conn) goto NACK;
+
+  connection_set_priority(conn, control->priority);
+
+#ifdef WITH_MAPME
+  /* Hook: connection event */
+  forwarder_on_connection_event(forwarder, conn,
+                                CONNECTION_EVENT_PRIORITY_CHANGED);
+#endif /* WITH_MAPME */
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+#endif /* WITH_POLICY */
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_connection_set_tags(forwarder_t *forwarder,
+                                              uint8_t *packet,
+                                              unsigned ingress_id,
+                                              size_t *reply_size) {
+  assert(forwarder);
+  assert(packet);
+
+#ifdef WITH_POLICY
+  msg_connection_set_tags_t *msg = (msg_connection_set_tags_t *)packet;
+  cmd_connection_set_tags_t *control = &msg->payload;
+
+  connection_t *conn =
+      getConnectionBySymbolicOrId(forwarder, control->symbolic_or_connid);
+  if (!conn) goto NACK;
+
+  connection_set_tags(conn, control->tags);
+
+#ifdef WITH_MAPME
+  /* Hook: connection event */
+  forwarder_on_connection_event(forwarder, conn, CONNECTION_EVENT_TAGS_CHANGED);
+#endif /* WITH_MAPME */
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+#endif /* WITH_POLICY */
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+/* Route */
+
+uint8_t *configuration_on_route_add(forwarder_t *forwarder, uint8_t *packet,
+                                    unsigned ingress_id, size_t *reply_size) {
+  INFO("CMD: route add (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_route_add_t *msg = (msg_route_add_t *)packet;
+  cmd_route_add_t *control = &msg->payload;
+
+  unsigned conn_id = symbolic_to_conn_id_self(
+      forwarder, control->symbolic_or_connid, ingress_id);
+  if (!connection_id_is_valid(conn_id)) goto NACK;
+
+  ip_prefix_t prefix = {.family = control->family,
+                        .address = control->address,
+                        .len = control->len};
+
+  if (!forwarder_add_or_update_route(forwarder, &prefix, conn_id)) goto NACK;
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_route_remove(forwarder_t *forwarder, uint8_t *packet,
+                                       unsigned ingress_id,
+                                       size_t *reply_size) {
+  INFO("CMD: route remove (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_route_remove_t *msg = (msg_route_remove_t *)packet;
+  cmd_route_remove_t *control = &msg->payload;
+
+  unsigned conn_id =
+      symbolic_to_conn_id(forwarder, control->symbolic_or_connid);
+  if (!connection_id_is_valid(conn_id)) goto NACK;
+
+  ip_prefix_t prefix = {.family = control->family,
+                        .address = control->address,
+                        .len = control->len};
+
+  if (!forwarder_remove_route(forwarder, &prefix, conn_id)) goto NACK;
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_route_list(forwarder_t *forwarder, uint8_t *packet,
+                                     unsigned ingress_id, size_t *reply_size) {
+  INFO("CMD: route list (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  msg_route_list_t *msg_received = (msg_route_list_t *)packet;
+  uint8_t command_id = msg_received->header.command_id;
+  uint32_t seq_num = msg_received->header.seq_num;
+  const fib_t *fib = forwarder_get_fib(forwarder);
+  fib_entry_t *entry;
+
+  /*
+   * Two step approach to precompute the number of entries to allocate
+   *
+   * NOTE: we might have routes with no or multiple next hops.
+   */
+  size_t n = 0;
+  fib_foreach_entry(fib, entry, {
+    const nexthops_t *nexthops = fib_entry_get_nexthops(entry);
+    assert(nexthops_get_len(nexthops) == nexthops_get_curlen(nexthops));
+    n += nexthops_get_len(nexthops);
+  });
+
+  msg_route_list_reply_t *msg;
+  msg_malloc_list(msg, command_id, n, seq_num);
+  if (!msg) goto NACK;
+
+  cmd_route_list_item_t *payload = &msg->payload;
+  fib_foreach_entry(fib, entry, {
+    const nexthops_t *nexthops = fib_entry_get_nexthops(entry);
+    assert(nexthops_get_len(nexthops) == nexthops_get_curlen(nexthops));
+    size_t num_nexthops = nexthops_get_len(nexthops);
+
+    if (num_nexthops == 0) continue;
+
+    NameBitvector *prefix = name_GetContentName(fib_entry_get_prefix(entry));
+
+    unsigned nexthop;
+    nexthops_foreach(nexthops, nexthop, {
+      address_t address;
+      nameBitvector_ToAddress(prefix, &address);
+      switch (address_family(&address)) {
+        case AF_INET:
+          payload->family = AF_INET;
+          payload->address.v4.as_inaddr = address4_ip(&address);
+          break;
+        case AF_INET6:
+          payload->family = AF_INET6;
+          payload->address.v6.as_in6addr = address6_ip(&address);
+          break;
+        default:
+          break;
+      }
+      payload->connection_id = nexthop;
+      payload->len = nameBitvector_GetLength(prefix);
+      payload->cost = DEFAULT_COST;
+
+      payload++;
+    });
+  });
+
+  *reply_size = sizeof(msg->header) + n * sizeof(msg->payload);
+  return (uint8_t *)msg;
+
+NACK:
+  *reply_size = sizeof(msg_header_t);
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+/* Cache */
+
+uint8_t *configuration_on_cache_set_store(forwarder_t *forwarder,
+                                          uint8_t *packet, unsigned ingress_id,
+                                          size_t *reply_size) {
+  INFO("CMD: cache set store (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_cache_set_store_t *msg = (msg_cache_set_store_t *)packet;
+  cmd_cache_set_store_t *control = &msg->payload;
+
+  if ((control->activate != 0) && (control->activate != 1)) goto NACK;
+  bool value = (bool)control->activate;
+
+  forwarder_cs_set_store(forwarder, value);
+  assert(forwarder_cs_get_store(forwarder) == value);
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_cache_set_serve(forwarder_t *forwarder,
+                                          uint8_t *packet, unsigned ingress_id,
+                                          size_t *reply_size) {
+  INFO("CMD: cache set serve (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_cache_set_serve_t *msg = (msg_cache_set_serve_t *)packet;
+  cmd_cache_set_serve_t *control = &msg->payload;
+
+  if ((control->activate != 0) && (control->activate != 1)) goto NACK;
+  bool value = (bool)control->activate;
+
+  forwarder_cs_set_serve(forwarder, value);
+  assert(forwarder_cs_get_serve(forwarder) == value);
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_cache_clear(forwarder_t *forwarder, uint8_t *packet,
+                                      unsigned ingress_id, size_t *reply_size) {
+  INFO("CMD: cache clear (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_cache_clear_t *msg = (msg_cache_clear_t *)packet;
+
+  forwarder_cs_clear(forwarder);
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_cache_list(forwarder_t *forwarder, uint8_t *packet,
+                                     unsigned ingress_id, size_t *reply_size) {
+  INFO("CMD: cache list (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  msg_cache_list_t *msg_received = (msg_cache_list_t *)packet;
+  uint32_t seq_num = msg_received->header.seq_num;
+
+  msg_cache_list_reply_t *msg = malloc(sizeof(*msg));
+  *msg = (msg_cache_list_reply_t){
+      .header = {.message_type = RESPONSE_LIGHT,
+                 .length = 1,
+                 .seq_num = seq_num},
+      .payload = {
+          .store_in_cs = forwarder_cs_get_store(forwarder),
+          .serve_from_cs = forwarder_cs_get_serve(forwarder),
+          .cs_size = forwarder_cs_get_size(forwarder),
+          .num_stale_entries = forwarder_cs_get_num_stale_entries(forwarder)}};
+
+  *reply_size = sizeof(*msg);
+  return (uint8_t *)msg;
+}
+
+/* Strategy */
+
+uint8_t *configuration_on_strategy_set(forwarder_t *forwarder, uint8_t *packet,
+                                       unsigned ingress_id,
+                                       size_t *reply_size) {
+  INFO("CMD: strategy set (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_strategy_set_t *msg = (msg_strategy_set_t *)packet;
+  cmd_strategy_set_t *control = &msg->payload;
+
+  char prefix_s[MAXSZ_IP_PREFIX];
+  ip_prefix_t prefix = {
+      .family = control->family,
+      .address = control->address,
+      .len = control->len,
+  };
+  int rc = ip_prefix_snprintf(prefix_s, MAXSZ_IP_PREFIX, &prefix);
+  assert(rc < MAXSZ_IP_PREFIX);
+  if (rc < 0) goto NACK;
+
+  strategy_type_t strategy = control->type;
+  configuration_t *config = forwarder_get_configuration(forwarder);
+  strategy_type_t existingFwdStrategy =
+      configuration_get_strategy(config, prefix_s);
+  strategy_options_t *options = NULL;
+
+  Name name_prefix = EMPTY_NAME;
+  name_CreateFromAddress(&name_prefix, control->family, control->address,
+                         control->len);
+
+  // The strategy is not present in the hash table
+  // or has to be updated or to be restarted
+  if (existingFwdStrategy == STRATEGY_TYPE_UNDEFINED ||
+      strategy != existingFwdStrategy ||
+      (strategy == existingFwdStrategy && strategy == STRATEGY_TYPE_BESTPATH)) {
+    configuration_set_strategy(config, prefix_s, strategy);
+
+    forwarder_set_strategy(forwarder, &name_prefix, strategy, options);
+  } else {
+    WITH_WARN({
+      char *nameString = name_ToString(&name_prefix);
+      WARN("Strategy for prefix %s not updated", nameString);
+      free(nameString);
+    })
+  }
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_strategy_add_local_prefix(forwarder_t *forwarder,
+                                                    uint8_t *packet,
+                                                    unsigned ingress_id,
+                                                    size_t *reply_size) {
+  INFO("CMD: strategy add local prefix (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_strategy_add_local_prefix_t *msg =
+      (msg_strategy_add_local_prefix_t *)packet;
+  cmd_strategy_add_local_prefix_t *control = &msg->payload;
+
+  char prefix_s[MAXSZ_IP_PREFIX];
+  ip_prefix_t prefix = {
+      .family = control->family,
+      .address = control->address,
+      .len = control->len,
+  };
+  int rc = ip_prefix_snprintf(prefix_s, MAXSZ_IP_PREFIX, &prefix);
+  assert(rc < MAXSZ_IP_PREFIX);
+  if (rc < 0) goto NACK;
+
+  strategy_type_t strategy = control->type;
+  configuration_t *config = forwarder_get_configuration(forwarder);
+  strategy_type_t existingFwdStrategy =
+      configuration_get_strategy(config, prefix_s);
+
+  if (strategy != existingFwdStrategy) goto NACK;
+
+  if (strategy != STRATEGY_TYPE_BESTPATH &&
+      strategy != STRATEGY_TYPE_REPLICATION)
+    goto NACK;
+
+  Name name_prefix = EMPTY_NAME;
+  name_CreateFromAddress(&name_prefix, control->family, control->address,
+                         control->len);
+
+  strategy_options_t options;
+  Name local_prefix = EMPTY_NAME;
+  name_CreateFromAddress(&local_prefix, control->local_family,
+                         control->local_address, control->local_len);
+
+  // for the moment bestpath and replication are the same but we distinguish the
+  // two in case they will diverge in the future
+  if (strategy == STRATEGY_TYPE_BESTPATH) {
+    options.bestpath.local_prefixes = create_local_prefixes();
+    local_prefixes_add_prefix(options.bestpath.local_prefixes, &local_prefix);
+  } else {
+    options.replication.local_prefixes = create_local_prefixes();
+    local_prefixes_add_prefix(options.replication.local_prefixes,
+                              &local_prefix);
+  }
+
+  forwarder_add_strategy_options(forwarder, &name_prefix, strategy, &options);
+
+  free_local_prefixes(options.bestpath.local_prefixes);
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+/* WLDR */
+
+uint8_t *configuration_on_wldr_set(forwarder_t *forwarder, uint8_t *packet,
+                                   unsigned ingress_id, size_t *reply_size) {
+  assert(forwarder);
+  assert(packet);
+
+  msg_wldr_set_t *msg = (msg_wldr_set_t *)packet;
+  cmd_wldr_set_t *control = &msg->payload;
+
+  if ((control->activate != 0) && (control->activate != 1)) goto NACK;
+  bool value = (bool)control->activate;
+
+  unsigned conn_id =
+      symbolic_to_conn_id(forwarder, control->symbolic_or_connid);
+  if (!connection_id_is_valid(conn_id)) goto NACK;
+
+  connection_table_t *table = forwarder_get_connection_table(forwarder);
+  connection_t *conn = connection_table_at(table, conn_id);
+
+  if (value) connection_wldr_enable(conn, value);
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+/* Punting */
+
+uint8_t *configuration_on_punting_add(forwarder_t *forwarder, uint8_t *packet,
+                                      unsigned ingress_id, size_t *reply_size) {
+  // #if !defined(__APPLE__) && !defined(_WIN32) && defined(PUNTING)
+  msg_punting_add_t *msg = (msg_punting_add_t *)packet;
+
+#if !defined(__APPLE__) && !defined(_WIN32) && defined(PUNTING)
+  cmd_punting_add_t *control = &msg->payload;
+  if (ip_address_empty(&control->address)) goto NACK;
+
+  /* This is for hICN listeners only */
+  // XXX add check !
+  // comments:
+  // EncapType: I use the Hicn encap since the punting is available only for
+  // Hicn listeners LocalAddress: The only listern for which we need punting
+  // rules is the main one, which has no address
+  //              so I create a fake empty address. This need to be consistent
+  //              with the address set at creation time
+  address_t fakeaddr;
+  memset(&fakeaddr, 0, sizeof(address_t));
+  fakeaddr = ADDRESS_ANY(control->family, DEFAULT_PORT);
+
+  listener_table_t *table = forwarder_get_listener_table(forwarder);
+  listener_t *listener =
+      listener_table_get_by_address(table, FACE_TYPE_HICN, &fakeaddr);
+  if (!listener) {
+    ERROR("the main listener does not exist");
+    goto NACK;
+  }
+
+  ip_prefix_t prefix = {.family = control->family,
+                        .address = control->address,
+                        .len = control->len};
+  char prefix_s[MAXSZ_IP_PREFIX];
+  int rc = ip_prefix_snprintf(prefix_s, MAXSZ_IP_PREFIX, &prefix);
+  assert(rc < MAXSZ_IP_PREFIX);
+  if (rc < 0) goto NACK;
+
+  if (listener_punt(listener, prefix_s) < 0) {
+    ERROR("error while adding the punting rule");
+    goto NACK;
+  }
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+#endif
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+/* MAP-Me */
+
+#ifdef WITH_MAPME
+uint8_t *configuration_on_mapme_enable(forwarder_t *forwarder, uint8_t *packet,
+                                       unsigned ingress_id,
+                                       size_t *reply_size) {
+  INFO("CMD: mapme enable (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_mapme_enable_t *msg = (msg_mapme_enable_t *)packet;
+  cmd_mapme_enable_t *control = &msg->payload;
+
+  if ((control->activate != 0) && (control->activate != 1)) goto NACK;
+  bool value = (bool)control->activate;
+
+  INFO("MAP-Me SET enable: %s", value ? "on" : "off");
+  mapme_t *mapme = forwarder_get_mapme(forwarder);
+  if (!mapme) goto NACK;
+  mapme_set_enable(mapme, value);
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_mapme_set_discovery(forwarder_t *forwarder,
+                                              uint8_t *packet,
+                                              unsigned ingress_id,
+                                              size_t *reply_size) {
+  INFO("CMD: mapme discovery (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_mapme_set_discovery_t *msg = (msg_mapme_set_discovery_t *)packet;
+  cmd_mapme_set_discovery_t *control = &msg->payload;
+
+  if ((control->activate != 0) && (control->activate != 1)) goto NACK;
+  bool value = (bool)control->activate;
+
+  INFO("MAP-Me SET discovery: %s", value ? "on" : "off");
+  mapme_t *mapme = forwarder_get_mapme(forwarder);
+  if (!mapme) goto NACK;
+  mapme_set_discovery(mapme, value);
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_mapme_set_timescale(forwarder_t *forwarder,
+                                              uint8_t *packet,
+                                              unsigned ingress_id,
+                                              size_t *reply_size) {
+  INFO("CMD: mapme timescale (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_mapme_set_timescale_t *msg = (msg_mapme_set_timescale_t *)packet;
+  cmd_mapme_set_timescale_t *control = &msg->payload;
+
+  INFO("MAP-Me SET timescale: %u", control->timePeriod);
+  mapme_t *mapme = forwarder_get_mapme(forwarder);
+  if (!mapme) goto NACK;
+  mapme_set_timescale(mapme, control->timePeriod);
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_mapme_set_retx(forwarder_t *forwarder,
+                                         uint8_t *packet, unsigned ingress_id,
+                                         size_t *reply_size) {
+  INFO("CMD: mapme retransmission (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_mapme_set_retx_t *msg = (msg_mapme_set_retx_t *)packet;
+  cmd_mapme_set_retx_t *control = &msg->payload;
+
+  INFO("MAP-Me SET retx: %u", control->timePeriod);
+  mapme_t *mapme = forwarder_get_mapme(forwarder);
+  if (!mapme) goto NACK;
+  mapme_set_retransmision(mapme, control->timePeriod);
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_mapme_send_update(forwarder_t *forwarder,
+                                            uint8_t *packet,
+                                            unsigned ingress_id,
+                                            size_t *reply_size) {
+  assert(forwarder);
+  assert(packet);
+
+  INFO("CMD: mapme send update (ingress=%d)", ingress_id);
+  msg_mapme_send_update_t *msg = (msg_mapme_send_update_t *)packet;
+
+  *reply_size = sizeof(msg_header_t);
+
+  fib_t *fib = forwarder_get_fib(forwarder);
+  if (!fib) goto NACK;
+
+  mapme_t *mapme = forwarder_get_mapme(forwarder);
+
+  /*
+   * The command triggers a mapme update for all prefixes produced on this face
+   * */
+  fib_entry_t *entry;
+  fib_foreach_entry(fib, entry, {
+    const nexthops_t *nexthops = fib_entry_get_nexthops(entry);
+    unsigned nexthop;
+    nexthops_foreach(nexthops, nexthop, {
+      if (nexthop != ingress_id) continue;
+      /* This entry points to the producer face */
+      mapme_set_all_adjacencies(mapme, entry);
+      break;
+    });
+  });
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+#endif /* WITH_MAPME */
+
+/* Policy */
+
+uint8_t *configuration_on_policy_add(forwarder_t *forwarder, uint8_t *packet,
+                                     unsigned ingress_id, size_t *reply_size) {
+  assert(forwarder);
+  assert(packet);
+
+#ifdef WITH_POLICY
+  msg_policy_add_t *msg = (msg_policy_add_t *)packet;
+  cmd_policy_add_t *control = &msg->payload;
+
+  ip_prefix_t prefix = {.family = control->family,
+                        .address = control->address,
+                        .len = control->len};
+
+  if (!forwarder_add_or_update_policy(forwarder, &prefix, &control->policy))
+    goto NACK;
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+#endif /* WITH_POLICY */
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_policy_remove(forwarder_t *forwarder, uint8_t *packet,
+                                        unsigned ingress_id,
+                                        size_t *reply_size) {
+  assert(forwarder);
+  assert(packet);
+
+#ifdef WITH_POLICY
+  msg_policy_remove_t *msg = (msg_policy_remove_t *)packet;
+  cmd_policy_remove_t *control = &msg->payload;
+
+  ip_prefix_t prefix = {.family = control->family,
+                        .address = control->address,
+                        .len = control->len};
+
+  if (!forwarder_remove_policy(forwarder, &prefix)) goto NACK;
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+#endif /* WITH_POLICY */
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_policy_list(forwarder_t *forwarder, uint8_t *packet,
+                                      unsigned ingress_id, size_t *reply_size) {
+  assert(forwarder);
+  assert(packet);
+
+  const fib_t *fib = forwarder_get_fib(forwarder);
+  assert(fib);
+  size_t n = fib_get_size(fib);
+
+#ifdef WITH_POLICY
+  msg_policy_list_t *msg_received = (msg_policy_list_t *)packet;
+  uint8_t command_id = msg_received->header.command_id;
+  uint32_t seq_num = msg_received->header.seq_num;
+
+  msg_policy_list_reply_t *msg;
+  msg_malloc_list(msg, command_id, n, seq_num);
+  if (!msg) goto NACK;
+
+  cmd_policy_list_item_t *payload = &msg->payload;
+
+  fib_entry_t *entry;
+
+  fib_foreach_entry(fib, entry, {
+    NameBitvector *prefix = name_GetContentName(fib_entry_get_prefix(entry));
+    address_t address;
+    nameBitvector_ToAddress(prefix, &address);
+
+    switch (address_family(&address)) {
+      case AF_INET:
+        payload->family = AF_INET;
+        payload->address.v4.as_inaddr = address4_ip(&address);
+        break;
+
+      case AF_INET6:
+        payload->family = AF_INET6;
+        payload->address.v6.as_in6addr = address6_ip(&address);
+        break;
+
+      default:
+        break;
+    }
+    payload->len = nameBitvector_GetLength(prefix);
+    payload->policy = fib_entry_get_policy(entry);
+
+    payload++;
+  });
+
+  return (uint8_t *)msg;
+#endif /* WITH_POLICY */
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+/* Subscription */
+
+uint8_t *configuration_on_subscription_add(forwarder_t *forwarder,
+                                           uint8_t *packet, unsigned ingress_id,
+                                           size_t *reply_size) {
+  INFO("CMD: subscription add (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_subscription_add_t *msg = (msg_subscription_add_t *)packet;
+  cmd_subscription_add_t *control = &msg->payload;
+  hc_topics_t topics = control->topics;
+
+  subscription_table_t *subscriptions = forwarder_get_subscriptions(forwarder);
+  assert(subscriptions);
+
+  int ret = subscription_table_add_topics_for_connection(subscriptions, topics,
+                                                         ingress_id);
+  if (ret < 0) goto NACK;
+
+  WITH_DEBUG(subscription_table_print(subscriptions);)
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+
+NACK:
+  make_nack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *configuration_on_subscription_remove(forwarder_t *forwarder,
+                                              uint8_t *packet,
+                                              unsigned ingress_id,
+                                              size_t *reply_size) {
+  INFO("CMD: subscription remove (ingress=%d)", ingress_id);
+  assert(forwarder);
+  assert(packet);
+
+  *reply_size = sizeof(msg_header_t);
+  msg_subscription_add_t *msg = (msg_subscription_add_t *)packet;
+  cmd_subscription_add_t *control = &msg->payload;
+  hc_topics_t topics = control->topics;
+
+  subscription_table_t *subscriptions = forwarder_get_subscriptions(forwarder);
+  assert(subscriptions);
+
+  subscription_table_remove_topics_for_connection(subscriptions, topics,
+                                                  ingress_id);
+  WITH_DEBUG(subscription_table_print(subscriptions);)
+
+  make_ack(msg);
+  return (uint8_t *)msg;
+}
+
+uint8_t *command_process(forwarder_t *forwarder, uint8_t *packet,
+                         command_type_t command_type, unsigned ingress_id,
+                         size_t *reply_size) {
+  uint8_t *reply = NULL;
+
+  /*
+   * For most commands, the packet will simply be transformed into an ack.
+   * For list commands, a new message will be allocated, and the return value
+   * might eventually be NULL in case of an error. That is why the free the
+   * reply at the end in these circumstances.
+   *
+   * XXX rework this part.
+   */
+  switch (command_type) {
+#define _(l, u)                                                              \
+  case COMMAND_TYPE_##u:                                                     \
+    reply = configuration_on_##l(forwarder, packet, ingress_id, reply_size); \
+    assert(reply);                                                           \
+    break;
+    foreach_command_type
+#undef _
+        case COMMAND_TYPE_UNDEFINED : case COMMAND_TYPE_N
+        : ERROR("Unexpected command type");
+    reply = packet;
+    make_nack(reply);
+    if (reply_size) *reply_size = sizeof(msg_header_t);
+    break;
+  }
+
+  return reply;
+}
+
+ssize_t command_process_msgbuf(forwarder_t *forwarder, msgbuf_t *msgbuf) {
+  assert(forwarder);
+  assert(msgbuf);
+
+  uint8_t *packet = msgbuf_get_packet(msgbuf);
+  unsigned ingress_id = msgbuf_get_connection_id(msgbuf);
+
+  uint8_t *reply = NULL;
+  size_t reply_size = 0;
+
+  command_type_t command_type = msgbuf_get_command_type(msgbuf);
+
+  reply =
+      command_process(forwarder, packet, command_type, ingress_id, &reply_size);
+  if (connection_id_is_valid(msgbuf->connection_id)) {
+    connection_table_t *table = forwarder_get_connection_table(forwarder);
+    const connection_t *connection = connection_table_at(table, ingress_id);
+    connection_send_packet(connection, reply, reply_size);
+  }
+
+  switch (msgbuf->command.type) {
+    case COMMAND_TYPE_LISTENER_LIST:
+    case COMMAND_TYPE_CONNECTION_LIST:
+    case COMMAND_TYPE_ROUTE_LIST:
+    case COMMAND_TYPE_POLICY_LIST:
+      /* Free replies that have been allocated (not NACK's) */
+      if (((msg_header_t *)reply)->header.message_type != NACK_LIGHT)
+        free(reply);
+      break;
+    default:
+      break;
+  }
+
+  return msgbuf_get_len(msgbuf);
+}
diff --git a/hicn-light/src/hicn/config/commands.h b/hicn-light/src/hicn/config/commands.h
new file mode 100644
index 000000000..cedf4de01
--- /dev/null
+++ b/hicn-light/src/hicn/config/commands.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file commands.h
+ * @brief hicn-light configuration, such as in-band commands or CLI
+ *
+ * Manages all user configuration of the system, such as from the CLI or web
+ * interface It remembers the user commands and will be able to write out a
+ * config file.
+ *
+ */
+
+#ifndef HICNLIGHT_COMMANDS_H
+#define HICNLIGHT_COMMANDS_H
+
+#include "../core/msgbuf.h"
+#include "../core/strategy.h"
+#include <hicn/ctrl/api.h>
+#include <hicn/ctrl/hicn-light-ng.h>
+
+uint8_t *command_process(forwarder_t *forwarder, uint8_t *packet,
+                         command_type_t command_type, unsigned ingress_id,
+                         size_t *reply_size);
+
+ssize_t command_process_msgbuf(forwarder_t *forwarder, msgbuf_t *msgbuf);
+
+uint8_t *configuration_on_listener_add(forwarder_t *forwarder, uint8_t *packet,
+                                       unsigned ingress_id, size_t *reply_size);
+
+uint8_t *configuration_on_listener_remove(forwarder_t *forwarder,
+                                          uint8_t *packet, unsigned ingress_id,
+                                          size_t *reply_size);
+
+uint8_t *configuration_on_listener_list(forwarder_t *forwarder, uint8_t *packet,
+                                        unsigned ingress_id,
+                                        size_t *reply_size);
+
+uint8_t *configuration_on_connection_add(forwarder_t *forwarder,
+                                         uint8_t *packet, unsigned ingress_id,
+                                         size_t *reply_size);
+
+uint8_t *configuration_on_connection_remove(forwarder_t *forwarder,
+                                            uint8_t *packet,
+                                            unsigned ingress_id,
+                                            size_t *reply_size);
+
+uint8_t *configuration_on_connection_list(forwarder_t *forwarder,
+                                          uint8_t *packet, unsigned ingress_id,
+                                          size_t *reply_size);
+
+uint8_t *configuration_on_connection_set_admin_state(forwarder_t *forwarder,
+                                                     uint8_t *packet,
+                                                     unsigned ingress_id,
+                                                     size_t *reply_size);
+
+uint8_t *configuration_on_connection_update(forwarder_t *forwarder,
+                                            uint8_t *packet,
+                                            unsigned ingress_id,
+                                            size_t *reply_size);
+
+uint8_t *configuration_on_connection_set_priority(forwarder_t *forwarder,
+                                                  uint8_t *packet,
+                                                  unsigned ingress_id,
+                                                  size_t *reply_size);
+
+uint8_t *configuration_on_connection_set_tags(forwarder_t *forwarder,
+                                              uint8_t *packet,
+                                              unsigned ingress_id,
+                                              size_t *reply_size);
+
+uint8_t *configuration_on_route_add(forwarder_t *forwarder, uint8_t *packet,
+                                    unsigned ingress_id, size_t *reply_size);
+
+uint8_t *configuration_on_route_remove(forwarder_t *forwarder, uint8_t *packet,
+                                       unsigned ingress_id, size_t *reply_size);
+
+uint8_t *configuration_on_route_list(forwarder_t *forwarder, uint8_t *packet,
+                                     unsigned ingress_id, size_t *reply_size);
+
+uint8_t *configuration_on_cache_set_store(forwarder_t *forwarder,
+                                          uint8_t *packet, unsigned ingress_id,
+                                          size_t *reply_size);
+
+uint8_t *configuration_on_cache_set_serve(forwarder_t *forwarder,
+                                          uint8_t *packet, unsigned ingress_id,
+                                          size_t *reply_size);
+
+uint8_t *configuration_on_cache_clear(forwarder_t *forwarder, uint8_t *packet,
+                                      unsigned ingress_id, size_t *reply_size);
+
+uint8_t *configuration_on_strategy_set(forwarder_t *forwarder, uint8_t *packet,
+                                       unsigned ingress_id, size_t *reply_size);
+
+uint8_t *configuration_on_strategy_add_local_prefix(forwarder_t *forwarder,
+                                                    uint8_t *packet,
+                                                    unsigned ingress_id,
+                                                    size_t *reply_size);
+
+uint8_t *configuration_on_wldr_set(forwarder_t *forwarder, uint8_t *packet,
+                                   unsigned ingress_id, size_t *reply_size);
+
+uint8_t *configuration_on_punting_add(forwarder_t *forwarder, uint8_t *packet,
+                                      unsigned ingress_id, size_t *reply_size);
+
+#ifdef WITH_MAPME
+uint8_t *configuration_on_mapme_enable(forwarder_t *forwarder, uint8_t *packet,
+                                       unsigned ingress_id, size_t *reply_size);
+
+uint8_t *configuration_on_mapme_set_discovery(forwarder_t *forwarder,
+                                              uint8_t *packet,
+                                              unsigned ingress_id,
+                                              size_t *reply_size);
+
+uint8_t *configuration_on_mapme_set_timescale(forwarder_t *forwarder,
+                                              uint8_t *packet,
+                                              unsigned ingress_id,
+                                              size_t *reply_size);
+
+uint8_t *configuration_on_mapme_set_retx(forwarder_t *forwarder,
+                                         uint8_t *packet, unsigned ingress_id,
+                                         size_t *reply_size);
+
+uint8_t *configuration_on_mapme_send_update(forwarder_t *forwarder,
+                                            uint8_t *packet,
+                                            unsigned ingress_id,
+                                            size_t *reply_size);
+#endif /* WITH_MAPME */
+
+uint8_t *configuration_on_policy_add(forwarder_t *forwarder, uint8_t *packet,
+                                     unsigned ingress_id, size_t *reply_size);
+
+uint8_t *configuration_on_policy_remove(forwarder_t *forwarder, uint8_t *packet,
+                                        unsigned ingress_id,
+                                        size_t *reply_size);
+
+uint8_t *configuration_on_policy_list(forwarder_t *forwarder, uint8_t *packet,
+                                      unsigned ingress_id, size_t *reply_size);
+
+#endif  // HICNLIGHT_COMMANDS_H
diff --git a/hicn-light/src/hicn/config/configuration.c b/hicn-light/src/hicn/config/configuration.c
index e414f05e3..9123ceebf 100644
--- a/hicn-light/src/hicn/config/configuration.c
+++ b/hicn-light/src/hicn/config/configuration.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -26,1504 +26,169 @@
 #include <unistd.h>
 #endif
 #include <ctype.h>
-#include <parc/assert/parc_Assert.h>
 #include <hicn/hicn-light/config.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include <parc/algol/parc_HashMap.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_String.h>
-
-#include <hicn/config/configurationListeners.h>
-#include <hicn/config/symbolicNameTable.h>
-
 #include <hicn/core/connection.h>
-#include <hicn/core/connectionTable.h>
+#include <hicn/core/connection_table.h>
 #include <hicn/core/forwarder.h>
-#include <hicn/core/system.h>
+//#include <hicn/core/system.h>
 #ifdef WITH_MAPME
 #include <hicn/core/mapme.h>
 #endif /* WITH_MAPME */
 
-#include <hicn/io/streamConnection.h>
-
-#include <hicn/io/hicnTunnel.h>
-#include <hicn/io/tcpTunnel.h>
-#include <hicn/io/udpTunnel.h>
+#include <hicn/core/listener.h>  //the listener list
+#include <hicn/core/listener_table.h>
+#include <hicn/ctrl/hicn-light-ng.h>
+#include <hicn/utils/punting.h>
+#include <hicn/util/log.h>
+#include <hicn/face.h>
 
-#include <parc/algol/parc_Unsigned.h>
-#include <hicn/io/listener.h>     //the listener list
-#include <hicn/io/listenerSet.h>  //   needed to print
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-#include <hicn/utils/address.h>
+#include "configuration.h"
 
 #define ETHERTYPE 0x0801
-
-struct configuration {
-  Forwarder *forwarder;
-  Logger *logger;
-
-  size_t maximumContentObjectStoreSize;
-
-  // map from prefix (parcString) to strategy (parcString)
-  PARCHashMap *strategy_map;
-
-  // translates between a symblic name and a connection id
-  SymbolicNameTable *symbolicNameTable;
+#define DEFAULT_COST 1
+#define DEFAULT_PORT 1234
+#define DEFAULT_LOGLEVEL "info"
+#define DEFAULT_CS_CAPACITY 100000
+
+#define msg_malloc_list(msg, N, seq_number)                           \
+  do {                                                                \
+    msg = malloc(sizeof((msg)->header) + N * sizeof((msg)->payload)); \
+    (msg)->header.message_type = RESPONSE_LIGHT;                      \
+    (msg)->header.length = (uint16_t)(N);                             \
+    (msg)->header.seq_num = (seq_number);                             \
+  } while (0);
+
+struct configuration_s {
+  const char *fn_config;
+  uint16_t port;
+  uint16_t configuration_port;
+  size_t cs_capacity;
+  int loglevel;
+  const char *logfile;
+  int logfile_fd;
+  bool daemon;
+  kh_strategy_map_t *strategy_map;
 };
 
-// ========================================================================================
-
-Connection *
-getConnectionBySymbolicOrId(Configuration * config, const char * symbolicOrConnid)
-{
-  ConnectionTable *table = forwarder_GetConnectionTable(config->forwarder);
-  unsigned connid;
-  Connection *conn = NULL;
-
-  /* Try to resolve an eventual symbolic name as input */
-  if (utils_IsNumber(symbolicOrConnid)) {
-    connid = (unsigned int)strtold(symbolicOrConnid, NULL);
-
-  } else {
-    connid = symbolicNameTable_Get(config->symbolicNameTable, symbolicOrConnid);
-    if (connid == UINT32_MAX) {
-      if (logger_IsLoggable(config->logger, LoggerFacility_Config,
-                            PARCLogLevel_Warning)) {
-        logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Error,
-                   __func__, "Symbolic name '%s' could not be resolved",
-                   symbolicOrConnid);
-      }
-    }
-  }
-
-  /* Get connection by ID */
-  conn = (Connection *)connectionTable_FindById( table, connid);
-  if (!conn) {
-    if (logger_IsLoggable(config->logger, LoggerFacility_Config,
-                          PARCLogLevel_Warning)) {
-      logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Error,
-              __func__, "ConnID not found, check list connections");
-    }
-  }
-
-  return conn;
-}
-
-// ========================================================================================
-
-Configuration *configuration_Create(Forwarder *forwarder) {
-  parcAssertNotNull(forwarder, "Parameter hicn-fwd must be non-null");
-  Configuration *config = parcMemory_AllocateAndClear(sizeof(Configuration));
-  parcAssertNotNull(config, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Configuration));
-  config->forwarder = forwarder;
-  config->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-  config->maximumContentObjectStoreSize = 100000;
-  config->strategy_map = parcHashMap_Create();
-  config->symbolicNameTable = symbolicNameTable_Create();
-
-  return config;
-}
-
-void configuration_Destroy(Configuration **configPtr) {
-  parcAssertNotNull(configPtr, "Parameter must be non-null double poitner");
-  parcAssertNotNull(*configPtr,
-                    "Parameter must dereference to non-null pointer");
-
-  Configuration *config = *configPtr;
-  logger_Release(&config->logger);
-  parcHashMap_Release(&(config->strategy_map));
-  symbolicNameTable_Destroy(&config->symbolicNameTable);
-  parcMemory_Deallocate((void **)&config);
-  *configPtr = NULL;
-}
-
-struct iovec *configuration_ProcessRegisterHicnPrefix(Configuration *config,
-                                                      struct iovec *request,
-                                                      unsigned ingressId) {
-  header_control_message *header = request[0].iov_base;
-  add_route_command *control = request[1].iov_base;
-
-  bool success = false;
-
-  const char *symbolicOrConnid = control->symbolicOrConnid;
-
-  if (strcmp(symbolicOrConnid, "SELF") == 0) {
-    success = forwarder_AddOrUpdateRoute(config->forwarder, control, ingressId);
-  } else if (utils_IsNumber(symbolicOrConnid)) {
-    // case for connid as input
-    unsigned connid = (unsigned)strtold(symbolicOrConnid, NULL);
-    ConnectionTable *table = forwarder_GetConnectionTable(config->forwarder);
-
-    // check if iconnID present in the fwd table
-    if (connectionTable_FindById(table, connid)) {
-      success = forwarder_AddOrUpdateRoute(config->forwarder, control, connid);
-    } else {
-      logger_Log(forwarder_GetLogger(config->forwarder), LoggerFacility_IO,
-                 PARCLogLevel_Error, __func__,
-                 "ConnID not found, check list connections");
-      // failure
-    }
-
-  } else {
-    // case for symbolic as input: check if symbolic name can be resolved
-    unsigned connid =
-        symbolicNameTable_Get(config->symbolicNameTable, symbolicOrConnid);
-    // connid = UINT_MAX when symbolicName is not found
-    if (connid != UINT32_MAX) {
-      if (logger_IsLoggable(config->logger, LoggerFacility_Config,
-                            PARCLogLevel_Debug)) {
-        logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Debug,
-                   __func__, "Add route resolve name '%s' to connid %u",
-                   symbolicOrConnid, connid);
-      }
-
-      success = forwarder_AddOrUpdateRoute(config->forwarder, control, connid);
-
-    } else {
-      if (logger_IsLoggable(config->logger, LoggerFacility_Config,
-                            PARCLogLevel_Warning)) {
-        logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Warning,
-                   __func__,
-                   "Add route symbolic name '%s' could not be resolved",
-                   symbolicOrConnid);
-      }
-      // failure
-    }
-  }
-
-  // generate ACK/NACK
-  struct iovec *response;
-
-  if (success) {  // ACK
-    response = utils_CreateAck(header, control, sizeof(add_route_command));
-  } else {  // NACK
-    response = utils_CreateNack(header, control, sizeof(add_route_command));
-  }
-
-  return response;
-}
-
-struct iovec *configuration_ProcessUnregisterHicnPrefix(Configuration *config,
-                                                        struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  remove_route_command *control = request[1].iov_base;
-
-  bool success = false;
-
-  const char *symbolicOrConnid = control->symbolicOrConnid;
-
-  if (utils_IsNumber(symbolicOrConnid)) {
-    // case for connid as input
-    unsigned connid = (unsigned)strtold(symbolicOrConnid, NULL);
-    ConnectionTable *table = forwarder_GetConnectionTable(config->forwarder);
-
-    // check if interface index present in the fwd table
-    if (connectionTable_FindById(table, connid)) {
-      success = forwarder_RemoveRoute(config->forwarder, control, connid);
-    } else {
-      logger_Log(forwarder_GetLogger(config->forwarder), LoggerFacility_IO,
-                 PARCLogLevel_Error, __func__,
-                 "ConnID not found, check list connections");
-      // failure
-    }
-
-  } else {
-    // case for symbolic as input: chech if symbolic name can be resolved
-    unsigned connid =
-        symbolicNameTable_Get(config->symbolicNameTable, symbolicOrConnid);
-    // connid = UINT_MAX when symbolicName is not found
-    if (connid != UINT32_MAX) {
-      if (logger_IsLoggable(config->logger, LoggerFacility_Config,
-                            PARCLogLevel_Debug)) {
-        logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Debug,
-                   __func__, "Remove route resolve name '%s' to connid %u",
-                   symbolicOrConnid, connid);
-      }
-      success = forwarder_RemoveRoute(config->forwarder, control, connid);
-    } else {
-      if (logger_IsLoggable(config->logger, LoggerFacility_Config,
-                            PARCLogLevel_Warning)) {
-        logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Warning,
-                   __func__,
-                   "Remove route symbolic name '%s' could not be resolved",
-                   symbolicOrConnid);
-      }
-      // failure
-    }
-  }
-
-  // generate ACK/NACK
-  struct iovec *response;
-
-  if (success) {  // ACK
-    response = utils_CreateAck(header, control, sizeof(remove_route_command));
-  } else {  // NACK
-    response = utils_CreateNack(header, control, sizeof(remove_route_command));
-  }
-
-  return response;
-}
-
-struct iovec *configuration_ProcessRegistrationList(Configuration *config,
-                                                    struct iovec *request) {
-  FibEntryList *fibList = forwarder_GetFibEntries(config->forwarder);
-
-  size_t payloadSize = fibEntryList_Length(fibList);
-  size_t effective_payloadSize = 0;
-  size_t pointerLocation = 0;
-  struct sockaddr_in tmpAddr;
-  struct sockaddr_in6 tmpAddr6;
-
-  // allocate payload, cast from void* to uint8_t* = bytes granularity
-  uint8_t *payloadResponse =
-      parcMemory_AllocateAndClear(sizeof(list_routes_command) * payloadSize);
-
-  for (size_t i = 0; i < fibEntryList_Length(fibList); i++) {
-    FibEntry *entry = (FibEntry *)fibEntryList_Get(fibList, i);
-    NameBitvector *prefix = name_GetContentName(fibEntry_GetPrefix(entry));
-    const NumberSet *nexthops = fibEntry_GetNexthops(entry);
-
-    if (numberSet_Length(nexthops) == 0)
-        continue;
-
-    if (numberSet_Length(nexthops) > 1) {
-      // payload extended, need reallocate, further entries via nexthops
-      payloadSize = payloadSize + numberSet_Length(nexthops) - 1;
-      payloadResponse = (uint8_t *) parcMemory_Reallocate(
-          payloadResponse, sizeof(list_routes_command) * payloadSize);
-    }
-
-    for (size_t j = 0; j < numberSet_Length(nexthops); j++) {
-      list_routes_command *listRouteCommand =
-          (list_routes_command *)(payloadResponse +
-                                  (pointerLocation *
-                                   sizeof(list_routes_command)));
-
-      Address *addressEntry = nameBitvector_ToAddress(prefix);
-      if (addressGetType(addressEntry) == ADDR_INET) {
-        addressGetInet(addressEntry, &tmpAddr);
-        listRouteCommand->addressType = ADDR_INET;
-        listRouteCommand->address.v4.as_inaddr = tmpAddr.sin_addr;
-      } else if (addressGetType(addressEntry) == ADDR_INET6) {
-        addressGetInet6(addressEntry, &tmpAddr6);
-        listRouteCommand->addressType = ADDR_INET6;
-        listRouteCommand->address.v6.as_in6addr = tmpAddr6.sin6_addr;
-      }
-      listRouteCommand->connid = numberSet_GetItem(nexthops, j);
-      listRouteCommand->len = nameBitvector_GetLength(prefix);
-      listRouteCommand->cost = 1;  // cost
-
-      pointerLocation++;
-      effective_payloadSize++;
-      addressDestroy(&addressEntry);
-    }
-  }
-
-  // send response
-  header_control_message *header = request[0].iov_base;
-  header->messageType = RESPONSE_LIGHT;
-  header->length = (unsigned)effective_payloadSize;
-
-  struct iovec *response =
-      parcMemory_AllocateAndClear(sizeof(struct iovec) * 2);
-
-  response[0].iov_base = header;
-  response[0].iov_len = sizeof(header_control_message);
-  response[1].iov_base = payloadResponse;
-  response[1].iov_len = sizeof(list_routes_command) * effective_payloadSize;
-
-  fibEntryList_Destroy(&fibList);
-  return response;
-}
-
-static void configuration_SendResponse(Configuration *config, struct iovec *msg,
-                                       unsigned egressId) {
-  ConnectionTable *connectionTable =
-      forwarder_GetConnectionTable(config->forwarder);
-  const Connection *conn = connectionTable_FindById(connectionTable, egressId);
-
-  if (conn == NULL) {
-    return;
-  }
-  connection_SendIOVBuffer(conn, msg, 2);
-}
-
-struct iovec *configuration_ProcessCreateTunnel(Configuration *config,
-                                                struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  add_connection_command *control = request[1].iov_base;
-
-  bool success = false;
-
-  Connection *conn;
-  const char *symbolicName = control->symbolic;
-
-  Address *source = NULL;
-  Address *destination = NULL;
-
-  if (symbolicNameTable_Exists(config->symbolicNameTable, symbolicName)) {
-      logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Error,
-              __func__, "Connection symbolic name already exists");
-      goto ERR;
-  }
-
-  if (control->ipType == ADDR_INET) {
-    source =
-        addressFromInaddr4Port(&control->localIp.v4.as_u32, &control->localPort);
-    destination =
-        addressFromInaddr4Port(&control->remoteIp.v4.as_u32, &control->remotePort);
-  } else if (control->ipType == ADDR_INET6) {
-    source =
-        addressFromInaddr6Port(&control->localIp.v6.as_in6addr, &control->localPort);
-    destination =
-        addressFromInaddr6Port(&control->remoteIp.v6.as_in6addr, &control->remotePort);
-  } else {
-    printf("Invalid IP type.\n");  // will generate a Nack
-  }
-
-  AddressPair *pair = addressPair_Create(source, destination);
-  conn = (Connection *)connectionTable_FindByAddressPair(
-      forwarder_GetConnectionTable(config->forwarder), pair);
-
-  addressPair_Release(&pair);
-
-  if (!conn) {
-    IoOperations *ops = NULL;
-    switch (control->connectionType) {
-      case TCP_CONN:
-        // logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Error,
-        // __func__,
-        //                  "Unsupported tunnel protocol: TCP");
-        ops = tcpTunnel_Create(config->forwarder, source, destination);
-        break;
-      case UDP_CONN:
-        ops = udpTunnel_Create(config->forwarder, source, destination);
-        break;
-      case GRE_CONN:
-        logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Error,
-                   __func__, "Unsupported tunnel protocol: GRE");
-        break;
-#if !defined(__APPLE__) && !defined(_WIN32) && defined(PUNTING)
-      case HICN_CONN:
-        ops = hicnTunnel_Create(config->forwarder, source, destination);
-        break;
-#endif /* __APPLE__  _WIN32*/
-      default:
-        logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Error,
-                   __func__, "Unsupported tunnel protocol: %d",
-                   control->connectionType);
-        break;
-    }
-
-    if (ops != NULL) {
-      Connection *conn = connection_Create(ops);
-#ifdef WITH_POLICY
-      connection_SetTags(conn, control->tags);
-      connection_SetPriority(conn, control->priority);
-#endif /* WITH_POLICY */
+configuration_t *configuration_create() {
+  configuration_t *config = malloc(sizeof(configuration_t));
+  if (!config) return NULL;
 
-      connection_SetAdminState(conn, control->admin_state);
-
-      connectionTable_Add(forwarder_GetConnectionTable(config->forwarder),
-                          conn);
-      symbolicNameTable_Add(config->symbolicNameTable, symbolicName,
-                            connection_GetConnectionId(conn));
-
-#ifdef WITH_MAPME
-       /* Hook: new connection created through the control protocol */
-      forwarder_onConnectionEvent(config->forwarder, conn, CONNECTION_EVENT_CREATE);
-#endif /* WITH_MAPME */
-
-      success = true;
-
-    } else {
-      printf("failed, could not create IoOperations");
-    }
-
-  } else {
-#ifdef WITH_POLICY
-    connection_SetTags(conn, control->tags);
-    connection_SetPriority(conn, control->priority);
-    connection_SetAdminState(conn, control->admin_state);
-
-#ifdef WITH_MAPME
-    /* Hook: new connection created through the control protocol */
-    forwarder_onConnectionEvent(config->forwarder, conn, CONNECTION_EVENT_UPDATE);
-#endif /* WITH_MAPME */
-    if (source)
-      addressDestroy(&source);
-    if (destination)
-      addressDestroy(&destination);
-
-    success = true;
+  config->fn_config = NULL;
+  config->port = PORT_NUMBER;
+  config->configuration_port = 2001;  // TODO(eloparco): What is this?
+  config->cs_capacity = DEFAULT_CS_CAPACITY;
+  config->logfile = NULL;
+  config->logfile_fd = -1;
+#ifndef _WIN32
+  config->daemon = false;
 #else
-    printf("failed, symbolic name or connection already exist\n");
-#endif /* WITH_POLICY */
-  }
-
-  if (source)
-    addressDestroy(&source);
-  if (destination)
-    addressDestroy(&destination);
-
-  if (!success)
-    goto ERR;
-
-  // ACK
-  return utils_CreateAck(header, control, sizeof(add_connection_command));
-
-ERR:
-    return utils_CreateNack(header, control, sizeof(add_connection_command));
-}
-
-struct iovec *configuration_ProcessRemoveListener(Configuration *config,
-                                                struct iovec *request,
-                                                unsigned ingressId) {
-  header_control_message *header = request[0].iov_base;
-  remove_listener_command *control = request[1].iov_base;
-
-  bool success = false;
-
-  const char *symbolicOrListenerid = control->symbolicOrListenerid;
-  int listenerId = -1;
-  ListenerSet *listenerSet = forwarder_GetListenerSet(config->forwarder);
-  if (utils_IsNumber(symbolicOrListenerid)) {
-    // case for connid as input
-    listenerId = (unsigned)strtold(symbolicOrListenerid, NULL);
-  } else {
-    listenerId = listenerSet_FindIdByListenerName(listenerSet, symbolicOrListenerid);
-  }
-
-  if (listenerId >= 0) {
-
-    ConnectionTable *connTable = forwarder_GetConnectionTable(config->forwarder);
-    ListenerOps *listenerOps = listenerSet_FindById(listenerSet, listenerId);
-    if (listenerOps) {
-      ConnectionList *connectionList = connectionTable_GetEntries(connTable);
-      for (size_t i = 0; i < connectionList_Length(connectionList); i++) {
-        Connection *connection = connectionList_Get(connectionList, i);
-        const AddressPair *addressPair = connection_GetAddressPair(connection);
-        const Address *address = addressPair_GetLocal(addressPair);
-        if (addressEquals(listenerOps->getListenAddress(listenerOps),address)) {
-          // case for connid as input
-          unsigned connid = connection_GetConnectionId(connection);
-          // remove connection from the FIB
-          forwarder_RemoveConnectionIdFromRoutes(config->forwarder, connid);
-          // remove connection
-          connectionTable_RemoveById(connTable, connid);
-          const char *symbolicConnection = symbolicNameTable_GetNameByIndex(config->symbolicNameTable,connid);
-          symbolicNameTable_Remove(config->symbolicNameTable, symbolicConnection);
-        }
-      }
-      connectionList_Destroy(&connectionList);
-      // remove listener
-      listenerSet_RemoveById(listenerSet, listenerId);
-      success = true;
-    } else {
-      logger_Log(forwarder_GetLogger(config->forwarder), LoggerFacility_IO,
-        PARCLogLevel_Error, __func__,
-        "Listener Id not found, check list listeners");
-    }
-  }
-
-  // generate ACK/NACK
-  struct iovec *response;
-
-  if (success) {  // ACK
-    response =
-        utils_CreateAck(header, control, sizeof(remove_listener_command));
-  } else {  // NACK
-    response =
-        utils_CreateNack(header, control, sizeof(remove_connection_command));
-  }
-
-  return response;
-}
-
-
-/**
- * Add an IP-based tunnel.
- *
- * The call cal fail if the symbolic name is a duplicate.  It could also fail if
- * there's an problem creating the local side of the tunnel (i.e. the local
- * socket address is not usable).
- *
- * @return true Tunnel added
- * @return false Tunnel not added (an error)
- */
-
-struct iovec *configuration_ProcessRemoveTunnel(Configuration *config,
-                                                struct iovec *request,
-                                                unsigned ingressId) {
-  header_control_message *header = request[0].iov_base;
-  remove_connection_command *control = request[1].iov_base;
-
-  bool success = false;
-
-  const char *symbolicOrConnid = control->symbolicOrConnid;
-  ConnectionTable *table = forwarder_GetConnectionTable(config->forwarder);
-  if (strcmp(symbolicOrConnid, "SELF") == 0) {
-    forwarder_RemoveConnectionIdFromRoutes(config->forwarder, ingressId);
-    connectionTable_RemoveById(table, ingressId);
-
-#ifdef WITH_MAPME
-       /* Hook: new connection created through the control protocol */
-      forwarder_onConnectionEvent(config->forwarder, NULL, CONNECTION_EVENT_DELETE);
-#endif /* WITH_MAPME */
-
-    success = true;
-  } else if (utils_IsNumber(symbolicOrConnid)) {
-    // case for connid as input
-    unsigned connid = (unsigned)strtold(symbolicOrConnid, NULL);
-
-    // check if interface index present in the fwd table
-    //(it was missing and therefore caused a program crash)
-    if (connectionTable_FindById(table, connid)) {
-      // remove connection from the FIB
-      forwarder_RemoveConnectionIdFromRoutes(config->forwarder, connid);
-      // remove connection
-      connectionTable_RemoveById(table, connid);
-      // remove connection from symbolicNameTable
-      const char *symbolicConnection = symbolicNameTable_GetNameByIndex(config->symbolicNameTable,connid);
-      symbolicNameTable_Remove(config->symbolicNameTable, symbolicConnection);
-
-#ifdef WITH_MAPME
-       /* Hook: new connection created through the control protocol */
-      forwarder_onConnectionEvent(config->forwarder, NULL, CONNECTION_EVENT_DELETE);
-#endif /* WITH_MAPME */
-
-      success = true;
-    } else {
-      logger_Log(forwarder_GetLogger(config->forwarder), LoggerFacility_IO,
-                 PARCLogLevel_Error, __func__,
-                 "ConnID not found, check list connections");
-      // failure
-    }
-
-  } else {
-    // case for symbolic as input
-    // chech if symbolic name can be resolved
-    unsigned connid =
-        symbolicNameTable_Get(config->symbolicNameTable, symbolicOrConnid);
-    // connid = UINT_MAX when symbolicName is not found
-    if (connid != UINT32_MAX) {
-      if (logger_IsLoggable(config->logger, LoggerFacility_Config,
-                            PARCLogLevel_Debug)) {
-        logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Debug,
-                   __func__, "Remove connection resolve name '%s' to connid %u",
-                   symbolicOrConnid, connid);
-      }
-
-      // remove connection from the FIB
-      forwarder_RemoveConnectionIdFromRoutes(config->forwarder, connid);
-      // remove connection
-      connectionTable_RemoveById(table, connid);
-      // remove connection from symbolicNameTable since we have symbolic input
-      symbolicNameTable_Remove(config->symbolicNameTable, symbolicOrConnid);
-
-#ifdef WITH_MAPME
-       /* Hook: new connection created through the control protocol */
-      forwarder_onConnectionEvent(config->forwarder, NULL, CONNECTION_EVENT_DELETE);
-#endif /* WITH_MAPME */
-
-      success = true;  // to write
-    } else {
-      if (logger_IsLoggable(config->logger, LoggerFacility_Config,
-                            PARCLogLevel_Warning)) {
-        logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Error,
-                   __func__,
-                   "Remove connection symbolic name '%s' could not be resolved",
-                   symbolicOrConnid);
-      }
-      // failure
-    }
-  }
-
-
-
-  // generate ACK/NACK
-  struct iovec *response;
-
-  if (success) {  // ACK
-    response =
-        utils_CreateAck(header, control, sizeof(remove_connection_command));
-  } else {  // NACK
-    response =
-        utils_CreateNack(header, control, sizeof(remove_connection_command));
-  }
-
-  return response;
-}
-
-void _parc_strlwr(char *string) {
-  char *p = string;
-  while ((*p = tolower(*p))) {
-    p++;
-  }
-}
-
-struct iovec *configuration_ProcessConnectionList(Configuration *config,
-                                                  struct iovec *request) {
-  ConnectionTable *table = forwarder_GetConnectionTable(config->forwarder);
-  ConnectionList *connList = connectionTable_GetEntries(table);
-  struct sockaddr_in tmpAddr;
-  struct sockaddr_in6 tmpAddr6;
-
-  // allocate payload, cast from void* to uint8_t* fot bytes granularity
-  uint8_t *payloadResponse = parcMemory_AllocateAndClear(
-      sizeof(list_connections_command) * connectionList_Length(connList));
-
-  for (size_t i = 0; i < connectionList_Length(connList); i++) {
-    // Don't release original, it is not stored
-    Connection *original = connectionList_Get(connList, i);
-
-    const AddressPair *addressPair = connection_GetAddressPair(original);
-    Address *localAddress = addressCopy(addressPair_GetLocal(addressPair));
-    Address *remoteAddress = addressCopy(addressPair_GetRemote(addressPair));
-
-    // Fill payload by shifting and casting at each 'i' step.
-    list_connections_command *listConnectionsCommand =
-        (list_connections_command *)(payloadResponse +
-                                     (i * sizeof(list_connections_command)));
-    // set structure fields
-
-    listConnectionsCommand->connid = connection_GetConnectionId(original);
-
-    const char *connectionName = symbolicNameTable_GetNameByIndex(config->symbolicNameTable, connection_GetConnectionId(original));
-    snprintf(listConnectionsCommand->connectionName, SYMBOLIC_NAME_LEN, "%s", connectionName);
-    _parc_strlwr(listConnectionsCommand->connectionName);
-
-    snprintf(listConnectionsCommand->interfaceName, SYMBOLIC_NAME_LEN, "%s", ioOperations_GetInterfaceName(connection_GetIoOperations(original)));
-
-    listConnectionsCommand->state =
-        connection_IsUp(original) ? IFACE_UP : IFACE_DOWN;
-    listConnectionsCommand->connectionData.admin_state =
-        (connection_GetAdminState(original) == CONNECTION_STATE_UP) ? IFACE_UP : IFACE_DOWN;
-    listConnectionsCommand->connectionData.connectionType =
-        ioOperations_GetConnectionType(connection_GetIoOperations(original));
-
-    listConnectionsCommand->connectionData.admin_state = connection_GetAdminState(original);
-
-#ifdef WITH_POLICY
-    listConnectionsCommand->connectionData.priority = connection_GetPriority(original);
-    listConnectionsCommand->connectionData.tags = connection_GetTags(original);
-#endif /* WITH_POLICY */
-
-    if (addressGetType(localAddress) == ADDR_INET &&
-        addressGetType(remoteAddress) == ADDR_INET) {
-      listConnectionsCommand->connectionData.ipType = ADDR_INET;
-
-      // get local port/address
-      addressGetInet(localAddress, &tmpAddr);
-      listConnectionsCommand->connectionData.localPort = tmpAddr.sin_port;
-      listConnectionsCommand->connectionData.localIp.v4.as_inaddr =
-          tmpAddr.sin_addr;
-      memset(&tmpAddr, 0, sizeof(tmpAddr));
-      // get remote port/address
-      addressGetInet(remoteAddress, &tmpAddr);
-      listConnectionsCommand->connectionData.remotePort = tmpAddr.sin_port;
-      listConnectionsCommand->connectionData.remoteIp.v4.as_inaddr =
-          tmpAddr.sin_addr;
-
-    } else if (addressGetType(localAddress) == ADDR_INET6 &&
-               addressGetType(remoteAddress) == ADDR_INET6) {
-      listConnectionsCommand->connectionData.ipType = ADDR_INET6;
-
-      // get local port/address
-      addressGetInet6(localAddress, &tmpAddr6);
-      listConnectionsCommand->connectionData.localPort = tmpAddr6.sin6_port;
-      listConnectionsCommand->connectionData.localIp.v6.as_in6addr = tmpAddr6.sin6_addr;
-      memset(&tmpAddr6, 0, sizeof(tmpAddr6));
-      // get remote port/address
-      addressGetInet6(remoteAddress, &tmpAddr6);
-      listConnectionsCommand->connectionData.remotePort = tmpAddr6.sin6_port;
-      listConnectionsCommand->connectionData.remoteIp.v6.as_in6addr = tmpAddr6.sin6_addr;
-
-    }  // no need further else, control on the addressed already done at the
-       // time of insertion in the connection table
-    addressDestroy(&localAddress);
-    addressDestroy(&remoteAddress);
-  }
-
-  // send response
-  header_control_message *header = request[0].iov_base;
-  header->messageType = RESPONSE_LIGHT;
-  header->length = (uint16_t)connectionList_Length(connList);
-
-  struct iovec *response =
-      parcMemory_AllocateAndClear(sizeof(struct iovec) * 2);
-
-  response[0].iov_base = header;
-  response[0].iov_len = sizeof(header_control_message);
-  response[1].iov_base = payloadResponse;
-  response[1].iov_len =
-      sizeof(list_connections_command) * connectionList_Length(connList);
-
-  connectionList_Destroy(&connList);
-  return response;
-}
-
-struct iovec *configuration_ProcessListenersList(Configuration *config,
-                                                 struct iovec *request) {
-  ListenerSet *listenerList = forwarder_GetListenerSet(config->forwarder);
-  struct sockaddr_in tmpAddr;
-  struct sockaddr_in6 tmpAddr6;
-
-  // allocate payload, cast from void* to uint8_t* fot bytes granularity
-  uint8_t *payloadResponse = parcMemory_AllocateAndClear(
-      sizeof(list_listeners_command) * listenerSet_Length(listenerList));
-
-  for (size_t i = 0; i < listenerSet_Length(listenerList); i++) {
-    ListenerOps *listenerEntry = listenerSet_Get(listenerList, i);
-
-    // Fill payload by shifting and casting at each 'i' step.
-    list_listeners_command *listListenersCommand =
-        (list_listeners_command *)(payloadResponse +
-                                   (i * sizeof(list_listeners_command)));
-
-    listListenersCommand->connid =
-        (uint32_t)listenerEntry->getInterfaceIndex(listenerEntry);
-    listListenersCommand->encapType =
-        (uint8_t)listenerEntry->getEncapType(listenerEntry);
-    if (addressGetType((const Address *)listenerEntry->getListenAddress(
-            listenerEntry)) == ADDR_INET) {
-      addressGetInet(
-          (const Address *)listenerEntry->getListenAddress(listenerEntry),
-          &tmpAddr);
-      listListenersCommand->addressType = ADDR_INET;
-      listListenersCommand->address.v4.as_inaddr = tmpAddr.sin_addr;
-      listListenersCommand->port = tmpAddr.sin_port;
-    } else if (addressGetType((const Address *)listenerEntry->getListenAddress(
-                   listenerEntry)) == ADDR_INET6) {
-      addressGetInet6(
-          (const Address *)listenerEntry->getListenAddress(listenerEntry),
-          &tmpAddr6);
-      listListenersCommand->addressType = ADDR_INET6;
-      listListenersCommand->address.v6.as_in6addr = tmpAddr6.sin6_addr;
-      listListenersCommand->port = tmpAddr6.sin6_port;
-    }
-
-    const char * listenerName = listenerEntry->getListenerName(listenerEntry);
-    snprintf(listListenersCommand->listenerName, SYMBOLIC_NAME_LEN, "%s", listenerName);
-    if (listenerEntry->getEncapType(listenerEntry) == ENCAP_TCP ||
-            listenerEntry->getEncapType(listenerEntry) == ENCAP_UDP) {
-      const char * interfaceName = listenerEntry->getInterfaceName(listenerEntry);
-      snprintf(listListenersCommand->interfaceName, SYMBOLIC_NAME_LEN, "%s", interfaceName);
-    }
-  }
-
-  // send response
-  header_control_message *header = request[0].iov_base;
-  header->messageType = RESPONSE_LIGHT;
-  header->length = (uint16_t)listenerSet_Length(listenerList);
-
-  struct iovec *response =
-      parcMemory_AllocateAndClear(sizeof(struct iovec) * 2);
-
-  response[0].iov_base = header;
-  response[0].iov_len = sizeof(header_control_message);
-  response[1].iov_base = payloadResponse;
-  response[1].iov_len =
-      sizeof(list_listeners_command) * listenerSet_Length(listenerList);
-
-  return response;
-}
-
-struct iovec *configuration_ProcessCacheStore(Configuration *config,
-                                              struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  ;
-  cache_store_command *control = request[1].iov_base;
-  ;
-
-  bool success = false;
-
-  switch (control->activate) {
-    case ACTIVATE_ON:
-      forwarder_SetChacheStoreFlag(config->forwarder, true);
-      if (forwarder_GetChacheStoreFlag(config->forwarder)) {
-        success = true;
-      }
-      break;
-
-    case ACTIVATE_OFF:
-      forwarder_SetChacheStoreFlag(config->forwarder, false);
-      if (!forwarder_GetChacheStoreFlag(config->forwarder)) {
-        success = true;
-      }
-      break;
-
-    default:
-      break;
-  }
-
-  struct iovec *response;
-  if (success) {  // ACK
-    response = utils_CreateAck(header, control, sizeof(cache_store_command));
-  } else {  // NACK
-    response = utils_CreateNack(header, control, sizeof(cache_store_command));
-  }
-
-  return response;
-}
-
-struct iovec *configuration_ProcessCacheServe(Configuration *config,
-                                              struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  cache_serve_command *control = request[1].iov_base;
-
-  bool success = false;
-
-  switch (control->activate) {
-    case ACTIVATE_ON:
-      forwarder_SetChacheServeFlag(config->forwarder, true);
-      if (forwarder_GetChacheServeFlag(config->forwarder)) {
-        success = true;
-      }
-      break;
-
-    case ACTIVATE_OFF:
-      forwarder_SetChacheServeFlag(config->forwarder, false);
-      if (!forwarder_GetChacheServeFlag(config->forwarder)) {
-        success = true;
-      }
-      break;
-
-    default:
-      break;
-  }
-
-  struct iovec *response;
-  if (success) {  // ACK
-    response = utils_CreateAck(header, control, sizeof(cache_store_command));
-  } else {  // NACK
-    response = utils_CreateNack(header, control, sizeof(cache_store_command));
-  }
-
-  return response;
-}
-
-struct iovec *configuration_ProcessCacheClear(Configuration *config,
-                                              struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-
-  forwarder_ClearCache(config->forwarder);
-
-  struct iovec *response = utils_CreateAck(header, NULL, 0);
-  return response;
-}
-
-size_t configuration_GetObjectStoreSize(Configuration *config) {
-  return config->maximumContentObjectStoreSize;
-}
+  WSADATA wsaData = {0};
+  WSAStartup(MAKEWORD(2, 2), &wsaData);
+#endif
+  configuration_set_loglevel(config, loglevel_from_str(DEFAULT_LOGLEVEL));
+  config->strategy_map = kh_init_strategy_map();
 
-void _configuration_StoreFwdStrategy(Configuration *config, const char *prefix,
-                                     strategy_type strategy) {
-  PARCString *prefixStr = parcString_Create(prefix);
-  PARCUnsigned *strategyValue = parcUnsigned_Create((unsigned)strategy);
-  parcHashMap_Put(config->strategy_map, prefixStr, strategyValue);
-  parcUnsigned_Release(&strategyValue);
-  parcString_Release(&prefixStr);
+  return config;
 }
 
-struct iovec *configuration_SetWldr(Configuration *config,
-                                    struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  set_wldr_command *control = request[1].iov_base;
-  ConnectionTable *table = forwarder_GetConnectionTable(config->forwarder);
-  Connection *conn = NULL;
-  bool success = false;
+void configuration_free(configuration_t *config) {
+  assert(config);
 
-  const char *symbolicOrConnid = control->symbolicOrConnid;
+  const char *k_prefix;
+  unsigned _;
+  (void)_;
 
-  if (utils_IsNumber(symbolicOrConnid)) {
-    // case for connid as input: check if connID present in the fwd table
-    conn = (Connection *)connectionTable_FindById(
-        table, (unsigned)strtold(symbolicOrConnid, NULL));
-    if (conn) {
-      success = true;
-    } else {
-      logger_Log(forwarder_GetLogger(config->forwarder), LoggerFacility_IO,
-                 PARCLogLevel_Error, __func__,
-                 "ConnID not found, check list connections");  // failure
-    }
-  } else {
-    // case for symbolic as input: check if symbolic name can be resolved
-    unsigned connid =
-        symbolicNameTable_Get(config->symbolicNameTable, symbolicOrConnid);
-    if (connid != UINT32_MAX) {
-      conn = (Connection *)connectionTable_FindById(table, connid);
-      if (conn) {
-        if (logger_IsLoggable(config->logger, LoggerFacility_Config,
-                              PARCLogLevel_Debug)) {
-          logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Debug,
-                     __func__, "Set wldr resolve name '%s' to connid %u",
-                     symbolicOrConnid, connid);
-        }
-        success = true;
-      }
-    } else {
-      if (logger_IsLoggable(config->logger, LoggerFacility_Config,
-                            PARCLogLevel_Warning)) {
-        logger_Log(config->logger, LoggerFacility_Config, PARCLogLevel_Error,
-                   __func__, "Symbolic name '%s' could not be resolved",
-                   symbolicOrConnid);
-      }  // failure
-    }
-  }
+  // Free the strategy hashmap
+  kh_foreach(config->strategy_map, k_prefix, _, { free((char *)k_prefix); });
+  kh_destroy_strategy_map(config->strategy_map);
 
-  // generate ACK/NACK
-  struct iovec *response;
-
-  if (success) {
-    switch (control->activate) {
-      case ACTIVATE_ON:
-        connection_EnableWldr(conn);
-        response = utils_CreateAck(header, control, sizeof(set_wldr_command));
-        break;
-
-      case ACTIVATE_OFF:
-        connection_DisableWldr(conn);
-        response = utils_CreateAck(header, control, sizeof(set_wldr_command));
-        break;
-
-      default:  // received wrong value
-        response = utils_CreateNack(header, control, sizeof(set_wldr_command));
-        break;
-    }
-  } else {
-    response = utils_CreateNack(header, control, sizeof(set_wldr_command));
-  }
-
-  return response;
+  free(config);
 }
 
-strategy_type configuration_GetForwardingStrategy(Configuration *config,
-                                                  const char *prefix) {
-  PARCString *prefixStr = parcString_Create(prefix);
-  const unsigned *val = parcHashMap_Get(config->strategy_map, prefixStr);
-  parcString_Release(&prefixStr);
-
-  if (val == NULL) {
-    return LAST_STRATEGY_VALUE;
-  } else {
-    return (strategy_type)*val;
-  }
+size_t configuration_get_cs_size(const configuration_t *config) {
+  return config->cs_capacity;
 }
 
-struct iovec *configuration_SetForwardingStrategy(Configuration *config,
-                                                  struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  set_strategy_command *control = request[1].iov_base;
-
-  const char *prefix = utils_PrefixLenToString(
-      control->addressType, &control->address, &control->len);
-  strategy_type strategy = control->strategyType;
-  strategy_type existingFwdStrategy =
-      configuration_GetForwardingStrategy(config, prefix);
-
-  if (existingFwdStrategy == LAST_STRATEGY_VALUE ||
-      strategy != existingFwdStrategy) {
-    // means such a new strategy is not present in the hash table or has to be
-    // updated
-    _configuration_StoreFwdStrategy(config, prefix, strategy);
-    Name *hicnPrefix = name_CreateFromAddress(control->addressType,
-                                              control->address, control->len);
-    Name *related_prefixes[MAX_FWD_STRATEGY_RELATED_PREFIXES];
-    if(control->related_prefixes != 0){
-      for(int i = 0; i < control->related_prefixes; i++){
-        related_prefixes[i] = name_CreateFromAddress(
-                                  control->addresses_type[i],
-                                  control->addresses[i], control->lens[i]);
-      }
-    }
-    forwarder_SetStrategy(config->forwarder, hicnPrefix, strategy,
-                          control->related_prefixes, related_prefixes);
-    name_Release(&hicnPrefix);
-    if(control->related_prefixes != 0){
-      for(int i = 0; i < control->related_prefixes; i++){
-        name_Release(&related_prefixes[i]);
-      }
-    }
-  }
-
-  free((char *) prefix);
-  struct iovec *response =
-      utils_CreateAck(header, control, sizeof(set_strategy_command));
-
-  return response;
+void configuration_set_cs_size(configuration_t *config, size_t size) {
+  config->cs_capacity = size;
 }
 
-void configuration_SetObjectStoreSize(Configuration *config,
-                                      size_t maximumObjectCount) {
-  config->maximumContentObjectStoreSize = maximumObjectCount;
-
-  forwarder_SetContentObjectStoreSize(config->forwarder,
-                                      config->maximumContentObjectStoreSize);
+const char *configuration_get_fn_config(const configuration_t *config) {
+  return config->fn_config;
 }
 
-Forwarder *configuration_GetForwarder(const Configuration *config) {
-  return config->forwarder;
+void configuration_set_fn_config(configuration_t *config,
+                                 const char *fn_config) {
+  config->fn_config = fn_config;
 }
 
-Logger *configuration_GetLogger(const Configuration *config) {
-  return config->logger;
+void configuration_set_port(configuration_t *config, uint16_t port) {
+  config->port = port;
 }
 
-struct iovec *configuration_MapMeEnable(Configuration *config,
-                                        struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  mapme_activator_command *control = request[1].iov_base;
-  const char *stateString[2] = {"on", "off"};
-
-  PARCBufferComposer *composer = parcBufferComposer_Create();
-  parcBufferComposer_Format(composer,
-                            "The mapme enable setting received is: %s",
-                            stateString[control->activate]);
-
-  PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(composer);
-  char *result = parcBuffer_ToString(tempBuffer);
-  parcBuffer_Release(&tempBuffer);
-  puts(result);
-  parcMemory_Deallocate((void **)&result);
-  parcBufferComposer_Release(&composer);
-
-  return utils_CreateAck(header, control, sizeof(mapme_timing_command));
+uint16_t configuration_get_port(const configuration_t *config) {
+  return config->port;
 }
 
-struct iovec *configuration_MapMeDiscovery(Configuration *config,
-                                           struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  mapme_activator_command *control = request[1].iov_base;
-  const char *stateString[2] = {"on", "off"};
-
-  PARCBufferComposer *composer = parcBufferComposer_Create();
-  parcBufferComposer_Format(composer,
-                            "The mapme discovery setting received is: %s",
-                            stateString[control->activate]);
-
-  PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(composer);
-  char *result = parcBuffer_ToString(tempBuffer);
-  parcBuffer_Release(&tempBuffer);
-  puts(result);
-  parcMemory_Deallocate((void **)&result);
-  parcBufferComposer_Release(&composer);
-
-  return utils_CreateAck(header, control, sizeof(mapme_timing_command));
+void configuration_set_configuration_port(configuration_t *config,
+                                          uint16_t configuration_port) {
+  config->configuration_port = configuration_port;
 }
 
-struct iovec *configuration_MapMeTimescale(Configuration *config,
-                                           struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  mapme_timing_command *control = request[1].iov_base;
-
-  PARCBufferComposer *composer = parcBufferComposer_Create();
-  parcBufferComposer_Format(composer,
-                            "The mapme timescale value received is: %u",
-                            control->timePeriod);
-
-  PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(composer);
-  char *result = parcBuffer_ToString(tempBuffer);
-  parcBuffer_Release(&tempBuffer);
-  puts(result);
-  parcMemory_Deallocate((void **)&result);
-  parcBufferComposer_Release(&composer);
-
-  return utils_CreateAck(header, control, sizeof(mapme_timing_command));
-}
-
-struct iovec *configuration_MapMeRetx(Configuration *config,
-                                      struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  mapme_timing_command *control = request[1].iov_base;
-
-  PARCBufferComposer *composer = parcBufferComposer_Create();
-  parcBufferComposer_Format(
-      composer, "The mapme retransmission time value received is: %u",
-      control->timePeriod);
-
-  PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(composer);
-  char *result = parcBuffer_ToString(tempBuffer);
-  parcBuffer_Release(&tempBuffer);
-  puts(result);
-  parcMemory_Deallocate((void **)&result);
-  parcBufferComposer_Release(&composer);
-
-  return utils_CreateAck(header, control, sizeof(mapme_timing_command));
+uint16_t configuration_get_configuration_port(const configuration_t *config) {
+  return config->configuration_port;
 }
 
-struct iovec * configuration_MapMeSendUpdate(Configuration *config,
-                                      struct iovec *request, unsigned ingressId) {
-  header_control_message *header = request[0].iov_base;
-  mapme_send_update_command *control = request[1].iov_base;
-
-  FIB * fib = forwarder_getFib(config->forwarder);
-  if (!fib)
-      goto ERR;
-  Name *prefix = name_CreateFromAddress(control->addressType, control->address,
-                                        control->len);
-  if (!prefix)
-      goto ERR;
-  FibEntry *entry = fib_Contains(fib, prefix);
-  name_Release(&prefix);
-  if (!entry)
-      goto ERR;
-
-  const NumberSet * nexthops = fibEntry_GetNexthops(entry);
-  unsigned size = (unsigned) numberSet_Length(nexthops);
-
-  /* The command is accepted iif triggered by (one of) the producer of this prefix */
-  for (unsigned i = 0; i < size; i++) {
-    unsigned nhop = numberSet_GetItem(nexthops, i);
-    if (nhop == ingressId) {
-        MapMe * mapme = forwarder_getMapmeInstance(config->forwarder);
-        mapme_send_updates(mapme, entry, nexthops);
-        return utils_CreateAck(header, control, sizeof(mapme_timing_command));
-    }
-  }
-
-ERR:
-  return utils_CreateNack(header, control, sizeof(connection_set_admin_state_command));
+void configuration_set_loglevel(configuration_t *config, int loglevel) {
+  config->loglevel = loglevel;
+  log_conf.log_level = loglevel;
 }
 
-
-struct iovec *configuration_ConnectionSetAdminState(Configuration *config,
-                                      struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  connection_set_admin_state_command *control = request[1].iov_base;
-
-  if ((control->admin_state != CONNECTION_STATE_UP) && (control->admin_state != CONNECTION_STATE_DOWN))
-    return utils_CreateNack(header, control, sizeof(connection_set_admin_state_command));
-
-  Connection * conn = getConnectionBySymbolicOrId(config, control->symbolicOrConnid);
-  if (!conn)
-    return utils_CreateNack(header, control, sizeof(connection_set_admin_state_command));
-
-  connection_SetAdminState(conn, control->admin_state);
-
-#ifdef WITH_MAPME
-  /* Hook: connection event */
-  forwarder_onConnectionEvent(config->forwarder, conn,
-      control->admin_state == CONNECTION_STATE_UP
-              ? CONNECTION_EVENT_SET_UP
-              : CONNECTION_EVENT_SET_DOWN);
-#endif /* WITH_MAPME */
-
-  return utils_CreateAck(header, control, sizeof(connection_set_admin_state_command));
+int configuration_get_loglevel(const configuration_t *config) {
+  return config->loglevel;
 }
 
-#ifdef WITH_POLICY
-
-struct iovec *configuration_ConnectionSetPriority(Configuration *config,
-                                      struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  connection_set_priority_command *control = request[1].iov_base;
-
-  Connection * conn = getConnectionBySymbolicOrId(config, control->symbolicOrConnid);
-  if (!conn)
-    return utils_CreateNack(header, control, sizeof(connection_set_priority_command));
-
-  connection_SetPriority(conn, control->priority);
-
-#ifdef WITH_MAPME
-  /* Hook: connection event */
-  forwarder_onConnectionEvent(config->forwarder, conn,
-          CONNECTION_EVENT_PRIORITY_CHANGED);
-#endif /* WITH_MAPME */
-
-  return utils_CreateAck(header, control, sizeof(connection_set_priority_command));
+void configuration_set_logfile(configuration_t *config, const char *logfile) {
+  config->logfile = logfile;
+  log_conf.log_file = fopen(logfile, "w");
+  config->logfile_fd = fileno(log_conf.log_file);
 }
 
-struct iovec *configuration_ConnectionSetTags(Configuration *config,
-                                      struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  connection_set_tags_command *control = request[1].iov_base;
-
-  Connection * conn = getConnectionBySymbolicOrId(config, control->symbolicOrConnid);
-  if (!conn)
-    return utils_CreateNack(header, control, sizeof(connection_set_tags_command));
-
-  connection_SetTags(conn, control->tags);
-
-#ifdef WITH_MAPME
-  /* Hook: connection event */
-  forwarder_onConnectionEvent(config->forwarder, conn,
-          CONNECTION_EVENT_TAGS_CHANGED);
-#endif /* WITH_MAPME */
-
-  return utils_CreateAck(header, control, sizeof(connection_set_tags_command));
+const char *configuration_get_logfile(const configuration_t *config) {
+  return config->logfile;
 }
 
-struct iovec *configuration_ProcessPolicyAdd(Configuration *config,
-                                      struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  add_policy_command *control = request[1].iov_base;
-
-  if (forwarder_AddOrUpdatePolicy(config->forwarder, control)) {
-    return utils_CreateAck(header, control, sizeof(add_policy_command));
-  } else {
-    return utils_CreateNack(header, control, sizeof(add_policy_command));
-  }
+int configuration_get_logfile_fd(const configuration_t *config) {
+  return config->logfile_fd;
 }
 
-struct iovec *configuration_ProcessPolicyList(Configuration *config,
-                                                    struct iovec *request) {
-  FibEntryList *fibList = forwarder_GetFibEntries(config->forwarder);
-
-  size_t payloadSize = fibEntryList_Length(fibList);
-  struct sockaddr_in tmpAddr;
-  struct sockaddr_in6 tmpAddr6;
-
-  // allocate payload, cast from void* to uint8_t* = bytes granularity
-  uint8_t *payloadResponse =
-      parcMemory_AllocateAndClear(sizeof(list_policies_command) * payloadSize);
-
-  for (size_t i = 0; i < fibEntryList_Length(fibList); i++) {
-    FibEntry *entry = (FibEntry *)fibEntryList_Get(fibList, i);
-    NameBitvector *prefix = name_GetContentName(fibEntry_GetPrefix(entry));
-
-    list_policies_command *listPoliciesCommand =
-        (list_policies_command *)(payloadResponse +
-                (i * sizeof(list_policies_command)));
-
-    Address *addressEntry = nameBitvector_ToAddress(prefix);
-    if (addressGetType(addressEntry) == ADDR_INET) {
-      addressGetInet(addressEntry, &tmpAddr);
-      listPoliciesCommand->addressType = ADDR_INET;
-      listPoliciesCommand->address.v4.as_inaddr = tmpAddr.sin_addr;
-    } else if (addressGetType(addressEntry) == ADDR_INET6) {
-      addressGetInet6(addressEntry, &tmpAddr6);
-      listPoliciesCommand->addressType = ADDR_INET6;
-      listPoliciesCommand->address.v6.as_in6addr = tmpAddr6.sin6_addr;
-    }
-    listPoliciesCommand->len = nameBitvector_GetLength(prefix);
-    listPoliciesCommand->policy = fibEntry_GetPolicy(entry);
-
-    addressDestroy(&addressEntry);
-  }
-
-  // send response
-  header_control_message *header = request[0].iov_base;
-  header->messageType = RESPONSE_LIGHT;
-  header->length = (unsigned)payloadSize;
-
-  struct iovec *response =
-      parcMemory_AllocateAndClear(sizeof(struct iovec) * 2);
-
-  response[0].iov_base = header;
-  response[0].iov_len = sizeof(header_control_message);
-  response[1].iov_base = payloadResponse;
-  response[1].iov_len = sizeof(list_policies_command) * payloadSize;
-
-  fibEntryList_Destroy(&fibList);
-  return response;
+void configuration_set_daemon(configuration_t *config, bool daemon) {
+  config->daemon = daemon;
 }
 
-struct iovec *configuration_ProcessPolicyRemove(Configuration *config,
-                                                        struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  remove_policy_command *control = request[1].iov_base;
-
-  if (forwarder_RemovePolicy(config->forwarder, control))
-    return utils_CreateAck(header, control, sizeof(remove_policy_command));
-  else
-    return utils_CreateNack(header, control, sizeof(remove_policy_command));
+bool configuration_get_daemon(const configuration_t *config) {
+  return config->daemon;
 }
 
-struct iovec *configuration_UpdateConnection(Configuration *config,
-                                                        struct iovec *request) {
-  header_control_message *header = request[0].iov_base;
-  update_connection_command *control = request[1].iov_base;
-
-  Connection * conn = getConnectionBySymbolicOrId(config, control->symbolicOrConnid);
-  if (!conn)
-    return utils_CreateNack(header, control, sizeof(update_connection_command));
-
-  connection_SetTags(conn, control->tags);
-  connection_SetAdminState(conn, control->admin_state);
-  if (control->priority > 0)
-    connection_SetPriority(conn, control->priority);
-
-  return utils_CreateAck(header, control, sizeof(update_connection_command));
+void configuration_set_strategy(configuration_t *config, const char *prefix,
+                                strategy_type_t strategy_type) {
+  int res;
+  khiter_t k = kh_put_strategy_map(config->strategy_map, strdup(prefix), &res);
+  kh_value(config->strategy_map, k) = strategy_type;
 }
-#endif /* WITH_POLICY */
-
-// ===========================
-// Main functions that deal with receiving commands, executing them, and sending
-// ACK/NACK
-
-struct iovec *configuration_DispatchCommand(Configuration *config,
-                                            command_id command,
-                                            struct iovec *control,
-                                            unsigned ingressId) {
-  struct iovec *response = NULL;
-  switch (command) {
-    case ADD_LISTENER:
-      response = configurationListeners_Add(config, control, ingressId);
-      break;
-
-    case ADD_CONNECTION:
-      response = configuration_ProcessCreateTunnel(config, control);
-      break;
-
-    case LIST_CONNECTIONS:
-      response = configuration_ProcessConnectionList(config, control);
-      break;
-
-    case ADD_ROUTE:
-      response =
-          configuration_ProcessRegisterHicnPrefix(config, control, ingressId);
-      break;
-
-    case LIST_ROUTES:
-      response = configuration_ProcessRegistrationList(config, control);
-      break;
-
-    case REMOVE_CONNECTION:
-      response = configuration_ProcessRemoveTunnel(config, control, ingressId);
-      break;
-
-    case REMOVE_LISTENER:
-      response = configuration_ProcessRemoveListener(config, control, ingressId);
-      break;
-
-    case REMOVE_ROUTE:
-      response = configuration_ProcessUnregisterHicnPrefix(config, control);
-      break;
-
-    case CACHE_STORE:
-      response = configuration_ProcessCacheStore(config, control);
-      break;
-
-    case CACHE_SERVE:
-      response = configuration_ProcessCacheServe(config, control);
-      break;
-
-    case CACHE_CLEAR:
-      response = configuration_ProcessCacheClear(config, control);
-      break;
-
-    case SET_STRATEGY:
-      response = configuration_SetForwardingStrategy(config, control);
-      break;
-
-    case SET_WLDR:
-      response = configuration_SetWldr(config, control);
-      break;
-
-    case ADD_PUNTING:
-      response = configurationListeners_AddPunting(config, control, ingressId);
-      break;
 
-    case LIST_LISTENERS:
-      response = configuration_ProcessListenersList(config, control);
-      break;
-
-    case MAPME_ENABLE:
-      response = configuration_MapMeEnable(config, control);
-      break;
-
-    case MAPME_DISCOVERY:
-      response = configuration_MapMeDiscovery(config, control);
-      break;
-
-    case MAPME_TIMESCALE:
-      response = configuration_MapMeTimescale(config, control);
-      break;
-
-    case MAPME_RETX:
-      response = configuration_MapMeRetx(config, control);
-      break;
-
-    case MAPME_SEND_UPDATE:
-      response = configuration_MapMeSendUpdate(config, control, ingressId);
-      break;
-
-    case CONNECTION_SET_ADMIN_STATE:
-      response = configuration_ConnectionSetAdminState(config, control);
-      break;
-
-#ifdef WITH_POLICY
-    case ADD_POLICY:
-      response = configuration_ProcessPolicyAdd(config, control);
-      break;
-
-    case LIST_POLICIES:
-      response = configuration_ProcessPolicyList(config, control);
-      break;
-
-    case REMOVE_POLICY:
-      response = configuration_ProcessPolicyRemove(config, control);
-      break;
-
-    case UPDATE_CONNECTION:
-      response = configuration_UpdateConnection(config, control);
-      break;
-
-    case CONNECTION_SET_PRIORITY:
-      response = configuration_ConnectionSetPriority(config, control);
-      break;
-
-    case CONNECTION_SET_TAGS:
-      response = configuration_ConnectionSetTags(config, control);
-      break;
-#endif /* WITH_POLICY */
-
-    default:
-      break;
-  }
-
-  return response;
+strategy_type_t configuration_get_strategy(const configuration_t *config,
+                                           const char *prefix) {
+  khiter_t k = kh_get_strategy_map(config->strategy_map, prefix);
+  if (k == kh_end(config->strategy_map)) return STRATEGY_TYPE_UNDEFINED;
+  return kh_val(config->strategy_map, k);
 }
 
-void configuration_ReceiveCommand(Configuration *config, command_id command,
-                                  struct iovec *request, unsigned ingressId) {
-  parcAssertNotNull(config, "Parameter config must be non-null");
-  parcAssertNotNull(request, "Parameter request must be non-null");
-  struct iovec *response =
-      configuration_DispatchCommand(config, command, request, ingressId);
-  configuration_SendResponse(config, response, ingressId);
-
-  /*
-   * The message is originally received by a listener, and will be freed in
-   * different parts of the code.
-   *
-   * For the special case of commands, a iovec is created, eg in
-   * udpListener::_readCommand, which has to be freed (it is commented in the
-   * listener). On the contrary, the original message is freed.
-   *
-   * From this function, commands are dispatched to different processing
-   * functions, which have two general behaviours:
-   *
-   * - LIST commands:
-   *   . a payload for the response is allocated
-   *   . a iovec for the response is allocated with header = request header,
-   *   payload = newly allocated payload
-   *
-   * - Other commands:
-   *   . a ack/nack packet is generated thanks to utils/utils.cc
-   *   . this allocates a iovec which reuses the header of the request just
-   *   updating the messageType field inside.
-   */
-  parcMemory_Deallocate(&request);
-
-  switch (command) {
-    case LIST_CONNECTIONS:
-    case LIST_ROUTES:  // case LIST_INTERFACES: case ETC...:
-    case LIST_LISTENERS:
-    case LIST_POLICIES:
-      /* Deallocate payload */
-      parcMemory_Deallocate(&response[1].iov_base);
-      break;
-    default:
-      break;
-  }
-
-  parcMemory_Deallocate(&response);
+void configuration_flush_log() {
+  if (log_conf.log_file) fclose(log_conf.log_file);
 }
diff --git a/hicn-light/src/hicn/config/configuration.h b/hicn-light/src/hicn/config/configuration.h
index 5090f1413..9861b6c9f 100644
--- a/hicn-light/src/hicn/config/configuration.h
+++ b/hicn-light/src/hicn/config/configuration.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -23,17 +23,18 @@
  *
  */
 
-#ifndef configuration_h
-#define configuration_h
+#ifndef HICNLIGHT_CONFIGURATION_H
+#define HICNLIGHT_CONFIGURATION_H
 
-#include <hicn/core/logger.h>
-#include <hicn/utils/commands.h>
+#include "../base/khash.h"
+#include "../core/msgbuf.h"
+#include "../core/strategy.h"
+#include <hicn/ctrl/api.h>
+#include <hicn/ctrl/hicn-light-ng.h>
 
-struct configuration;
-typedef struct configuration Configuration;
+KHASH_MAP_INIT_STR(strategy_map, unsigned);
 
-struct forwarder;
-typedef struct forwarder Forwarder;
+typedef struct configuration_s configuration_t;
 
 /**
  * <#One Line Description#>
@@ -49,7 +50,7 @@ typedef struct forwarder Forwarder;
  * <#example#>
  * @endcode
  */
-Configuration *configuration_Create(Forwarder *forwarder);
+configuration_t *configuration_create();
 
 /**
  * <#One Line Description#>
@@ -65,13 +66,7 @@ Configuration *configuration_Create(Forwarder *forwarder);
  * <#example#>
  * @endcode
  */
-void configuration_Destroy(Configuration **configPtr);
-
-void configuration_SetupAllListeners(Configuration *config, uint16_t port,
-                                     const char *localPath);
-
-void configuration_ReceiveCommand(Configuration *config, command_id command,
-                                  struct iovec *request, unsigned ingressId);
+void configuration_free(configuration_t *config);
 
 /**
  * Returns the configured size of the content store
@@ -87,7 +82,7 @@ void configuration_ReceiveCommand(Configuration *config, command_id command,
  * <#example#>
  * @endcode
  */
-size_t configuration_GetObjectStoreSize(Configuration *config);
+size_t configuration_get_cs_size(const configuration_t *config);
 
 /**
  * Sets the size of the content store (in objects, not bytes)
@@ -101,52 +96,42 @@ size_t configuration_GetObjectStoreSize(Configuration *config);
  * <#example#>
  * @endcode
  */
-void configuration_SetObjectStoreSize(Configuration *config,
-                                      size_t maximumContentObjectCount);
+void configuration_set_cs_size(configuration_t *config, size_t size);
 
-strategy_type configuration_GetForwardingStrategy(Configuration *config,
-                                                  const char *prefix);
+const char *configuration_get_fn_config(const configuration_t *config);
 
-/**
- * Returns the Forwarder that owns the Configuration
- *
- * Returns the hicn-light Forwarder.  Used primarily by associated classes in
- * the configuration group.
- *
- * @param [in] config An allocated Configuration
- *
- * @return non-null The owning Forwarder
- * @return null An error
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-Forwarder *configuration_GetForwarder(const Configuration *config);
+void configuration_set_fn_config(configuration_t *config,
+                                 const char *fn_config);
 
-/**
- * Returns the logger used by the Configuration subsystem
- *
- * Returns the logger specified when the Configuration was created.
- *
- * @param [in] config An allocated Configuration
- *
- * @retval non-null The logger
- * @retval null An error
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-Logger *configuration_GetLogger(const Configuration *config);
+void configuration_set_port(configuration_t *config, uint16_t port);
+
+uint16_t configuration_get_port(const configuration_t *config);
+
+void configuration_set_configuration_port(configuration_t *config,
+                                          uint16_t configuration_port);
+
+uint16_t configuration_get_configuration_port(const configuration_t *config);
+
+void configuration_set_loglevel(configuration_t *config, int loglevel);
+
+int configuration_get_loglevel(const configuration_t *config);
+
+void configuration_set_logfile(configuration_t *config, const char *logfile);
+
+const char *configuration_get_logfile(const configuration_t *config);
+
+int configuration_get_logfile_fd(const configuration_t *config);
+
+void configuration_set_daemon(configuration_t *config, bool daemon);
+
+bool configuration_get_daemon(const configuration_t *config);
+
+void configuration_set_strategy(configuration_t *config, const char *prefix,
+                                strategy_type_t strategy_type);
+
+strategy_type_t configuration_get_strategy(const configuration_t *config,
+                                           const char *prefix);
 
-struct iovec *configuration_DispatchCommand(Configuration *config,
-                                            command_id command,
-                                            struct iovec *control,
-                                            unsigned ingressId);
+void configuration_flush_log();
 
-#endif  // configuration_h
+#endif  // HICNLIGHT_CONFIGURATION_H
diff --git a/hicn-light/src/hicn/config/configurationFile.c b/hicn-light/src/hicn/config/configurationFile.c
deleted file mode 100644
index ebf057fa6..000000000
--- a/hicn-light/src/hicn/config/configurationFile.c
+++ /dev/null
@@ -1,314 +0,0 @@
-/*
- * 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 _WIN32
-#include <unistd.h>
-#endif
-#include <ctype.h>
-#include <errno.h>
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <parc/algol/parc_ArrayList.h>
-#include <parc/algol/parc_List.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Object.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/config/configuration.h>
-#include <hicn/config/configurationFile.h>
-#include <hicn/config/controlRoot.h>
-#include <hicn/config/controlState.h>
-
-struct configuration_file {
-  Forwarder *forwarder;
-  const char *filename;
-  FILE *fh;
-
-  size_t linesRead;
-
-  // our custom state machine.
-  ControlState *controlState;
-};
-
-/*
- * Called by a command to dispatch the correct command
- */
-struct iovec *_writeRead(ControlState *state, struct iovec *msg) {
-  ConfigurationFile *configFile =
-      (ConfigurationFile *)controlState_GetUserdata(state);
-
-  parcAssertNotNull(msg, "Parameter msg must be non-null");
-  struct iovec *response = configuration_DispatchCommand(
-      forwarder_GetConfiguration(configFile->forwarder),
-      ((header_control_message *)msg[0].iov_base)->commandID, msg, 0);
-
-  return response;
-}
-
-/**
- * Removes leading whitespace (space + tab).
- *
- * If the string is all whitespace, the return value will point to the
- * terminating '\0'.
- *
- * @param [in] str A null-terminated c-string
- *
- * @retval non-null A pointer in to string of the first non-whitespace
- *
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-static char *_stripLeadingWhitespace(char *str) {
-  while (isspace(*str)) {
-    str++;
-  }
-  return str;
-}
-
-/**
- * Removes trailing whitespace
- *
- * Inserts a NULL after the last non-whitespace character, modiyfing the input
- * string.
- *
- * @param [in] str A null-terminated c-string
- *
- * @return non-null A pointer to the input string
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-static char *_stripTrailingWhitespace(char *str) {
-  char *p = str + strlen(str) - 1;
-  while (p > str && isspace(*p)) {
-    p--;
-  }
-
-  // cap it.  If no whitespace, p+1 == str + strlen(str), so will overwrite the
-  // current null.  If all whitespace p+1 == str+1.  For an empty string, p+1 =
-  // str.
-  *(p + 1) = 0;
-
-  // this does not catch the case where the entire string is whitespace
-  if (p == str && isspace(*p)) {
-    *p = 0;
-  }
-
-  return str;
-}
-
-/**
- * Removed leading and trailing whitespace
- *
- * Modifies the input string (may add a NULL at the end).  Will return
- * a pointer to the first non-whitespace character or the terminating NULL.
- *
- * @param [in] str A null-terminated c-string
- *
- * @return non-null A pointer in to the input string
- *
- * Example:
- * @code
- * {
- *     <#example#>
- * }
- * @endcode
- */
-static char *_trim(char *str) {
-  return _stripTrailingWhitespace(_stripLeadingWhitespace(str));
-}
-
-/**
- * Parse a string in to a PARCList with one word per element
- *
- * The string passed will be modified by inserting NULLs after each token.
- *
- * @param [in] str A c-string (will be modified)
- *
- * @retval non-null A PARCList where each item is a single word
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-static PARCList *_parseArgs(char *str) {
-  PARCList *list =
-      parcList(parcArrayList_Create(NULL), PARCArrayListAsPARCList);
-
-  const char delimiters[] = " \t";
-
-  char *token;
-  token = strtok(str, delimiters);
-  while (token != NULL) {
-    if (strlen(token) > 0) {
-      parcList_Add(list, strdup(token));
-    }
-    token = strtok(NULL, delimiters);
-  }
-  // while ((token = strsep(&str, delimiters)) != NULL) {
-  //	  parcList_Add(list, token);
-  //  }
-
-  return list;
-}
-
-// =============================================================
-
-static void _destroy(ConfigurationFile **configFilePtr) {
-  ConfigurationFile *configFile = *configFilePtr;
-  parcMemory_Deallocate((void **)&configFile->filename);
-
-  if (configFile->fh != NULL) {
-    fclose(configFile->fh);
-  }
-
-  controlState_Destroy(&configFile->controlState);
-}
-
-parcObject_ExtendPARCObject(ConfigurationFile, _destroy, NULL, NULL, NULL, NULL,
-                            NULL, NULL);
-
-parcObject_ImplementRelease(configurationFile, ConfigurationFile);
-
-ConfigurationFile *configurationFile_Create(Forwarder *forwarder,
-                                            const char *filename) {
-  parcAssertNotNull(forwarder, "Parameter hicn-fwd must be non-null");
-  parcAssertNotNull(filename, "Parameter filename must be non-null");
-
-  ConfigurationFile *configFile = parcObject_CreateInstance(ConfigurationFile);
-
-  if (configFile) {
-    configFile->linesRead = 0;
-    configFile->forwarder = forwarder;
-    configFile->filename =
-        parcMemory_StringDuplicate(filename, strlen(filename));
-    parcAssertNotNull(configFile->filename, "Could not copy string '%s'",
-                      filename);
-
-    // setup the control state for the command parser: last parameter NULL
-    // because
-    // writeRead still not implemented from configuration file.
-    configFile->controlState =
-        controlState_Create(configFile, _writeRead, false,
-                            SRV_CTRL_IP, SRV_CTRL_PORT);
-
-    // we do not register Help commands
-    controlState_RegisterCommand(configFile->controlState,
-                                 controlRoot_Create(configFile->controlState));
-
-    // open the file and make sure we can read it
-    configFile->fh = fopen(configFile->filename, "r");
-
-    if (configFile->fh) {
-      if (logger_IsLoggable(forwarder_GetLogger(forwarder),
-                            LoggerFacility_Config, PARCLogLevel_Debug)) {
-        logger_Log(forwarder_GetLogger(forwarder), LoggerFacility_Config,
-                   PARCLogLevel_Debug, __func__, "Open config file %s",
-                   configFile->filename);
-      }
-    } else {
-      if (logger_IsLoggable(forwarder_GetLogger(forwarder),
-                            LoggerFacility_Config, PARCLogLevel_Error)) {
-        logger_Log(forwarder_GetLogger(forwarder), LoggerFacility_Config,
-                   PARCLogLevel_Error, __func__,
-                   "Could not open config file %s: (%d) %s",
-                   configFile->filename, errno, strerror(errno));
-      }
-
-      // failure cleanup the object -- this nulls it so final return null be
-      // NULL
-      configurationFile_Release(&configFile);
-    }
-  }
-  return configFile;
-}
-
-bool configurationFile_Process(ConfigurationFile *configFile) {
-  parcAssertNotNull(configFile, "Parameter configFile must be non-null");
-
-  // default to a "true" return value and only set to false if we encounter an
-  // error.
-  bool success = true;
-
-#define BUFFERLEN 2048
-  char buffer[BUFFERLEN];
-
-  configFile->linesRead = 0;
-
-  // always clear errors and fseek to start of file in case we get called
-  // multiple times.
-  clearerr(configFile->fh);
-  rewind(configFile->fh);
-
-  while (success && fgets(buffer, BUFFERLEN, configFile->fh) != NULL) {
-    configFile->linesRead++;
-
-    char *stripedBuffer = _trim(buffer);
-    if (strlen(stripedBuffer) > 0) {
-      if (stripedBuffer[0] != '#') {
-        // not empty and not a comment
-
-        // _parseArgs will modify the string
-        char *copy =
-            parcMemory_StringDuplicate(stripedBuffer, strlen(stripedBuffer));
-        PARCList *args = _parseArgs(copy);
-        char output[8192];
-        CommandReturn result =
-            controlState_DispatchCommand(configFile->controlState, args, output, sizeof(output));
-
-        // we ignore EXIT from the configuration file
-        if (result == CommandReturn_Failure) {
-          if (logger_IsLoggable(forwarder_GetLogger(configFile->forwarder),
-                                LoggerFacility_Config, PARCLogLevel_Error)) {
-            logger_Log(forwarder_GetLogger(configFile->forwarder),
-                       LoggerFacility_Config, PARCLogLevel_Error, __func__,
-                       "Error on input file %s line %d: %s",
-                       configFile->filename, configFile->linesRead,
-                       stripedBuffer);
-          }
-          success = false;
-        }
-        for(int i = 0; i < parcList_Size(args); i++){
-          free(parcList_GetAtIndex(args, i));
-        }
-        parcList_Release(&args);
-        parcMemory_Deallocate((void **)&copy);
-      }
-    }
-  }
-
-  if (ferror(configFile->fh)) {
-    if (logger_IsLoggable(forwarder_GetLogger(configFile->forwarder),
-                          LoggerFacility_Config, PARCLogLevel_Error)) {
-      logger_Log(forwarder_GetLogger(configFile->forwarder),
-                 LoggerFacility_Config, PARCLogLevel_Error, __func__,
-                 "Error on input file %s line %d: (%d) %s",
-                 configFile->filename, configFile->linesRead, errno,
-                 strerror(errno));
-    }
-    success = false;
-  }
-
-  return success;
-}
diff --git a/hicn-light/src/hicn/config/configurationFile.h b/hicn-light/src/hicn/config/configurationFile.h
deleted file mode 100644
index b748dfc15..000000000
--- a/hicn-light/src/hicn/config/configurationFile.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * 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 configurationFile.h
- * @brief Accepts a filename and provides a means to read it into Configuration
- *
- * Reads a configuration file and converts the lines in to configuration
- * commands for use in Configuration.
- *
- * Accepts '#' lines as comments.  Skips blank and whitespace-only lines.
- *
- */
-
-#ifndef configurationFile_h
-#define configurationFile_h
-
-#include <hicn/core/forwarder.h>
-
-struct configuration_file;
-typedef struct configuration_file ConfigurationFile;
-
-/**
- * Creates a ConfigurationFile to prepare to process the file
- *
- * Prepares the object and opens the file.  Makes sure we can read the file.
- * Does not read the file or process any commands from the file.
- *
- * @param [in] hicn-light An allocated Forwarder to configure with the file
- * @param [in] filename The file to use
- *
- * @retval non-null An allocated ConfigurationFile that is readable
- * @retval null An error
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-ConfigurationFile *configurationFile_Create(Forwarder *forwarder,
-                                            const char *filename);
-
-/**
- * Reads the configuration file line-by-line and issues commands to
- * Configuration
- *
- * Reads the file line by line.  Skips '#' and blank lines.
- *
- * Will stop on the first error.  Lines already processed will not be un-done.
- *
- * @param [in] configFile An allocated ConfigurationFile
- *
- * @retval true The entire files was processed without error.
- * @retval false There was an error in the file.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-bool configurationFile_Process(ConfigurationFile *configFile);
-
-// void configurationFile_ProcessForwardingStrategies(Configuration * config,
-// ConfigurationFile * configFile);
-
-/**
- * Closes the underlying file and releases memory
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [in,out] configFilePtr An allocated ConfigurationFile that will be
- * NULL'd as output
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void configurationFile_Release(ConfigurationFile **configFilePtr);
-
-#endif /* defined(configurationFile_h) */
diff --git a/hicn-light/src/hicn/config/configurationListeners.c b/hicn-light/src/hicn/config/configurationListeners.c
deleted file mode 100644
index 31a0c4776..000000000
--- a/hicn-light/src/hicn/config/configurationListeners.c
+++ /dev/null
@@ -1,629 +0,0 @@
-/*
- * 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 _WIN32
-#include <arpa/inet.h>
-#include <unistd.h>
-#endif
-#include <parc/assert/parc_Assert.h>
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-
-#include <hicn/core/system.h>
-#include <hicn/utils/interfaceSet.h>
-#include <hicn/utils/punting.h>
-
-#include <hicn/config/configurationListeners.h>
-#include <hicn/io/hicnListener.h>
-#include <hicn/io/tcpListener.h>
-#include <hicn/io/udpListener.h>
-
-#include <hicn/utils/address.h>
-#include <hicn/utils/addressList.h>
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static bool _setupHicnListenerOnInet4(Forwarder *forwarder,
-                                      const char *symbolic, Address *address) {
-  bool success = false;
-#if !defined(__APPLE__) && !defined(_WIN32) && defined(PUNTING)
-  ListenerOps *ops =
-      hicnListener_CreateInet(forwarder, (char *)symbolic, address);
-  if (ops != NULL) {
-    success = listenerSet_Add(forwarder_GetListenerSet(forwarder), ops);
-    parcAssertTrue(success, "Failed to add Hicn listener %s to ListenerSet",
-                   symbolic);
-  }
-#endif /* __APPLE__ _WIN32*/
-  return success;
-}
-
-static bool _setupHicnListenerOnInet6(Forwarder *forwarder,
-                                      const char *symbolic, Address *address) {
-  bool success = false;
-#if !defined(__APPLE__) && !defined(_WIN32) && defined(PUNTING)
-  ListenerOps *ops =
-      hicnListener_CreateInet6(forwarder, (char *)symbolic, address);
-  if (ops != NULL) {
-    success = listenerSet_Add(forwarder_GetListenerSet(forwarder), ops);
-    parcAssertTrue(success, "Failed to add Hicn listener %s to ListenerSet",
-                   symbolic);
-  }
-#endif /* __APPLE__ _WIN32 */
-  return success;
-}
-
-bool configurationListeners_Remove(const Configuration *config) {
-  Logger *logger = configuration_GetLogger(config);
-  if (logger_IsLoggable(logger, LoggerFacility_Config, PARCLogLevel_Warning)) {
-    logger_Log(logger, LoggerFacility_Config, PARCLogLevel_Warning, __func__,
-               "Removing a listener not supported: ingress %u control %s");
-  }
-
-  return false;
-}
-
-bool _AddPuntingInet(const Configuration *config, Punting *punting,
-                     unsigned ingressId) {
-#if !defined(__APPLE__) && !defined(_WIN32) && defined(PUNTING)
-  struct sockaddr *addr = parcNetwork_SockAddress("0.0.0.0", 1234);
-  if (addr == NULL) {
-    printf("Error creating address\n");
-    return false;
-  }
-
-  Address *fakeAddr = addressCreateFromInet((struct sockaddr_in *)addr);
-
-  ListenerOps *listenerOps = listenerSet_Find(
-      forwarder_GetListenerSet(configuration_GetForwarder(config)), ENCAP_HICN,
-      fakeAddr);
-  addressDestroy(&fakeAddr);
-
-  if (listenerOps == NULL) {
-    printf("the main listener (IPV4) does not exists\n");
-    return false;
-  }
-
-  struct sockaddr_in puntingAddr;
-
-  Address *address = puntingGetAddress(punting);
-  if (address == NULL) return false;
-
-  bool res = addressGetInet(address, &puntingAddr);
-  if (!res) {
-    printf("unable to read the punting address\n");
-    return false;
-  }
-
-  char prefix[INET_ADDRSTRLEN];
-  inet_ntop(AF_INET, &(puntingAddr.sin_addr), prefix, INET_ADDRSTRLEN);
-
-  char len[5];
-  sprintf(len, "%d", puntingPrefixLen(punting));
-
-  char *prefixStr =
-      malloc(strlen(prefix) + strlen(len) + 2);  //+1 for the zero-terminator
-  if (prefixStr == NULL) {
-    printf("error while create the prefix string\n");
-    return false;
-  }
-  strcpy(prefixStr, prefix);
-  strcat(prefixStr, "/");
-  strcat(prefixStr, len);
-
-  res = hicnListener_Punting(listenerOps, prefixStr);
-  if (!res) {
-    printf("error while adding the punting rule\n");
-    return false;
-  }
-
-  return true;
-#else
-  return false;
-#endif
-}
-
-bool _AddPuntingInet6(const Configuration *config, Punting *punting,
-                      unsigned ingressId) {
-#if !defined(__APPLE__) && !defined(_WIN32) && defined(PUNTING)
-  struct sockaddr *addr = parcNetwork_SockAddress("0::0", 1234);
-  if (addr == NULL) {
-    printf("Error creating address\n");
-    return false;
-  }
-
-  Address *fakeAddr = addressCreateFromInet6((struct sockaddr_in6 *)addr);
-
-  // comments:
-  // EncapType: I use the Hicn encap since the punting is available only for
-  // Hicn listeners LocalAddress: The only listern for which we need punting
-  // rules is the main one, which has no address
-  //              so I create a fake empty address. This need to be consistent
-  //              with the address set at creation time
-
-  ListenerOps *listenerOps = listenerSet_Find(
-      forwarder_GetListenerSet(configuration_GetForwarder(config)), ENCAP_HICN,
-      fakeAddr);
-  addressDestroy(&fakeAddr);
-
-  if (listenerOps == NULL) {
-    printf("the main listener does not exists\n");
-    return false;
-  }
-
-  struct sockaddr_in6 puntingAddr;
-  bool res = addressGetInet6(puntingGetAddress(punting), &puntingAddr);
-  if (!res) {
-    printf("unable to read the punting address\n");
-    return false;
-  }
-
-  char prefix[INET6_ADDRSTRLEN];
-  inet_ntop(AF_INET6, &(puntingAddr.sin6_addr), prefix, INET6_ADDRSTRLEN);
-
-  char len[5];
-  sprintf(len, "%d", puntingPrefixLen(punting));
-
-  char *prefixStr =
-      malloc(strlen(prefix) + strlen(len) + 2);  //+1 for the zero-terminator
-  if (prefixStr == NULL) {
-    printf("error while create the prefix string\n");
-    return false;
-  }
-  strcpy(prefixStr, prefix);
-  strcat(prefixStr, "/");
-  strcat(prefixStr, len);
-
-  res = hicnListener_Punting(listenerOps, prefixStr);
-  if (!res) {
-    printf("error while adding the punting rule\n");
-    return false;
-  }
-
-  return true;
-#else
-  return false;
-#endif
-}
-
-//=============     LIGHT COMMAN    ===============
-
-static bool _addEther(Configuration *config, add_listener_command *control,
-                      unsigned ingressId) {
-  // Not implemented
-  return false;
-}
-
-/*
- *  Create a new IPV4/TCP listener.
- *
- * @param [in,out] forwarder   The hicn-light forwarder instance
- * @param [in] listenerName    The name of the listener
- * @param [in] addr4           The ipv4 address in network byte order
- * @param [in] port            The port number in network byte order
- * @param [in] interfaceName   The name of the interface to bind the socket
- *
- * return true if success, false otherwise
- */
-static bool _setupTcpListenerOnInet(Forwarder *forwarder, char *listenerName, ipv4_addr_t *addr4,
-                                    uint16_t *port, char *interfaceName) {
-  parcAssertNotNull(listenerName, "Parameter listenerName must be non-null");
-
-  bool success = false;
-
-  struct sockaddr_in addr;
-  memset(&addr, 0, sizeof(addr));
-  addr.sin_family = AF_INET;
-  addr.sin_port = *port;
-  addr.sin_addr.s_addr = *addr4;
-
-  ListenerOps *ops = tcpListener_CreateInet(forwarder, listenerName, addr, interfaceName);
-  if (ops) {
-    success = listenerSet_Add(forwarder_GetListenerSet(forwarder), ops);
-#if 0
-    parcAssertTrue(success, "Failed to add TCP listener on %s to ListenerSet",
-                   addressToString(ops->getListenAddress(ops)));
-#endif
-  }
-  return success;
-}
-
-
-/*
- *  Create a new IPV4/UDP listener.
- *
- * @param [in,out] forwarder   The hicn-light forwarder instance
- * @param [in] listenerName    The name of the listener
- * @param [in] addr4           The ipv4 address in network byte order
- * @param [in] port            The port number in network byte order
- * @param [in] interfaceName   The name of the interface to bind the socket
- *
- * return true if success, false otherwise
- */
-static bool _setupUdpListenerOnInet(Forwarder *forwarder, char *listenerName, ipv4_addr_t *addr4,
-                                    uint16_t *port, char *interfaceName) {
-  bool success = false;
-
-  struct sockaddr_in addr;
-  memset(&addr, 0, sizeof(addr));
-  addr.sin_family = AF_INET;
-  addr.sin_port = *port;
-  addr.sin_addr.s_addr = *addr4;
-
-  ListenerOps *ops = udpListener_CreateInet(forwarder, listenerName, addr, interfaceName);
-  if (ops) {
-    success = listenerSet_Add(forwarder_GetListenerSet(forwarder), ops);
-#if 0
-    parcAssertTrue(success, "Failed to add UDP listener on %s to ListenerSet",
-                   addressToString(ops->getListenAddress(ops)));
-#endif
-  }
-  return success;
-}
-
-
-/*
- *  Create a new IPV6/TCP listener.
- *
- * @param [in,out] forwarder   The hicn-light forwarder instance
- * @param [in] addr6           The ipv6 address in network byte order
- * @param [in] port            The port number in network byte order
- * @param [in] interfaceName   The name of the interface to bind the socket
- *
- * return true if success, false otherwise
- */
-static bool _setupTcpListenerOnInet6Light(Forwarder *forwarder, char *listenerName,
-                                          ipv6_addr_t *addr6, uint16_t *port, char *interfaceName,
-                                          uint32_t scopeId) {
-  bool success = false;
-
-  struct sockaddr_in6 addr;
-  memset(&addr, 0, sizeof(addr));
-  addr.sin6_family = AF_INET6;
-  addr.sin6_port = *port;
-  addr.sin6_addr = *addr6;
-  addr.sin6_scope_id = scopeId;
-
-  ListenerOps *ops = tcpListener_CreateInet6(forwarder, listenerName, addr, interfaceName);
-  if (ops) {
-    success = listenerSet_Add(forwarder_GetListenerSet(forwarder), ops);
-#if 0
-    parcAssertTrue(success, "Failed to add TCP6 listener on %s to ListenerSet",
-                   addressToString(ops->getListenAddress(ops)));
-#endif
-  }
-  return success;
-}
-
-
-/*
- *  Create a new IPV6/UDP listener.
- *
- * @param [in,out] forwarder   The hicn-light forwarder instance
- * @param [in] listenerName    The name of the listener
- * @param [in] addr6           The ipv6 address in network byte order
- * @param [in] port            The port number in network byte order
- * @param [in] interfaceName   The name of the interface to bind the socket
- *
- * return true if success, false otherwise
- */
-static bool _setupUdpListenerOnInet6Light(Forwarder *forwarder, char *listenerName,
-                                          ipv6_addr_t *addr6, uint16_t *port, char *interfaceName) {
-  bool success = false;
-
-  struct sockaddr_in6 addr;
-  memset(&addr, 0, sizeof(addr));
-  addr.sin6_family = AF_INET6;
-  addr.sin6_port = *port;
-  addr.sin6_addr = *addr6;
-  addr.sin6_scope_id = 0;
-
-  ListenerOps *ops = udpListener_CreateInet6(forwarder, listenerName, addr, interfaceName);
-  if (ops) {
-    success = listenerSet_Add(forwarder_GetListenerSet(forwarder), ops);
-#if 0
-    parcAssertTrue(success, "Failed to add UDP6 listener on %s to ListenerSet",
-                   addressToString(ops->getListenAddress(ops)));
-#endif
-  }
-  return success;
-}
-
-/*
- *  Create a new HICN listener.
- *
- * @param [in] config   The configuration
- * @param [in] control  The control command
- * @param [in] port     The connection id of the command
- *
- * return true if success, false otherwise
- */
-bool _addHicn(Configuration *config, add_listener_command *control,
-              unsigned ingressId) {
-  bool success = false;
-  const char *symbolic = control->symbolic;
-  Address *localAddress = NULL;
-
-  switch (control->addressType) {
-    case ADDR_INET: {
-      localAddress =
-          addressFromInaddr4Port(&control->address.v4.as_u32, &control->port);
-      success = _setupHicnListenerOnInet4(configuration_GetForwarder(config),
-                                          symbolic, localAddress);
-      break;
-    }
-
-    case ADDR_INET6: {
-      localAddress =
-          addressFromInaddr6Port(&control->address.v6.as_in6addr, &control->port);
-      success = _setupHicnListenerOnInet6(configuration_GetForwarder(config),
-                                          symbolic, localAddress);
-      break;
-    }
-
-    default:
-      if (logger_IsLoggable(configuration_GetLogger(config),
-                            LoggerFacility_Config, PARCLogLevel_Warning)) {
-        logger_Log(configuration_GetLogger(config), LoggerFacility_Config,
-                   PARCLogLevel_Warning, __func__,
-                   "Unsupported address type for HICN (ingress id %u): "
-                   "must be either IPV4 or IPV6",
-                   ingressId);
-      }
-      break;
-  }
-
-  if (success == true && localAddress != NULL) {
-    if (logger_IsLoggable(configuration_GetLogger(config),
-                          LoggerFacility_Config, PARCLogLevel_Info)) {
-      char * str = addressToString(localAddress);
-      logger_Log(configuration_GetLogger(config), LoggerFacility_Config,
-                 PARCLogLevel_Info, __func__,
-                 "Setup hicn listener on address %s",
-                 str);
-      parcMemory_Deallocate((void **)&str);
-    }
-  }
-
-  addressDestroy(&localAddress);
-
-  return success;
-}
-
-bool _addIP(Configuration *config, add_listener_command *control,
-            unsigned ingressId) {
-  bool success = false;
-  char *symbolic = control->symbolic;
-
-  switch (control->addressType) {
-    case ADDR_INET: {
-
-      if (control->connectionType == UDP_CONN) {
-        success =
-            _setupUdpListenerOnInet(configuration_GetForwarder(config), symbolic,
-                                    &control->address.v4.as_u32, &control->port, control->interfaceName);
-      } else if (control->connectionType == TCP_CONN) {
-        success =
-            _setupTcpListenerOnInet(configuration_GetForwarder(config), symbolic,
-                                    &control->address.v4.as_u32, &control->port, control->interfaceName);
-      }
-      break;
-    }
-
-    case ADDR_INET6: {
-      if (control->connectionType == UDP_CONN) {
-        success = _setupUdpListenerOnInet6Light(
-            configuration_GetForwarder(config), symbolic, &control->address.v6.as_in6addr,
-            &control->port, control->interfaceName);
-      } else if (control->connectionType == TCP_CONN) {
-        success = _setupTcpListenerOnInet6Light(
-            configuration_GetForwarder(config), symbolic, &control->address.v6.as_in6addr,
-            &control->port, control->interfaceName, 0);
-      }
-      break;
-    }
-
-    default:
-      if (logger_IsLoggable(configuration_GetLogger(config),
-                            LoggerFacility_Config, PARCLogLevel_Warning)) {
-        char *addrStr = utils_CommandAddressToString(
-            control->addressType, &control->address, &control->port);
-        logger_Log(
-            configuration_GetLogger(config), LoggerFacility_Config,
-            PARCLogLevel_Warning, __func__,
-            "Unsupported address type for IP encapsulation ingress id %u: %s",
-            ingressId, addrStr);
-        parcMemory_Deallocate((void **)&addrStr);
-      }
-      break;
-  }
-
-  if (success) {
-    if (logger_IsLoggable(configuration_GetLogger(config),
-                          LoggerFacility_Config, PARCLogLevel_Info)) {
-      char *addrStr = utils_CommandAddressToString(
-          control->addressType, &control->address, &control->port);
-      logger_Log(configuration_GetLogger(config), LoggerFacility_Config,
-                 PARCLogLevel_Info, __func__, "Setup listener on address %s",
-                 addrStr);
-      parcMemory_Deallocate((void **)&addrStr);
-    }
-  }
-
-  return success;
-}
-
-struct iovec *configurationListeners_Add(Configuration *config,
-                                         struct iovec *request,
-                                         unsigned ingressId) {
-  header_control_message *header = request[0].iov_base;
-  add_listener_command *control = request[1].iov_base;
-
-  bool success = false;
-
-  ListenerSet *listenerSet = forwarder_GetListenerSet(configuration_GetForwarder(config));
-  int listenerId = listenerSet_FindIdByListenerName(listenerSet, control->symbolic);
-
-  if (listenerId < 0) {
-    if (control->listenerMode == ETHER_MODE) {
-      parcTrapNotImplemented("Add Ethernet Listener is not supported");
-      success = _addEther(config, control, ingressId);
-      // it is a failure
-    } else if (control->listenerMode == IP_MODE) {
-      success = _addIP(config, control, ingressId);
-    } else if (control->listenerMode == HICN_MODE) {
-      success = _addHicn(config, control, ingressId);
-    } else {
-      Logger *logger = configuration_GetLogger(config);
-      if (logger_IsLoggable(logger, LoggerFacility_Config,
-                            PARCLogLevel_Warning)) {
-        logger_Log(logger, LoggerFacility_Config, PARCLogLevel_Warning, __func__,
-                   "Unsupported encapsulation mode (ingress id %u)", ingressId);
-      }
-    }
-  }
-
-  // generate ACK/NACK
-  struct iovec *response;
-
-  if (success) {  // ACK
-    response = utils_CreateAck(header, control, sizeof(add_listener_command));
-  } else {  // NACK
-    response = utils_CreateNack(header, control, sizeof(add_listener_command));
-  }
-
-  return response;
-}
-
-struct iovec *configurationListeners_AddPunting(Configuration *config,
-                                                struct iovec *request,
-                                                unsigned ingressId) {
-  header_control_message *header = request[0].iov_base;
-  add_punting_command *control = request[1].iov_base;
-
-  const char *symbolicOrConnid = control->symbolicOrConnid;
-  uint32_t len = control->len;
-  in_port_t port = htons(1234);
-  bool success = false;
-
-  if (control->addressType == ADDR_INET) {
-    Address *address = addressFromInaddr4Port(&control->address.v4.as_u32, &port);
-    Punting *punting = puntingCreate(symbolicOrConnid, address, len);
-    success = _AddPuntingInet(config, punting, ingressId);
-    addressDestroy(&address);
-  } else if (control->addressType == ADDR_INET6) {
-    Address *address = addressFromInaddr6Port(&control->address.v6.as_in6addr, &port);
-    Punting *punting = puntingCreate(symbolicOrConnid, address, len);
-    success = _AddPuntingInet6(config, punting, ingressId);
-    addressDestroy(&address);
-  } else {
-    printf("Invalid IP type.\n");  // will generate a Nack
-    return utils_CreateNack(header, control, sizeof(add_punting_command));
-  }
-
-  // generate ACK/NACK
-  struct iovec *response;
-  if (success) {  // ACK
-    response = utils_CreateAck(header, control, sizeof(add_punting_command));
-  } else {  // NACK
-    response = utils_CreateNack(header, control, sizeof(add_punting_command));
-  }
-
-  return response;
-}
-
-//===========================       INITIAL LISTENERS ====================
-
-static void _setupListenersOnAddress(Forwarder *forwarder, char *listenerName,
-                                     const Address *address, uint16_t port,
-                                     char *interfaceName) {
-  address_type type = addressGetType(address);
-  switch (type) {
-    case ADDR_INET: {
-      struct sockaddr_in tmp;
-      addressGetInet(address, &tmp);
-      _setupTcpListenerOnInet(forwarder, listenerName, &tmp.sin_addr.s_addr, &port, interfaceName);
-      break;
-    }
-
-    case ADDR_INET6: {
-      struct sockaddr_in6 tmp;
-      addressGetInet6(address, &tmp);
-      _setupTcpListenerOnInet6Light(forwarder, listenerName, &tmp.sin6_addr, &port, interfaceName,
-                                    tmp.sin6_scope_id);
-      break;
-    }
-
-    case ADDR_LINK:
-      // not used
-      break;
-
-    default:
-      // dont' know how to handle this, so no listeners
-      break;
-  }
-}
-
-void configurationListeners_SetupAll(const Configuration *config, uint16_t port,
-                                     const char *localPath) {
-  Forwarder *forwarder = configuration_GetForwarder(config);
-  InterfaceSet *set = system_Interfaces(forwarder);
-
-  size_t interfaceSetLen = interfaceSetLength(set);
-  for (size_t i = 0; i < interfaceSetLen; i++) {
-    Interface *iface = interfaceSetGetByOrdinalIndex(set, i);
-
-    const AddressList *addresses = interfaceGetAddresses(iface);
-    size_t addressListLen = addressListLength(addresses);
-
-    for (size_t j = 0; j < addressListLen; j++) {
-      const Address *address = addressListGetItem(addresses, j);
-
-      // Do not start on link address
-      char listenerName[SYMBOLIC_NAME_LEN];
-#if defined(__ANDROID__) || defined(_WIN32)
-      snprintf(listenerName, SYMBOLIC_NAME_LEN, "local_%zu", i);
-#else
-      snprintf(listenerName, SYMBOLIC_NAME_LEN, "local_%ld", i);
-#endif
-      if (addressGetType(address) != ADDR_LINK) {
-        _setupListenersOnAddress(forwarder, listenerName, address, port,
-                                 (char *)interfaceGetName(iface));
-      }
-    }
-  }
-
-  interfaceSetDestroy(&set);
-}
-
-void configurationListeners_SetutpLocalIPv4(const Configuration *config,
-                                            uint16_t port) {
-  Forwarder *forwarder = configuration_GetForwarder(config);
-  in_addr_t addr = inet_addr("127.0.0.1");
-  uint16_t network_byte_order_port = htons(port);
-
-  char listenerNameUdp[SYMBOLIC_NAME_LEN] = "lo_udp";
-  char listenerNameTcp[SYMBOLIC_NAME_LEN] = "lo_tcp";
-  char *loopback_interface = "lo";
-  _setupUdpListenerOnInet(forwarder, listenerNameUdp,(ipv4_addr_t *)&(addr),
-                          &network_byte_order_port, loopback_interface);
-  _setupTcpListenerOnInet(forwarder, listenerNameTcp, (ipv4_addr_t *)&(addr),
-                          &network_byte_order_port, loopback_interface);
-}
diff --git a/hicn-light/src/hicn/config/configurationListeners.h b/hicn-light/src/hicn/config/configurationListeners.h
deleted file mode 100644
index b09ad5167..000000000
--- a/hicn-light/src/hicn/config/configurationListeners.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * 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 configurationListeners.h
- * @brief Configuration routines related to Listeners
- *
- * Adding and removing listeners.
- *
- */
-
-#ifndef configurationListeners_h
-#define configurationListeners_h
-
-#include <hicn/config/configuration.h>
-#include <hicn/core/forwarder.h>
-
-#include <hicn/utils/address.h>
-
-/**
- * Setup udp, tcp, and local listeners
- *
- *   Will bind to all available IP protocols on the given port.
- *   Does not add Ethernet listeners.
- *
- * @param port is the UPD and TCP port to use
- * @param localPath is the AF_UNIX path to use, if NULL no AF_UNIX listener is
- * setup
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void configurationListeners_SetupAll(const Configuration *config, uint16_t port,
-                                     const char *localPath);
-
-void configurationListeners_SetutpLocalIPv4(const Configuration *config,
-                                            uint16_t port);
-
-bool configurationListeners_Remove(const Configuration *config);
-
-// light functions
-
-/**
- * Add new listener.
- *
- * @param request The request coming from hicnLightControl or the
- *                configuration file. The bytes in the request are
- *                ordered following the network byte order convention.
- *
- * @param ingressId The connection id of the incoming request.
- */
-struct iovec *configurationListeners_Add(Configuration *config,
-                                         struct iovec *request,
-                                         unsigned ingressId);
-
-struct iovec *configurationListeners_AddPunting(Configuration *config,
-                                                struct iovec *request,
-                                                unsigned ingressId);
-
-#endif /* defined(configurationListeners_h) */
diff --git a/hicn-light/src/hicn/config/configuration_file.c b/hicn-light/src/hicn/config/configuration_file.c
new file mode 100644
index 000000000..2e8e7a6ac
--- /dev/null
+++ b/hicn-light/src/hicn/config/configuration_file.c
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <hicn/config/configuration_file.h>
+#include <hicn/util/sstrncpy.h>
+
+#include "commands.h"
+#include "parse.h"
+
+#define BUFFERLEN 2048
+
+static char *_trim(char *str) {
+  char *end;
+
+  // Trim leading space
+  while (isspace((unsigned char)*str)) str++;
+
+  if (*str == 0)  // All spaces?
+    return str;
+
+  // Trim trailing space
+  end = str + strnlen_s(str, BUFFERLEN) - 1;
+  while (end > str && isspace((unsigned char)*end)) end--;
+
+  // Write new null terminator character
+  end[1] = '\0';
+
+  return str;
+}
+
+bool configuration_file_process(forwarder_t *forwarder, const char *filename) {
+  assert(forwarder);
+  assert(filename);
+
+  int linesRead = 0;
+  FILE *f = fopen(filename, "r");
+  if (!f) {
+    ERROR("Could not open configuration file %s: (%d) %s", filename, errno,
+          strerror(errno));
+    goto ERR_OPEN;
+  }
+  DEBUG("Opening configuration file %s", filename);
+
+  char buffer[BUFFERLEN];
+  bool success = true;
+  // TODO(eloparco): We could use a fake socket since we only need the vft
+  hc_sock_t *s = hc_sock_create_forwarder(HICNLIGHT_NG);
+  if (!s) {
+    ERROR("Could not create socket");
+    goto ERR_SOCK;
+  }
+
+  while (success && fgets(buffer, BUFFERLEN, f) != NULL) {
+    linesRead++;
+
+    char *cmd = _trim(buffer);
+    if (strnlen_s(cmd, BUFFERLEN) <= 0) continue;
+    if (cmd[0] == '#') continue;
+
+    INFO("Processing command: %s", cmd);
+    hc_command_t command = {};
+    if (parse(cmd, &command) < 0) {
+      ERROR("Error parsing command : '%s'", cmd);
+      continue;
+    }
+
+    // TODO(eloparco): Handle all commands
+    hc_result_t *result = NULL;
+    if (command.action == ACTION_CREATE) {
+      if (command.object.type == OBJECT_LISTENER) {
+        result = hc_listener_create_conf(s, &command.object.listener);
+      } else if (command.object.type == OBJECT_CONNECTION) {
+        result = hc_connection_create_conf(s, &command.object.connection);
+      } else if (command.object.type == OBJECT_ROUTE) {
+        result = hc_route_create_conf(s, &command.object.route);
+      } else if (command.object.type == OBJECT_LOCAL_PREFIX) {
+        result = hc_strategy_add_local_prefix_conf(s, &command.object.strategy);
+      }
+    } else if (command.action == ACTION_SET) {
+      if (command.object.type == OBJECT_STRATEGY) {
+        result = hc_strategy_set_conf(s, &command.object.strategy);
+      }
+    }
+    if (result == NULL) {
+      ERROR("Command '%s' not supported", cmd);
+      continue;
+    }
+
+    size_t _unused;
+    hc_msg_t *msg = hc_result_get_msg(s, result);
+    command_type_t cmd_id = hc_result_get_cmd_id(s, result);
+    bool success = hc_result_get_success(s, result);
+    if (success == false) {
+      ERROR("Error serializing command : '%s'", cmd);
+      continue;
+    }
+
+    command_process(forwarder, (uint8_t *)msg, cmd_id, CONNECTION_ID_UNDEFINED,
+                    &_unused);
+    hc_result_free(result);
+  }
+  hc_sock_free(s);
+
+  if (ferror(f)) {
+    ERROR("Error on input file %s line %d: (%d) %s", filename, linesRead, errno,
+          strerror(errno));
+    goto ERR_READ;
+  }
+  fclose(f);
+  return true;
+
+ERR_SOCK:
+  hc_sock_free(s);
+ERR_READ:
+  fclose(f);
+ERR_OPEN:
+  return false;
+}
diff --git a/hicn-light/src/hicn/config/configuration_file.h b/hicn-light/src/hicn/config/configuration_file.h
new file mode 100644
index 000000000..4d9535ab7
--- /dev/null
+++ b/hicn-light/src/hicn/config/configuration_file.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file configuration_file.h
+ * @brief Accepts a filename and provides a means to read it into Configuration
+ *
+ * Reads a configuration file and converts the lines in to configuration
+ * commands for use in Configuration.
+ *
+ * Accepts '#' lines as comments.  Skips blank and whitespace-only lines.
+ *
+ */
+
+#ifndef configuration_file_h
+#define configuration_file_h
+
+#include <hicn/core/forwarder.h>
+
+/**
+ * Configure hicn-light by reading a configuration file line-by-line and
+ * issueing commands to the forwarder.
+ *
+ * The configuration file is a set of lines, just like used in hicnLightControl.
+ * You need to have "add listener" lines in the file to receive connections. No
+ * default listeners are configured.
+ *
+ * This function reads the file line by line, skipping '#' and blank lines, and
+ * will stop on the first error. Lines already processed will not be un-done.
+ *
+ * @param[in] forwarder An allocated forwarder_t
+ * @param[in] filename The path to the configuration file
+ *
+ * @retval true The entire files was processed without error.
+ * @retval false There was an error in the file.
+ *
+ * Example:
+ * @code
+ * <#example#>
+ * @endcode
+ */
+bool configuration_file_process(forwarder_t* forwarder, const char* filename);
+
+#endif /* defined(configuration_file_h) */
diff --git a/hicn-light/src/hicn/config/controlAdd.c b/hicn-light/src/hicn/config/controlAdd.c
deleted file mode 100644
index cac8e7913..000000000
--- a/hicn-light/src/hicn/config/controlAdd.c
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <parc/assert/parc_Assert.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/config/controlAdd.h>
-#include <hicn/config/controlAddConnection.h>
-#include <hicn/config/controlAddListener.h>
-#include <hicn/config/controlAddPunting.h>
-#include <hicn/config/controlAddRoute.h>
-#ifdef WITH_POLICY
-#include <hicn/config/controlAddPolicy.h>
-#endif /* WITH_POLICY */
-
-// ===================================================
-
-static void _controlAdd_Init(CommandParser *parser, CommandOps *ops);
-
-static CommandReturn _controlAdd_Execute(CommandParser *parser, 
-                                         CommandOps *ops,
-                                         PARCList *args,
-                                         char *output,
-                                         size_t output_size);
-
-static CommandReturn _controlAdd_HelpExecute(CommandParser *parser,
-                                             CommandOps *ops,
-                                             PARCList *args,
-                                             char *output,
-                                             size_t output_size);
-
-// ===================================================
-
-static const char *command_add = "add";
-static const char *help_command_add = "help add";
-
-CommandOps *webControlAdd_Create(ControlState *state) {
-  return commandOps_Create(state, command_add, _controlAdd_Init,
-                           _controlAdd_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlAdd_CreateHelp(ControlState *state) {
-  return commandOps_Create(state, help_command_add, NULL,
-                           _controlAdd_HelpExecute, commandOps_Destroy);
-}
-
-// ===================================================
-
-static CommandReturn _controlAdd_HelpExecute(CommandParser *parser,
-                                             CommandOps *ops,
-                                             PARCList *args,
-                                             char *output,
-                                             size_t output_size) {
-  CommandOps *ops_add_connection = controlAddConnection_Create(NULL);
-  CommandOps *ops_add_route = controlAddRoute_Create(NULL);
-  CommandOps *ops_add_punting = controlAddPunting_Create(NULL);
-  CommandOps *ops_add_listener = controlAddListener_Create(NULL);
-#ifdef WITH_POLICY
-  CommandOps *ops_add_policy = controlAddPolicy_Create(NULL);
-#endif /* WITH_POLICY */
-#ifdef WITH_POLICY
-  snprintf(output, output_size, "Available commands:\n   %s\n   %s\n   %s\n   %s\n   %s\n\n",
-                                  ops_add_connection->command,
-                                  ops_add_route->command,
-                                  ops_add_punting->command,
-                                  ops_add_listener->command,
-                                  ops_add_policy->command);
-#else
-  snprintf(output, output_size, "Available commands:\n   %s\n   %s\n   %s\n   %s\n\n",
-                                  ops_add_connection->command,
-                                  ops_add_route->command,
-                                  ops_add_punting->command,
-                                  ops_add_listener->command);
-
-#endif /* WITH_POLICY */
-
-  commandOps_Destroy(&ops_add_connection);
-  commandOps_Destroy(&ops_add_route);
-  commandOps_Destroy(&ops_add_punting);
-  commandOps_Destroy(&ops_add_listener);
-#ifdef WITH_POLICY
-  commandOps_Destroy(&ops_add_policy);
-#endif /* WITH_POLICY */
-  return CommandReturn_Success;
-}
-
-static void _controlAdd_Init(CommandParser *parser, CommandOps *ops) {
-  ControlState *state = ops->closure;
-  controlState_RegisterCommand(state, controlAddListener_HelpCreate(state));
-  controlState_RegisterCommand(state, controlAddListener_Create(state));
-  controlState_RegisterCommand(state, controlAddConnection_HelpCreate(state));
-  controlState_RegisterCommand(state, controlAddRoute_HelpCreate(state));
-  controlState_RegisterCommand(state, controlAddConnection_Create(state));
-  controlState_RegisterCommand(state, controlAddRoute_Create(state));
-  controlState_RegisterCommand(state, controlAddPunting_Create(state));
-  controlState_RegisterCommand(state, controlAddPunting_HelpCreate(state));
-#ifdef WITH_POLICY
-  controlState_RegisterCommand(state, controlAddPolicy_HelpCreate(state));
-  controlState_RegisterCommand(state, controlAddPolicy_Create(state));
-#endif /* WITH_POLICY */
-}
-
-static CommandReturn _controlAdd_Execute(CommandParser *parser,
-                                         CommandOps *ops,
-                                         PARCList *args,
-                                         char *output,
-                                         size_t output_size) {
-  return _controlAdd_HelpExecute(parser, ops, args, output, output_size);
-}
diff --git a/hicn-light/src/hicn/config/controlAddConnection.c b/hicn-light/src/hicn/config/controlAddConnection.c
deleted file mode 100644
index eed37f3ad..000000000
--- a/hicn-light/src/hicn/config/controlAddConnection.c
+++ /dev/null
@@ -1,450 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <ctype.h>
-#include <parc/assert/parc_Assert.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-
-#include <hicn/config/controlAddConnection.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-// ===================================================
-
-static void _controlAddConnection_Init(CommandParser *parser, CommandOps *ops);
-static CommandReturn _controlAddConnection_HelpExecute(CommandParser *parser,
-                                                       CommandOps *ops,
-                                                       PARCList *args,
-                                                       char *output,
-                                                       size_t output_size);
-static CommandReturn _controlAddConnection_Execute(CommandParser *parser,
-                                                   CommandOps *ops,
-                                                   PARCList *args,
-                                                   char *output,
-                                                   size_t output_size);
-
-// ===================================================
-
-#ifdef __linux__
-static CommandReturn _controlAddConnection_HicnHelpExecute(CommandParser *parser,
-                                                           CommandOps *ops,
-                                                           PARCList *args,
-                                                           char *output,
-                                                           size_t output_size);
-static CommandReturn _controlAddConnection_HicnExecute(CommandParser *parser,
-                                                       CommandOps *ops,
-                                                       PARCList *args,
-                                                       char *output,
-                                                       size_t output_size);
-#endif
-
-static CommandReturn _controlAddConnection_UdpHelpExecute(CommandParser *parser,
-                                                          CommandOps *ops,
-                                                          PARCList *args,
-                                                          char *output,
-                                                          size_t output_size);
-static CommandReturn _controlAddConnection_UdpExecute(CommandParser *parser,
-                                                      CommandOps *ops,
-                                                      PARCList *args,
-                                                      char *output,
-                                                      size_t output_size);
-
-static CommandReturn _controlAddConnection_TcpHelpExecute(CommandParser *parser,
-                                                          CommandOps *ops,
-                                                          PARCList *args,
-                                                          char *output,
-                                                          size_t output_size);
-static CommandReturn _controlAddConnection_TcpExecute(CommandParser *parser,
-                                                      CommandOps *ops,
-                                                      PARCList *args,
-                                                      char *output,
-                                                      size_t output_size);
-
-// ===================================================
-
-static const char *_commandAddConnection = "add connection";
-#ifdef __linux__
-static const char *_commandAddConnectionHicn = "add connection hicn";
-#endif
-static const char *_commandAddConnectionUdp = "add connection udp";
-static const char *_commandAddConnectionTcp = "add connection tcp";
-static const char *_commandAddConnectionHelp = "help add connection";
-#ifdef __linux__
-static const char *_commandAddConnectionHicnHelp = "help add connection hicn";
-#endif
-static const char *_commandAddConnectionUdpHelp = "help add connection udp";
-static const char *_commandAddConnectionTcpHelp = "help add connection tcp";
-
-// ===================================================
-
-CommandOps *controlAddConnection_Create(ControlState *state) {
-  return commandOps_Create(state, _commandAddConnection,
-                           _controlAddConnection_Init,
-                           _controlAddConnection_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlAddConnection_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandAddConnectionHelp, NULL,
-                           _controlAddConnection_HelpExecute,
-                           commandOps_Destroy);
-}
-
-// ===================================================
-
-#ifdef __linux__
-static CommandOps *_controlAddConnection_HicnCreate(ControlState *state) {
-  return commandOps_Create(state, _commandAddConnectionHicn, NULL,
-                           _controlAddConnection_HicnExecute,
-                           commandOps_Destroy);
-}
-#endif
-
-static CommandOps *_controlAddConnection_UdpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandAddConnectionUdp, NULL,
-                           _controlAddConnection_UdpExecute,
-                           commandOps_Destroy);
-}
-
-static CommandOps *_controlAddConnection_TcpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandAddConnectionTcp, NULL,
-                           _controlAddConnection_TcpExecute,
-                           commandOps_Destroy);
-}
-
-// ===================================================
-#ifdef __linux__
-static CommandOps *_controlAddConnection_HicnHelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandAddConnectionHicnHelp, NULL,
-                           _controlAddConnection_HicnHelpExecute,
-                           commandOps_Destroy);
-}
-#endif
-
-static CommandOps *_controlAddConnection_UdpHelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandAddConnectionUdpHelp, NULL,
-                           _controlAddConnection_UdpHelpExecute,
-                           commandOps_Destroy);
-}
-
-static CommandOps *_controlAddConnection_TcpHelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandAddConnectionTcpHelp, NULL,
-                           _controlAddConnection_TcpHelpExecute,
-                           commandOps_Destroy);
-}
-
-// ===================================================
-
-static CommandReturn _controlAddConnection_HelpExecute(CommandParser *parser,
-                                                       CommandOps *ops,
-                                                       PARCList *args,
-                                                       char *output,
-                                                       size_t output_size) {
-#ifdef __linux__
-  snprintf(output, output_size, "Available commands:\n   %s\n   %s\n   %s\n\n",
-                                  _commandAddConnectionHicn,
-                                  _commandAddConnectionUdp,
-                                  _commandAddConnectionTcp);
-#else
-  snprintf(output, output_size, "Available commands:\n   %s\n   %s\n\n",
-                                  _commandAddConnectionUdp,
-                                  _commandAddConnectionTcp);
-#endif
-  return CommandReturn_Success;
-}
-
-static void _controlAddConnection_Init(CommandParser *parser, CommandOps *ops) {
-  ControlState *state = ops->closure;
-#ifdef __linux__
-  controlState_RegisterCommand(state,
-                               _controlAddConnection_HicnHelpCreate(state));
-#endif
-  controlState_RegisterCommand(state,
-                               _controlAddConnection_UdpHelpCreate(state));
-  controlState_RegisterCommand(state,
-                               _controlAddConnection_TcpHelpCreate(state));
-#ifdef __linux__
-  controlState_RegisterCommand(state, _controlAddConnection_HicnCreate(state));
-#endif
-  controlState_RegisterCommand(state, _controlAddConnection_UdpCreate(state));
-  controlState_RegisterCommand(state, _controlAddConnection_TcpCreate(state));
-}
-
-static CommandReturn _controlAddConnection_Execute(CommandParser *parser,
-                                                   CommandOps *ops,
-                                                   PARCList *args,
-                                                   char *output,
-                                                   size_t output_size) {
-  return _controlAddConnection_HelpExecute(parser, ops, args, output, output_size);
-}
-
-// ===================================================
-// functions general to all connection types
-
-/**
- * Create a tunnel in the forwarder based on the addresses
- *
- * Caller retains ownership of memory.
- * The symbolic name will be used to refer to this connection. It must be unqiue
- * otherwise the forwarder will reject this commend.
- *
- * @param [in] parser An allocated CommandParser
- * @param [in] ops Allocated CommandOps (needed to extract ControlState)
- * @param [in] localAddress the local IP and port.  The port may be the wildcard
- * value.
- * @param [in] remoteAddress The remote IP and port (both must be specified)
- * @param [in] tunnelType The tunneling protocol
- * @param [in] symbolic The symbolic name for the connection (must be unique)
- * @param [in] output Output buffer
- * @param [in] output_size Output buffer size
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * {
- *      struct sockaddr_in *anyAddress = parcNetwork_SockInet4AddressAny();
- *      struct sockaddr_in *remote     =
- * parcNetwork_SockInet4Address("192.168.1.2", 9695);
- *
- *      Address *localAddress = addressCreateFromInet(anyAddress);
- *      Address *remoteAddress = addressCreateFromInet(remote);
- *
- *      control_CreateTunnel(state, localAddress, remoteAddress, IPTUN_TCP,
- * "conn7");
- *
- *      addressDestroy(&localAddress);
- *      addressDestroy(&remoteAddress);
- *      parcMemory_Deallocate((void **)&remote);
- *      parcMemory_Deallocate((void **)&anyAddress);
- * }
- * @endcode
- */
-
-static CommandReturn _controlAddConnection_CreateTunnel(CommandParser *parser,
-                                                        CommandOps *ops, const char *local_ip,
-                                                        const char *local_port,
-                                                        const char *remote_ip,
-                                                        const char *remote_port,
-                                                        connection_type tunnelType,
-                                                        const char *symbolic,
-                                                        char *output,
-                                                        size_t output_size) {
-  ControlState *state = ops->closure;
-  // a request like this always has an interface index of 0 [FIELD REMOVED]
-  // unsigned int interfaceIndex = 0;
-
-  // allocate command payload
-  add_connection_command *addConnectionCommand =
-      parcMemory_AllocateAndClear(sizeof(add_connection_command));
-
-  // check and set IP addresses
-  if (inet_pton(AF_INET, remote_ip, &addConnectionCommand->remoteIp.v4.as_u32) ==
-          1 &&
-      inet_pton(AF_INET, local_ip, &addConnectionCommand->localIp.v4.as_u32) == 1) {
-    addConnectionCommand->ipType = ADDR_INET;
-
-  } else if (inet_pton(AF_INET6, remote_ip,
-                       &addConnectionCommand->remoteIp.v6.as_in6addr) == 1 &&
-             inet_pton(AF_INET6, local_ip,
-                       &addConnectionCommand->localIp.v6.as_in6addr) == 1) {
-    addConnectionCommand->ipType = ADDR_INET6;
-
-  } else {
-    snprintf(output, output_size, "Error: local address %s not same type as remote address %s\n",
-           local_ip, remote_ip);
-    parcMemory_Deallocate(&addConnectionCommand);
-    return CommandReturn_Failure;
-  }
-
-  // Fill remaining payload fields
-  addConnectionCommand->connectionType = tunnelType;
-  strcpy(addConnectionCommand->symbolic, symbolic);
-  addConnectionCommand->remotePort = htons((uint16_t)atoi(remote_port));
-  addConnectionCommand->localPort = htons((uint16_t)atoi(local_port));
-
-  // send message and receive response
-  struct iovec *response =
-      utils_SendRequest(state, ADD_CONNECTION, addConnectionCommand,
-                        sizeof(add_connection_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlAddConnection_IpHelp(CommandParser *parser,
-                                                  CommandOps *ops,
-                                                  PARCList *args,
-                                                  const char *protocol,
-                                                  char *output,
-                                                  size_t output_size) {
-  snprintf(output, output_size,
-  #ifdef __linux__
-        "add connection hicn <symbolic> <remote_ip> <local_ip>\n"
-  #endif
-        "add connection udp <symbolic> <remote_ip> <port> <local_ip> <port>\n"
-        "  <symbolic>              : symbolic name, e.g. 'conn1' (must be "
-        "unique, start with alpha)\n"
-        "  <remote_ip>  : the IPv4 or IPv6 or hostname of the remote system\n"
-        "  <local_ip>              : optional local IP address to bind to\n"
-        "\n");
-  return CommandReturn_Success;
-}
-
-#ifdef __linux__
-static CommandReturn _controlAddConnection_HicnHelpExecute(CommandParser *parser,
-                                                          CommandOps *ops,
-                                                          PARCList *args,
-                                                          char *output,
-                                                          size_t output_size) {
-  _controlAddConnection_IpHelp(parser, ops, args, "hicn", output, output_size);
-
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlAddConnection_HicnExecute(CommandParser *parser,
-                                                       CommandOps *ops,
-                                                       PARCList *args,
-                                                       char *output,
-                                                       size_t output_size) {
-  static const int _indexSymbolic = 3;
-  static const int _indexRemAddr = 4;
-  static const int _indexLocAddr = 5;
-
-  if (parcList_Size(args) != 6) {
-    _controlAddConnection_HicnHelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  char *symbolic = parcList_GetAtIndex(args, _indexSymbolic);
-
-  if (!utils_ValidateSymbolicName(symbolic)) {
-    snprintf(output, output_size, "Invalid symbolic name.  Must begin with alpha and contain only "
-        "alphanum.\n");
-    return CommandReturn_Failure;
-  }
-
-  char *remote_ip = parcList_GetAtIndex(args, _indexRemAddr);
-  char *local_ip = parcList_GetAtIndex(args, _indexLocAddr);
-  char *port = "1234";  // this is a random port number that will be ignored
-
-  return _controlAddConnection_CreateTunnel(
-      parser, ops, local_ip, port, remote_ip, port, HICN_CONN, symbolic, output, output_size);
-}
-#endif
-
-static CommandReturn _controlAddConnection_UdpHelpExecute(CommandParser *parser,
-                                                          CommandOps *ops,
-                                                          PARCList *args,
-                                                          char *output,
-                                                          size_t output_size) {
-  _controlAddConnection_IpHelp(parser, ops, args, "udp", output, output_size);
-
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlAddConnection_UdpExecute(CommandParser *parser,
-                                                      CommandOps *ops,
-                                                      PARCList *args,
-                                                      char *output,
-                                                      size_t output_size) {
-  static const int _indexSymbolic = 3;
-  static const int _indexRemAddr = 4;
-  static const int _indexRemPort = 5;
-  static const int _indexLocAddr = 6;
-  static const int _indexLocPort = 7;
-
-  if (parcList_Size(args) != 8) {
-    _controlAddConnection_UdpHelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  char *symbolic = parcList_GetAtIndex(args, _indexSymbolic);
-  size_t offset = 0;
-  if (!utils_ValidateSymbolicName(symbolic)) {
-    snprintf(output, output_size,
-        "Invalid symbolic name.  Must begin with alpha and contain only "
-        "alphanum.\n");
-    return CommandReturn_Failure;
-  }
-
-  char *remote_ip = parcList_GetAtIndex(args, _indexRemAddr);
-  char *local_ip = parcList_GetAtIndex(args, _indexLocAddr);
-
-  char *remote_port = parcList_GetAtIndex(args, _indexRemPort);
-  char *local_port = parcList_GetAtIndex(args, _indexLocPort);
-
-  return _controlAddConnection_CreateTunnel(parser, ops, local_ip, local_port,
-                                            remote_ip, remote_port, UDP_CONN,
-                                            symbolic,
-                                            output + offset, output_size - offset);
-}
-
-static CommandReturn _controlAddConnection_TcpHelpExecute(CommandParser *parser,
-                                                          CommandOps *ops,
-                                                          PARCList *args,
-                                                          char *output,
-                                                          size_t output_size) {
-  _controlAddConnection_IpHelp(parser, ops, args, "tcp", output, output_size);
-
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlAddConnection_TcpExecute(CommandParser *parser,
-                                                      CommandOps *ops,
-                                                      PARCList *args,
-                                                      char *output,
-                                                      size_t output_size) {
-  static const int _indexSymbolic = 3;
-  static const int _indexRemAddr = 4;
-  static const int _indexRemPort = 5;
-  static const int _indexLocAddr = 6;
-  static const int _indexLocPort = 7;
-
-  if (parcList_Size(args) != 8) {
-    _controlAddConnection_UdpHelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  char *symbolic = parcList_GetAtIndex(args, _indexSymbolic);
-  if (!utils_ValidateSymbolicName(symbolic)) {
-    snprintf(output, output_size, "Invalid symbolic name.  Must begin with alpha and contain only "
-        "alphanum.\n");
-    return CommandReturn_Failure;
-  }
-
-  char *remote_ip = parcList_GetAtIndex(args, _indexRemAddr);
-  char *local_ip = parcList_GetAtIndex(args, _indexLocAddr);
-
-  char *remote_port = parcList_GetAtIndex(args, _indexRemPort);
-  char *local_port = parcList_GetAtIndex(args, _indexLocPort);
-
-  return _controlAddConnection_CreateTunnel(parser, ops, local_ip, local_port,
-                                            remote_ip, remote_port, TCP_CONN,
-                                            symbolic,
-                                            output, output_size);
-}
diff --git a/hicn-light/src/hicn/config/controlAddConnection.h b/hicn-light/src/hicn/config/controlAddConnection.h
deleted file mode 100644
index 546388efc..000000000
--- a/hicn-light/src/hicn/config/controlAddConnection.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * 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 control_AddConnection.h
- * @brief Command-line "add connection" node
- *
- * Implements the "add connection" node of the CLI tree
- *
- *
- */
-
-#ifndef controlAddConnection_h
-#define controlAddConnection_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlAddConnection_Create(ControlState *state);
-CommandOps *controlAddConnection_HelpCreate(ControlState *state);
-#endif  // controlAddConnection_h
diff --git a/hicn-light/src/hicn/config/controlAddListener.c b/hicn-light/src/hicn/config/controlAddListener.c
deleted file mode 100644
index df84c4691..000000000
--- a/hicn-light/src/hicn/config/controlAddListener.c
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <ctype.h>
-#include <inttypes.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-
-#include <hicn/config/controlAddListener.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlAddListener_Execute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size);
-static CommandReturn _controlAddListener_HelpExecute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size);
-
-static const char *command_add_listener = "add listener";
-static const char *command_help_add_listener = "help add listener";
-
-CommandOps *controlAddListener_Create(ControlState *state) {
-  return commandOps_Create(state, command_add_listener, NULL,
-                           _controlAddListener_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlAddListener_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, command_help_add_listener, NULL,
-                           _controlAddListener_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static const int _indexProtocol = 2;
-static const int _indexSymbolic = 3;
-static const int _indexAddress = 4;
-static const int _indexPort = 5;
-static const int _indexInterfaceName = 6;
-
-static CommandReturn _controlAddListener_HelpExecute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size) {
-  snprintf(output, output_size,
-                  "commands:\n"
-#ifdef __linux__
-                  "   add listener hicn <symbolic> <localAddress> \n"
-#endif
-                  "   add listener udp <symbolic> <localAddress> <port> <interface>\n"
-                  "   add listener tcp <symbolic> <localAddress> <port> <interface>\n"
-                  "\n"
-                  "   symbolic:        User defined name for listener, must start with "
-                  "alpha and be alphanum\n"
-#ifdef __linux__
-                  "   protocol:        hicn | udp\n"
-#else
-                  "   protocol:        udp\n"
-#endif
-                  "   localAddress:    IPv4 or IPv6 address (or prefix protocol = hicn) "
-                  "assigend to the local interface\n"
-                  "   port:            Udp port\n"
-                  "   interface:            interface\n"
-                  "\n"
-                  "Notes:\n"
-                  "   The symblic name must be unique or the source will reject it.\n"
-#ifdef __linux__
-                  "    If protocol = hicn: the address 0::0 indicates the main listern, "
-                  "for which we can set punting rules.\n"
-#endif
-  );
-  return CommandReturn_Success;
-}
-
-static CommandReturn _CreateListener(CommandParser *parser, CommandOps *ops,
-                                     const char *symbolic, const char *addr,
-                                     const char *port, char *interfaceName, listener_mode mode,
-                                     connection_type type,
-                                     char *output,
-                                     size_t output_size) {
-  ControlState *state = ops->closure;
-
-  // allocate command payload
-  add_listener_command *addListenerCommand =
-      parcMemory_AllocateAndClear(sizeof(add_listener_command));
-
-  // check and set IP address
-  if (inet_pton(AF_INET, addr, &addListenerCommand->address.v4.as_u32) == 1) {
-    addListenerCommand->addressType = ADDR_INET;
-
-  } else if (inet_pton(AF_INET6, addr, &addListenerCommand->address.v6.as_in6addr) == 1) {
-    addListenerCommand->addressType = ADDR_INET6;
-
-  } else {
-    snprintf(output, output_size, "Error: %s is not a valid network address \n", addr);
-    parcMemory_Deallocate(&addListenerCommand);
-    return CommandReturn_Failure;
-  }
-
-  // Fill remaining payload fields
-  size_t name_size = strlen((const char *)interfaceName);
-  if(name_size > SYMBOLIC_NAME_LEN){
-    //cut the string
-    name_size = SYMBOLIC_NAME_LEN;
-  }
-
-  memcpy(addListenerCommand->interfaceName, interfaceName, name_size);
-  addListenerCommand->listenerMode = mode;
-  addListenerCommand->connectionType = type;
-  addListenerCommand->port = htons((uint16_t)atoi(port));
-  strcpy(addListenerCommand->symbolic, symbolic);
-
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(
-      state, ADD_LISTENER, addListenerCommand, sizeof(add_listener_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlAddListener_Execute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size) {
-  if (parcList_Size(args) != 5 && parcList_Size(args) != 7) {
-    _controlAddListener_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  CommandReturn result = CommandReturn_Failure;
-
-  const char *symbolic = parcList_GetAtIndex(args, _indexSymbolic);
-
-  if (!utils_ValidateSymbolicName(symbolic)) {
-    snprintf(output, output_size,
-        "Error: symbolic name must begin with an alpha and be alphanum "
-        "after\n");
-    return result;
-  }
-
-  const char *protocol = parcList_GetAtIndex(args, _indexProtocol);
-  const char *host = parcList_GetAtIndex(args, _indexAddress);
-  char *interfaceName = parcList_GetAtIndex(args, _indexInterfaceName);
-  if ((strcasecmp("hicn", protocol) == 0)) {
-    const char *port =
-        "1234";  // this is a random port number that will be ignored
-
-    // here we discard the prefix len if it exists, since we don't use it in
-    // code but we let libhicn to find the right ip address.
-    return _CreateListener(parser, ops, symbolic, host, port, "hicn", HICN_MODE,
-                           HICN_CONN, output, output_size);
-  }
-  const char *port = parcList_GetAtIndex(args, _indexPort);
-
-  if ((strcasecmp("udp", protocol) == 0)) {
-    return _CreateListener(parser, ops, symbolic, host, port, interfaceName, IP_MODE,
-                           UDP_CONN, output, output_size);
-  } else if ((strcasecmp("tcp", protocol) == 0)) {
-    return _CreateListener(parser, ops, symbolic, host, port, interfaceName, IP_MODE,
-                           TCP_CONN, output, output_size);
-  } else {
-    _controlAddListener_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  if (result == CommandReturn_Failure) snprintf(output, output_size, "creation failed\n");
-
-  return result;
-}
diff --git a/hicn-light/src/hicn/config/controlAddListener.h b/hicn-light/src/hicn/config/controlAddListener.h
deleted file mode 100644
index 6516d1779..000000000
--- a/hicn-light/src/hicn/config/controlAddListener.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 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 control_AddListener.h
- * @brief Add a listener to an interface
- *
- * <#Detailed Description#>
- *
- */
-
-#ifndef Control_AddListener_h
-#define Control_AddListener_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlAddListener_Create(ControlState *state);
-CommandOps *controlAddListener_HelpCreate(ControlState *state);
-#endif  // Control_AddListener_h
diff --git a/hicn-light/src/hicn/config/controlAddPolicy.c b/hicn-light/src/hicn/config/controlAddPolicy.c
deleted file mode 100644
index 66439d29c..000000000
--- a/hicn-light/src/hicn/config/controlAddPolicy.c
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- * 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.
- */
-
-#ifdef WITH_POLICY
-
-#include <hicn/hicn-light/config.h>
-
-#include <ctype.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-
-#include <hicn/config/controlAddPolicy.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-#include <hicn/utils/token.h>
-
-static CommandReturn _controlAddPolicy_Execute(CommandParser *parser,
-                                              CommandOps *ops, PARCList *args,
-                                              char *output,
-                                              size_t output_size);
-static CommandReturn _controlAddPolicy_HelpExecute(CommandParser *parser,
-                                                  CommandOps *ops,
-                                                  PARCList *args,
-                                                  char *output,
-                                                  size_t output_size);
-
-static const char *_commandAddPolicy = "add policy";
-static const char *_commandAddPolicyHelp = "help add policy";
-
-CommandOps *controlAddPolicy_Create(ControlState *state) {
-  return commandOps_Create(state, _commandAddPolicy, NULL,
-                           _controlAddPolicy_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlAddPolicy_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandAddPolicyHelp, NULL,
-                           _controlAddPolicy_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlAddPolicy_HelpExecute(CommandParser *parser,
-                                                  CommandOps *ops,
-                                                  PARCList *args,
-                                                  char *output,
-                                                  size_t output_size) {
-  size_t output_offset = snprintf(output, output_size,  "commands:\n"
-                                                        "   add policy <prefix> <app_name>");
-  
-  #define _(x, y) output_offset += snprintf(output + output_offset, output_size - output_offset, " FLAG:%s", policy_tag_str[POLICY_TAG_ ## x]);
-  foreach_policy_tag
-  #undef _
-            
-  output_offset += snprintf(output + output_offset, output_size - output_offset,"\n");
-  printf("\n");
-  output_offset += snprintf(output + output_offset, output_size - output_offset,
-      "   prefix:    The hicn name as IPv4 or IPv6 address (e.g 1234::0/64)\n"
-      "   app_name:      The application name associated to this policy\n"
-      "   FLAG:*:  A value among [neutral|require|prefer|avoid|prohibit] with an optional '!' character prefix for disabling changes\n"
-      "\n");
-
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlAddPolicy_Execute(CommandParser *parser,
-                                              CommandOps *ops,
-                                              PARCList *args,
-                                              char *output,
-                                              size_t output_size) {
-  ControlState *state = ops->closure;
-
-  if (parcList_Size(args) != 11) {
-    _controlAddPolicy_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  const char *prefixStr = parcList_GetAtIndex(args, 2);
-  char *addr = (char *)malloc((strlen(prefixStr) + 1) * sizeof(char));
-
-  // separate address and len
-  char *slash;
-  uint32_t len = 0;
-  strcpy(addr, prefixStr);
-  slash = strrchr(addr, '/');
-  if (slash != NULL) {
-    len = atoi(slash + 1);
-    *slash = '\0';
-  }
-
-  // allocate command payload
-  add_policy_command *addPolicyCommand =
-      parcMemory_AllocateAndClear(sizeof(add_policy_command));
-
-  // check and set IP address
-  if (inet_pton(AF_INET, addr, &addPolicyCommand->address.v4.as_u32) == 1) {
-    if (len > 32) {
-      snprintf(output, output_size, "ERROR: exceeded INET mask length, max=32\n");
-      parcMemory_Deallocate(&addPolicyCommand);
-      free(addr);
-      return CommandReturn_Failure;
-    }
-    addPolicyCommand->addressType = ADDR_INET;
-  } else if (inet_pton(AF_INET6, addr, &addPolicyCommand->address.v6.as_in6addr) == 1) {
-    if (len > 128) {
-      snprintf(output, output_size, "ERROR: exceeded INET6 mask length, max=128\n");
-      parcMemory_Deallocate(&addPolicyCommand);
-      free(addr);
-      return CommandReturn_Failure;
-    }
-    addPolicyCommand->addressType = ADDR_INET6;
-  } else {
-    snprintf(output, output_size, "Error: %s is not a valid network address \n", addr);
-    parcMemory_Deallocate(&addPolicyCommand);
-    free(addr);
-    return CommandReturn_Failure;
-  }
-
-  free(addr);
-
-  addPolicyCommand->len = len;
-
-  hicn_policy_t policy;
-  snprintf((char*)policy.app_name, APP_NAME_LEN, "%s", (char*)parcList_GetAtIndex(args, 3));
-  for (int i=4; i < 11; i++) {
-    const char *tag = parcList_GetAtIndex(args, i);
-    policy_tag_state_t tag_state;
-    tag_state.disabled = (tag[0] == '!') ? 1 : 0;
-    if (strcmp(&tag[tag_state.disabled], "neutral") == 0) {
-      tag_state.state = POLICY_STATE_NEUTRAL;
-    } else if (strcmp(&tag[tag_state.disabled], "require") == 0) {
-      tag_state.state = POLICY_STATE_REQUIRE;
-    } else if (strcmp(&tag[tag_state.disabled], "prefer") == 0) {
-      tag_state.state = POLICY_STATE_PREFER;
-    } else if (strcmp(&tag[tag_state.disabled], "avoid") == 0) {
-      tag_state.state = POLICY_STATE_AVOID;
-    } else if (strcmp(&tag[tag_state.disabled], "prohibit") == 0) {
-      tag_state.state = POLICY_STATE_PROHIBIT;
-    } else {
-      snprintf(output, output_size, "ERROR: invalid tag value '%s'\n", tag);
-      parcMemory_Deallocate(&addPolicyCommand);
-      free(addr);
-      return CommandReturn_Failure;
-    }
-
-    policy.tags[i-4] = tag_state;
-
-  }
-
-  addPolicyCommand->policy = policy;
-
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(state, ADD_POLICY, addPolicyCommand,
-                                             sizeof(add_policy_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
-
-#endif /* WITH_POLICY */
diff --git a/hicn-light/src/hicn/config/controlAddPunting.c b/hicn-light/src/hicn/config/controlAddPunting.c
deleted file mode 100644
index 41d846d55..000000000
--- a/hicn-light/src/hicn/config/controlAddPunting.c
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <ctype.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-#include <hicn/utils/punting.h>
-
-#include <hicn/config/controlAddPunting.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlAddPunting_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size);
-static CommandReturn _controlAddPunting_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size);
-
-static const char *_commandAddPunting = "add punting";
-static const char *_commandAddPuntingHelp = "help add punting";
-
-static const int _indexSymbolic = 2;
-static const int _indexPrefix = 3;
-
-CommandOps *controlAddPunting_Create(ControlState *state) {
-  return commandOps_Create(state, _commandAddPunting, NULL,
-                           _controlAddPunting_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlAddPunting_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandAddPuntingHelp, NULL,
-                           _controlAddPunting_HelpExecute, commandOps_Destroy);
-}
-
-// =====================================================
-
-static CommandReturn _controlAddPunting_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size) {
-    snprintf(output, output_size, "add punting <symbolic> <prefix>\n"
-                                  "    <symbolic> : listener symbolic name\n"
-                                  "    <address>  : prefix to add as a punting rule. (example "
-                                  "1234::0/64)\n"
-                                  "\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlAddPunting_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size) {
-  ControlState *state = ops->closure;
-
-  if (parcList_Size(args) != 4) {
-    _controlAddPunting_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  const char *symbolicOrConnid = parcList_GetAtIndex(args, _indexSymbolic);
-
-  if (!utils_ValidateSymbolicName(symbolicOrConnid) &&
-      !utils_IsNumber(symbolicOrConnid)) {
-    snprintf(output, output_size,
-        "ERROR: Invalid symbolic or connid:\n"
-        "symbolic name must begin with an alpha followed by alphanum;\nconnid "
-        "must be an integer\n");
-    return CommandReturn_Failure;
-  }
-
-  const char *prefixStr = parcList_GetAtIndex(args, _indexPrefix);
-  char *addr = (char *)malloc((strlen(prefixStr) + 1) * sizeof(char));
-
-  // separate address and len
-  char *slash;
-  uint32_t len = 0;
-  strcpy(addr, prefixStr);
-  slash = strrchr(addr, '/');
-  if (slash != NULL) {
-    len = atoi(slash + 1);
-    *slash = '\0';
-  }
-
-  // allocate command payload
-  add_punting_command *addPuntingCommand =
-      parcMemory_AllocateAndClear(sizeof(add_punting_command));
-
-  // check and set IP address
-  if (inet_pton(AF_INET, addr, &addPuntingCommand->address.v4.as_u32) == 1) {
-    if (len > 32) {
-      snprintf(output, output_size, "ERROR: exceeded INET mask length, max=32\n");
-      parcMemory_Deallocate(&addPuntingCommand);
-      free(addr);
-      return CommandReturn_Failure;
-    }
-    addPuntingCommand->addressType = ADDR_INET;
-  } else if (inet_pton(AF_INET6, addr, &addPuntingCommand->address.v6.as_in6addr) == 1) {
-    if (len > 128) {
-      snprintf(output, output_size, "ERROR: exceeded INET6 mask length, max=128\n");
-      parcMemory_Deallocate(&addPuntingCommand);
-      free(addr);
-      return CommandReturn_Failure;
-    }
-    addPuntingCommand->addressType = ADDR_INET6;
-  } else {
-    snprintf(output, output_size, "Error: %s is not a valid network address \n", addr);
-    parcMemory_Deallocate(&addPuntingCommand);
-    free(addr);
-    return CommandReturn_Failure;
-  }
-
-  free(addr);
-
-  // Fill remaining payload fields
-  addPuntingCommand->len = len;
-  strcpy(addPuntingCommand->symbolicOrConnid, symbolicOrConnid);
-
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(
-      state, ADD_PUNTING, addPuntingCommand, sizeof(add_punting_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
-
-// ======================================================================
diff --git a/hicn-light/src/hicn/config/controlAddRoute.c b/hicn-light/src/hicn/config/controlAddRoute.c
deleted file mode 100644
index 78c0173ea..000000000
--- a/hicn-light/src/hicn/config/controlAddRoute.c
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <ctype.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-
-#include <hicn/config/controlAddRoute.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlAddRoute_Execute(CommandParser *parser,
-                                              CommandOps *ops, PARCList *args,
-                                              char *output,
-                                              size_t output_size);
-static CommandReturn _controlAddRoute_HelpExecute(CommandParser *parser,
-                                                  CommandOps *ops,
-                                                  PARCList *args,
-                                                  char *output,
-                                                  size_t output_size);
-
-static const char *_commandAddRoute = "add route";
-static const char *_commandAddRouteHelp = "help add route";
-
-CommandOps *controlAddRoute_Create(ControlState *state) {
-  return commandOps_Create(state, _commandAddRoute, NULL,
-                           _controlAddRoute_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlAddRoute_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandAddRouteHelp, NULL,
-                           _controlAddRoute_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlAddRoute_HelpExecute(CommandParser *parser,
-                                                  CommandOps *ops,
-                                                  PARCList *args,
-                                                  char *output,
-                                                  size_t output_size) {
-  snprintf(output, output_size, "commands:\n"
-                                "   add route <symbolic | connid> <prefix> <cost>\n"
-                                "\n"
-                                "   symbolic:  The symbolic name for an exgress\n"
-                                "   connid:    The egress connection id (see 'help list connections')\n"
-                                "   prefix:    The hicn name as IPv4 or IPv6 address (e.g 1234::0/64)\n"
-                                "   cost:      positive integer representing cost\n"
-                                "\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlAddRoute_Execute(CommandParser *parser,
-                                              CommandOps *ops,
-                                              PARCList *args,
-                                              char *output,
-                                              size_t output_size) {
-  ControlState *state = ops->closure;
-
-  if (parcList_Size(args) != 5) {
-    _controlAddRoute_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  const char *symbolicOrConnid = parcList_GetAtIndex(args, 2);
-
-  if (!utils_ValidateSymbolicName(symbolicOrConnid) &&
-      !utils_IsNumber(symbolicOrConnid)) {
-    snprintf(output, output_size, "ERROR: Invalid symbolic or connid:\nsymbolic name must begin with an "
-                                  "alpha followed by alphanum;\nconnid must be an integer\n");
-    return CommandReturn_Failure;
-  }
-
-  unsigned cost = atoi(parcList_GetAtIndex(args, 4));
-
-  if (cost == 0) {
-    snprintf(output, output_size, "ERROR: cost must be positive integer, got %u from '%s'\n", cost,
-           (char *)parcList_GetAtIndex(args, 4));
-    return CommandReturn_Failure;
-  }
-
-  const char *prefixStr = parcList_GetAtIndex(args, 3);
-  char *addr = (char *)malloc((strlen(prefixStr) + 1) * sizeof(char));
-
-  // separate address and len
-  char *slash;
-  uint32_t len = 0;
-  strcpy(addr, prefixStr);
-  slash = strrchr(addr, '/');
-  if (slash != NULL) {
-    len = atoi(slash + 1);
-    *slash = '\0';
-  }
-
-  // allocate command payload
-  add_route_command *addRouteCommand =
-      parcMemory_AllocateAndClear(sizeof(add_route_command));
-
-  // check and set IP address
-  if (inet_pton(AF_INET, addr, &addRouteCommand->address.v4.as_u32) == 1) {
-    if (len > 32) {
-      snprintf(output, output_size, "ERROR: exceeded INET mask length, max=32\n");
-      parcMemory_Deallocate(&addRouteCommand);
-      free(addr);
-      return CommandReturn_Failure;
-    }
-    addRouteCommand->addressType = ADDR_INET;
-  } else if (inet_pton(AF_INET6, addr, &addRouteCommand->address.v6.as_in6addr) == 1) {
-    if (len > 128) {
-      snprintf(output, output_size, "ERROR: exceeded INET6 mask length, max=128\n");
-      parcMemory_Deallocate(&addRouteCommand);
-      free(addr);
-      return CommandReturn_Failure;
-    }
-    addRouteCommand->addressType = ADDR_INET6;
-  } else {
-    snprintf(output, output_size, "Error: %s is not a valid network address \n", addr);
-    parcMemory_Deallocate(&addRouteCommand);
-    free(addr);
-    return CommandReturn_Failure;
-  }
-
-  free(addr);
-
-  // Fill remaining payload fields
-  addRouteCommand->len = len;
-  addRouteCommand->cost = (uint16_t)cost;
-  strcpy(addRouteCommand->symbolicOrConnid, symbolicOrConnid);
-
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(state, ADD_ROUTE, addRouteCommand,
-                                             sizeof(add_route_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlAddRoute.h b/hicn-light/src/hicn/config/controlAddRoute.h
deleted file mode 100644
index 9588c0f42..000000000
--- a/hicn-light/src/hicn/config/controlAddRoute.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 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 control_AddRoute.h
- * @brief Add a static route
- *
- * Implements the "add route" node of the CLI tree
- *
- */
-
-#ifndef Control_AddRoute_h
-#define Control_AddRoute_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlAddRoute_Create(ControlState *state);
-CommandOps *controlAddRoute_HelpCreate(ControlState *state);
-#endif  // Control_AddRoute_h
diff --git a/hicn-light/src/hicn/config/controlCache.c b/hicn-light/src/hicn/config/controlCache.c
deleted file mode 100644
index b6010fcfd..000000000
--- a/hicn-light/src/hicn/config/controlCache.c
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/security/parc_Security.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/config/controlCache.h>
-#include <hicn/config/controlCacheClear.h>
-#include <hicn/config/controlCacheServe.h>
-#include <hicn/config/controlCacheStore.h>
-
-static void _controlCache_Init(CommandParser *parser, CommandOps *ops);
-static CommandReturn _controlCache_Execute(CommandParser *parser,
-                                           CommandOps *ops,
-                                           PARCList *args,
-                                           char *output,
-                                           size_t output_size);
-static CommandReturn _controlCache_HelpExecute(CommandParser *parser,
-                                               CommandOps *ops, PARCList *args,
-                                               char *output,
-                                               size_t output_size);
-
-static const char *_commandCache = "cache";
-static const char *_commandCacheHelp = "help cache";
-
-CommandOps *controlCache_Create(ControlState *state) {
-  return commandOps_Create(state, _commandCache, _controlCache_Init,
-                           _controlCache_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlCache_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandCacheHelp, NULL,
-                           _controlCache_HelpExecute, commandOps_Destroy);
-}
-
-// =====================================================
-
-static CommandReturn _controlCache_HelpExecute(CommandParser *parser,
-                                               CommandOps *ops,
-                                               PARCList *args,
-                                               char *output,
-                                               size_t output_size) {
-  CommandOps *ops_cache_serve = controlCacheServe_HelpCreate(NULL);
-  CommandOps *ops_cache_store = controlCacheStore_HelpCreate(NULL);
-  CommandOps *ops_cache_clear = controlCacheClear_HelpCreate(NULL);
-
-  snprintf(output, output_size, "Available commands:\n"
-                                "   %s\n   %s\n   %s\n\n",
-                                ops_cache_serve->command,
-                                ops_cache_store->command,
-                                ops_cache_clear->command);
-  commandOps_Destroy(&ops_cache_serve);
-  commandOps_Destroy(&ops_cache_store);
-  commandOps_Destroy(&ops_cache_clear);
-
-  return CommandReturn_Success;
-}
-
-static void _controlCache_Init(CommandParser *parser, CommandOps *ops) {
-  ControlState *state = ops->closure;
-  controlState_RegisterCommand(state, controlCacheServe_HelpCreate(state));
-  controlState_RegisterCommand(state, controlCacheStore_HelpCreate(state));
-  controlState_RegisterCommand(state, controlCacheClear_HelpCreate(state));
-  controlState_RegisterCommand(state, controlCacheServe_Create(state));
-  controlState_RegisterCommand(state, controlCacheStore_Create(state));
-  controlState_RegisterCommand(state, controlCacheClear_Create(state));
-}
-
-static CommandReturn _controlCache_Execute(CommandParser *parser,
-                                           CommandOps *ops,
-                                           PARCList *args,
-                                           char *output,
-                                           size_t output_size) {
-  return _controlCache_HelpExecute(parser, ops, args, output, output_size);
-}
-
-// ======================================================================
diff --git a/hicn-light/src/hicn/config/controlCacheClear.c b/hicn-light/src/hicn/config/controlCacheClear.c
deleted file mode 100644
index afd8f6fc1..000000000
--- a/hicn-light/src/hicn/config/controlCacheClear.c
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/config/controlCacheClear.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlCacheClear_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size);
-static CommandReturn _controlCacheClear_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size);
-
-static const char *_commandCacheClear = "cache clear";
-static const char *_commandCacheClearHelp = "help cache clear";
-
-// ====================================================
-
-CommandOps *controlCacheClear_Create(ControlState *state) {
-  return commandOps_Create(state, _commandCacheClear, NULL,
-                           _controlCacheClear_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlCacheClear_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandCacheClearHelp, NULL,
-                           _controlCacheClear_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlCacheClear_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size) {
-  snprintf(output, output_size, "cache clear\n\n");
-
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlCacheClear_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size) {
-  if (parcList_Size(args) != 2) {
-    _controlCacheClear_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  ControlState *state = ops->closure;
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(state, CACHE_CLEAR, NULL, 0);
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlCacheClear.h b/hicn-light/src/hicn/config/controlCacheClear.h
deleted file mode 100644
index 025758c34..000000000
--- a/hicn-light/src/hicn/config/controlCacheClear.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 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 controlCacheClear.h
- * @brief Clear the cache
- *
- * Removes all the cached data form the local content store (if available)
- *
- */
-
-#ifndef Control_CacheClear_h
-#define Control_CacheClear_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlCacheClear_Create(ControlState *state);
-CommandOps *controlCacheClear_HelpCreate(ControlState *state);
-#endif  // Control_CacheClear_h
diff --git a/hicn-light/src/hicn/config/controlCacheServe.c b/hicn-light/src/hicn/config/controlCacheServe.c
deleted file mode 100644
index a4454037d..000000000
--- a/hicn-light/src/hicn/config/controlCacheServe.c
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/config/controlCacheServe.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlCacheServe_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size);
-static CommandReturn _controlCacheServe_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size);
-
-static const char *_commandCacheServe = "cache serve";
-static const char *_commandCacheServeHelp = "help cache serve";
-
-// ====================================================
-
-CommandOps *controlCacheServe_Create(ControlState *state) {
-  return commandOps_Create(state, _commandCacheServe, NULL,
-                           _controlCacheServe_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlCacheServe_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandCacheServeHelp, NULL,
-                           _controlCacheServe_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlCacheServe_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size) {
-  snprintf(output, output_size, "cache serve [on|off]\n\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlCacheServe_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size) {
-  if (parcList_Size(args) != 3) {
-    _controlCacheServe_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  bool active;
-  if (strcmp(parcList_GetAtIndex(args, 2), "on") == 0) {
-    active = true;
-  } else if (strcmp(parcList_GetAtIndex(args, 2), "off") == 0) {
-    active = false;
-  } else {
-    _controlCacheServe_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  cache_serve_command *cacheServeCommand =
-      parcMemory_AllocateAndClear(sizeof(cache_serve_command));
-  if (active) {
-    cacheServeCommand->activate = ACTIVATE_ON;
-  } else {
-    cacheServeCommand->activate = ACTIVATE_OFF;
-  }
-
-  ControlState *state = ops->closure;
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(
-      state, CACHE_SERVE, cacheServeCommand, sizeof(cache_serve_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlCacheServe.h b/hicn-light/src/hicn/config/controlCacheServe.h
deleted file mode 100644
index afebc0601..000000000
--- a/hicn-light/src/hicn/config/controlCacheServe.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 Control_CacheServe_h
-#define Control_CacheServe_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlCacheServe_Create(ControlState *state);
-CommandOps *controlCacheServe_HelpCreate(ControlState *state);
-#endif  // Control_CacheServe_h
diff --git a/hicn-light/src/hicn/config/controlCacheStore.c b/hicn-light/src/hicn/config/controlCacheStore.c
deleted file mode 100644
index 9f2a18146..000000000
--- a/hicn-light/src/hicn/config/controlCacheStore.c
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/config/controlCacheStore.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlCacheStore_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size);
-static CommandReturn _controlCacheStore_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size);
-
-static const char *_commandCacheStore = "cache store";
-static const char *_commandCacheStoreHelp = "help cache store";
-
-// ====================================================
-
-CommandOps *controlCacheStore_Create(ControlState *state) {
-  return commandOps_Create(state, _commandCacheStore, NULL,
-                           _controlCacheStore_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlCacheStore_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandCacheStoreHelp, NULL,
-                           _controlCacheStore_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlCacheStore_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size) {
-  snprintf(output, output_size, "cache store [on|off]\n\n");
-
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlCacheStore_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size) {
-  if (parcList_Size(args) != 3) {
-    _controlCacheStore_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  bool active;
-  if (strcmp(parcList_GetAtIndex(args, 2), "on") == 0) {
-    active = true;
-  } else if (strcmp(parcList_GetAtIndex(args, 2), "off") == 0) {
-    active = false;
-  } else {
-    _controlCacheStore_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  cache_store_command *cacheStoreCommand =
-      parcMemory_AllocateAndClear(sizeof(cache_store_command));
-  if (active) {
-    cacheStoreCommand->activate = ACTIVATE_ON;
-  } else {
-    cacheStoreCommand->activate = ACTIVATE_OFF;
-  }
-
-  ControlState *state = ops->closure;
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(
-      state, CACHE_STORE, cacheStoreCommand, sizeof(cache_store_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlCacheStore.h b/hicn-light/src/hicn/config/controlCacheStore.h
deleted file mode 100644
index e32bf5663..000000000
--- a/hicn-light/src/hicn/config/controlCacheStore.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 Control_CacheStore_h
-#define Control_CacheStore_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlCacheStore_Create(ControlState *state);
-CommandOps *controlCacheStore_HelpCreate(ControlState *state);
-#endif  // Control_CacheStore_h
diff --git a/hicn-light/src/hicn/config/controlList.c b/hicn-light/src/hicn/config/controlList.c
deleted file mode 100644
index 353856c43..000000000
--- a/hicn-light/src/hicn/config/controlList.c
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/security/parc_Security.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/config/controlList.h>
-#include <hicn/config/controlListConnections.h>
-//#include <hicn/config/controlListInterfaces.h>
-#include <hicn/config/controlListListeners.h>
-#include <hicn/config/controlListRoutes.h>
-#ifdef WITH_POLICY
-#include <hicn/config/controlListPolicies.h>
-#endif /* WITH_POLICY */
-
-static void _controlList_Init(CommandParser *parser, CommandOps *ops);
-static CommandReturn _controlList_Execute(CommandParser *parser,
-                                          CommandOps *ops,
-                                          PARCList *args,
-                                          char *output,
-                                          size_t output_size);
-static CommandReturn _controlList_HelpExecute(CommandParser *parser,
-                                              CommandOps *ops,
-                                              PARCList *args,
-                                              char *output,
-                                              size_t output_size);
-
-static const char *_commandList = "list";
-static const char *_commandListHelp = "help list";
-
-CommandOps *controlList_Create(ControlState *state) {
-  return commandOps_Create(state, _commandList, _controlList_Init,
-                           _controlList_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlList_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandListHelp, NULL,
-                           _controlList_HelpExecute, commandOps_Destroy);
-}
-
-// =====================================================
-
-static CommandReturn _controlList_HelpExecute(CommandParser *parser,
-                                              CommandOps *ops,
-                                              PARCList *args,
-                                              char *output,
-                                              size_t output_size) {
-  CommandOps *ops_list_connections = controlListConnections_HelpCreate(NULL);
-  // CommandOps *ops_list_interfaces = controlListInterfaces_HelpCreate(NULL);
-  CommandOps *ops_list_routes = controlListRoutes_HelpCreate(NULL);
-  CommandOps *ops_list_listeners = controlListListeners_HelpCreate(NULL);
-#ifdef WITH_POLICY
-  CommandOps *ops_list_policies = controlListPolicies_HelpCreate(NULL);
-#endif /* WITH_POLICY */
-
-  snprintf(output, output_size, "Available commands:\n"
-                                "   %s\n"
-                                "   %s\n"
-                                "   %s\n"
-#ifdef WITH_POLICY
-                                "   %s\n"
-#endif /* WITH_POLICY */
-                                "\n",
-                                ops_list_connections->command,
-                                ops_list_routes->command,
-                                ops_list_listeners->command
-#ifdef WITH_POLICY
-                                , ops_list_policies->command
-#endif /* WITH_POLICY */
-  );
-
-  commandOps_Destroy(&ops_list_connections);
-  // commandOps_Destroy(&ops_list_interfaces);
-  commandOps_Destroy(&ops_list_routes);
-  commandOps_Destroy(&ops_list_listeners);
-#ifdef WITH_POLICY
-  commandOps_Destroy(&ops_list_policies);
-#endif /* WITH_POLICY */
-
-  return CommandReturn_Success;
-}
-
-static void _controlList_Init(CommandParser *parser, CommandOps *ops) {
-  ControlState *state = ops->closure;
-  controlState_RegisterCommand(state, controlListConnections_HelpCreate(state));
-  // controlState_RegisterCommand(state,
-  // controlListInterfaces_HelpCreate(state));
-  controlState_RegisterCommand(state, controlListListeners_HelpCreate(state));
-  controlState_RegisterCommand(state, controlListRoutes_HelpCreate(state));
-  controlState_RegisterCommand(state, controlListConnections_Create(state));
-  // controlState_RegisterCommand(state, controlListInterfaces_Create(state));
-  controlState_RegisterCommand(state, controlListRoutes_Create(state));
-  controlState_RegisterCommand(state, controlListListeners_Create(state));
-#ifdef WITH_POLICY
-  controlState_RegisterCommand(state, controlListPolicies_HelpCreate(state));
-  controlState_RegisterCommand(state, controlListPolicies_Create(state));
-#endif /* WITH_POLICY */
-}
-
-static CommandReturn _controlList_Execute(CommandParser *parser,
-                                          CommandOps *ops,
-                                          PARCList *args,
-                                          char *output,
-                                          size_t output_size) {
-  return _controlList_HelpExecute(parser, ops, args, output, output_size);
-}
-
-// ======================================================================
diff --git a/hicn-light/src/hicn/config/controlList.h b/hicn-light/src/hicn/config/controlList.h
deleted file mode 100644
index d497e5179..000000000
--- a/hicn-light/src/hicn/config/controlList.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 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 control_List.h
- * @brief Root node for the "list" commands
- *
- * Implements the "list" node of the CLI tree.
- *
- */
-
-#ifndef controlList_h
-#define controlList_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlList_Create(ControlState *state);
-CommandOps *controlList_HelpCreate(ControlState *state);
-#endif  // controlList_h
diff --git a/hicn-light/src/hicn/config/controlListConnections.c b/hicn-light/src/hicn/config/controlListConnections.c
deleted file mode 100644
index 6406ba8c3..000000000
--- a/hicn-light/src/hicn/config/controlListConnections.c
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/config/controlListConnections.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlListConnections_Execute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size);
-static CommandReturn _controlListConnections_HelpExecute(CommandParser *parser,
-                                                         CommandOps *ops,
-                                                         PARCList *args,
-                                                         char *output,
-                                                         size_t output_size);
-
-static const char *_commandListConnections = "list connections";
-static const char *_commandListConnectionsHelp = "help list connections";
-const char *connTypeString[6] = {"GRE", "TCP", "UDP", "MCAST", "L2", "HICN"};
-const char *stateString[3] = {"UP", "DOWN", "UNKNOWN"};
-
-CommandOps *controlListConnections_Create(ControlState *state) {
-  return commandOps_Create(state, _commandListConnections, NULL,
-                           _controlListConnections_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlListConnections_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandListConnectionsHelp, NULL,
-                           _controlListConnections_HelpExecute,
-                           commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlListConnections_HelpExecute(CommandParser *parser,
-                                                         CommandOps *ops,
-                                                         PARCList *args,
-                                                         char *output,
-                                                         size_t output_size) {
-snprintf(output, output_size, "%s", "list connections: displays a 1-line summary of each connection\n"
-                                    "\n"
-                                    "The columns are:\n"
-                                    "   connection id : an integer index for the connection\n"
-                                    "   state         : UP or DOWN\n"
-                                    "   local address : the local network address associated with the "
-                                    "connection\n"
-                                    "   remote address: the remote network address associated with the "
-                                    "connection\n"
-                                    "   protocol      : the network protocol (tcp, udp, gre, mcast, "
-                                    "ether)\n"
-                                    "\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlListConnections_Execute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size) {
-  if (parcList_Size(args) != 2) {
-    _controlListConnections_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-#ifdef WITH_POLICY
-  char flags_str[POLICY_TAG_N+1];
-  char *s;
-#endif /* WITH_POLICY */
-
-  ControlState *state = ops->closure;
-
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(state, LIST_CONNECTIONS, NULL, 0);
-  if (!response) {  // get NULL pointer = FAILURE
-    return CommandReturn_Failure;
-  }
-
-  // Process/Print message
-  header_control_message *receivedHeader =
-      (header_control_message *)response[0].iov_base;
-  uint8_t *receivedPayload = (uint8_t *)response[1].iov_base;
-
-  char *sourceString = NULL;
-  char *destinationString = NULL;
-
-  // Allocate output to pass to the main function if the call is not interactive
-  char **commandOutputMain = NULL;
-  if (!controlState_IsInteractive(state) && receivedHeader->length > 0) {
-    commandOutputMain =
-        parcMemory_Allocate(sizeof(char *) * receivedHeader->length);
-    for (size_t j = 0; j < receivedHeader->length; j++) {
-      commandOutputMain[j] = parcMemory_Allocate(sizeof(char) * 256);
-    }
-  }
-size_t output_offset = 0;
-
-#ifdef WITH_POLICY
-  output_offset = snprintf(output, output_size, "%5s %10s %12s %6s %40s %40s %5s %s %s\n", "id", "name", "admin_state", "state", "source", "destination", "type", "priority", "flags");
-#else
-  output_offset = snprintf(output, output_size, "%5s %10s %12s %6s %40s %40s %5s\n", "id", "name", "admin_state", "state", "source", "destination", "type");
-#endif /* WITH_POLICY */
-
-  // Process/Print payload
-
-  for (int i = 0; i < receivedHeader->length; i++) {
-    list_connections_command *listConnectionsCommand =
-        (list_connections_command *)(receivedPayload +
-                                     (i * sizeof(list_connections_command)));
-
-    sourceString = utils_CommandAddressToString(
-        listConnectionsCommand->connectionData.ipType,
-        &listConnectionsCommand->connectionData.localIp,
-        &listConnectionsCommand->connectionData.localPort);
-
-    destinationString = utils_CommandAddressToString(
-        listConnectionsCommand->connectionData.ipType,
-        &listConnectionsCommand->connectionData.remoteIp,
-        &listConnectionsCommand->connectionData.remotePort);
-
-    PARCBufferComposer *composer = parcBufferComposer_Create();
-
-#ifdef WITH_POLICY
-
-    s = flags_str;
-#define _(x, y) *s++ = policy_tags_has(listConnectionsCommand->connectionData.tags, POLICY_TAG_ ## x) ? y : '.';
-foreach_policy_tag
-#undef _
-    *s = '\0';
-
-    parcBufferComposer_Format(
-        composer, "%5d %10s %12s %6s %40s %40s %5s [%6d] [%s]", listConnectionsCommand->connid, listConnectionsCommand->connectionName,
-        stateString[listConnectionsCommand->connectionData.admin_state],
-        stateString[listConnectionsCommand->state], sourceString,
-        destinationString,
-        connTypeString[listConnectionsCommand->connectionData.connectionType],
-        listConnectionsCommand->connectionData.priority,
-        flags_str);
-
-#else
-    parcBufferComposer_Format(
-        composer, "%5d %10s %12s %6s %40s %40s %5s", listConnectionsCommand->connid, listConnectionsCommand->connectionName,
-        stateString[listConnectionsCommand->admin_state],
-        stateString[listConnectionsCommand->state], sourceString,
-        destinationString,
-        connTypeString[listConnectionsCommand->connectionData.connectionType]);
-#endif /* WITH_POLICY */
-
-    PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(composer);
-    char *result = parcBuffer_ToString(tempBuffer);
-    parcBuffer_Release(&tempBuffer);
-
-    if (!controlState_IsInteractive(state)) {
-      strcpy(commandOutputMain[i], result);
-    }
-    output_offset += snprintf(output + output_offset, output_size - output_offset, "%s\n", result);
-    parcMemory_Deallocate((void **)&result);
-    parcBufferComposer_Release(&composer);
-  }
-
-  controlState_SetCommandOutput(state, commandOutputMain);
-
-  // DEALLOCATE
-  parcMemory_Deallocate((void **)&sourceString);
-  parcMemory_Deallocate((void **)&destinationString);
-  parcMemory_Deallocate(&receivedHeader);   // free response[0].iov_base
-  parcMemory_Deallocate(&receivedPayload);  // free response[1].iov_base
-  parcMemory_Deallocate(&response);         // free iovec pointer
-
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlListConnections.h b/hicn-light/src/hicn/config/controlListConnections.h
deleted file mode 100644
index cd5c21cec..000000000
--- a/hicn-light/src/hicn/config/controlListConnections.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 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 control_ListConnections.h
- * @brief List the current connections of hicn-light
- *
- * Implements the "list connections" node of the CLI tree
- *
- */
-
-#ifndef Control_ListConnections_h
-#define Control_ListConnections_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlListConnections_Create(ControlState *state);
-CommandOps *controlListConnections_HelpCreate(ControlState *state);
-#endif  // Control_ListConnections_h
diff --git a/hicn-light/src/hicn/config/controlListInterfaces.c b/hicn-light/src/hicn/config/controlListInterfaces.c
deleted file mode 100644
index c632a1d21..000000000
--- a/hicn-light/src/hicn/config/controlListInterfaces.c
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/config/controlListInterfaces.h>
-
-static CommandReturn _controlListInterfaces_Execute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size);
-static CommandReturn _controlListInterfaces_HelpExecute(CommandParser *parser,
-                                                        CommandOps *ops,
-                                                        PARCList *args,
-                                                        char *output,
-                                                        size_t output_size);
-
-static const char *_commandListInterfaces = "list interfaces";
-static const char *_commandListInterfacesHelp = "help list interfaces";
-
-// ====================================================
-
-CommandOps *controlListInterfaces_Create(ControlState *state) {
-  return commandOps_Create(state, _commandListInterfaces, NULL,
-                           _controlListInterfaces_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlListInterfaces_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandListInterfacesHelp, NULL,
-                           _controlListInterfaces_HelpExecute,
-                           commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlListInterfaces_HelpExecute(CommandParser *parser,
-                                                        CommandOps *ops,
-                                                        PARCList *args,
-                                                        char *output,
-                                                        size_t output_size) {
-  snprintf(output, output_size, "list interfaces\n\n")
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlListInterfaces_Execute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size) {
-  if (parcList_Size(args) != 2) {
-    _controlListInterfaces_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  //==========================        NOT IMPLEMENTED
-  //===========================
-
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlListInterfaces.h b/hicn-light/src/hicn/config/controlListInterfaces.h
deleted file mode 100644
index f885835ed..000000000
--- a/hicn-light/src/hicn/config/controlListInterfaces.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * 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 control_ListInterfaces.h
- * @brief List the icn-light interfaces
- *
- * Implements the "list interfaces" and "help list interfaces" nodes of the
- * command tree
- *
- */
-
-#ifndef Control_ListInterfaces_h
-#define Control_ListInterfaces_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlListInterfaces_Create(ControlState *state);
-CommandOps *controlListInterfaces_HelpCreate(ControlState *state);
-#endif  // Control_ListInterfaces_h
diff --git a/hicn-light/src/hicn/config/controlListListeners.c b/hicn-light/src/hicn/config/controlListListeners.c
deleted file mode 100644
index c189dfc36..000000000
--- a/hicn-light/src/hicn/config/controlListListeners.c
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-
-#include <hicn/config/controlListListeners.h>
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlListListeners_Execute(CommandParser *parser,
-                                                   CommandOps *ops,
-                                                   PARCList *args,
-                                                   char *output,
-                                                   size_t output_size);
-static CommandReturn _controlListListeners_HelpExecute(CommandParser *parser,
-                                                       CommandOps *ops,
-                                                       PARCList *args,
-                                                       char *output,
-                                                       size_t output_size);
-
-static const char *_commandListListeners = "list listeners";
-static const char *_commandListListenersHelp = "help list listeners";
-static const char *listenerType[5] = {"TCP", "UDP", "ETHER", "LOCAL", "HICN"};
-
-// ====================================================
-
-CommandOps *controlListListeners_Create(ControlState *state) {
-  return commandOps_Create(state, _commandListListeners, NULL,
-                           _controlListListeners_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlListListeners_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandListListenersHelp, NULL,
-                           _controlListListeners_HelpExecute,
-                           commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlListListeners_HelpExecute(CommandParser *parser,
-                                                       CommandOps *ops,
-                                                       PARCList *args,
-                                                       char *output,
-                                                       size_t output_size) {
-  snprintf(output, output_size, "list listeners\n\n");
-
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlListListeners_Execute(CommandParser *parser,
-                                                   CommandOps *ops,
-                                                   PARCList *args,
-                                                   char *output,
-                                                   size_t output_size) {
-  if (parcList_Size(args) != 2) {
-    _controlListListeners_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  ControlState *state = ops->closure;
-
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(state, LIST_LISTENERS, NULL, 0);
-  if (!response) {  // get NULL pointer = FAILURE
-    return CommandReturn_Failure;
-  }
-
-  // Process/Print message
-  header_control_message *receivedHeader =
-      (header_control_message *)response[0].iov_base;
-  uint8_t *receivedPayload = (uint8_t *)response[1].iov_base;
-
-  // Allocate output to pass to the main function if the call is not interactive
-  char **commandOutputMain = NULL;
-  if (!controlState_IsInteractive(state) && receivedHeader->length > 0) {
-    commandOutputMain =
-        parcMemory_Allocate(sizeof(char *) * receivedHeader->length);
-    for (size_t j = 0; j < receivedHeader->length; j++) {
-      commandOutputMain[j] = parcMemory_Allocate(sizeof(char) * 128);
-    }
-  }
-
-  char *addrString = NULL;
-  size_t output_offset = 0;
-  if (receivedHeader->length > 0) {
-    output_offset = snprintf(output, output_size, "%6.6s %.*s %50.70s %6s %10s\n", "iface", SYMBOLIC_NAME_LEN, "name", "address", "type", "interface");
-
-  } else {
-    output_offset = snprintf(output, output_size, " --- No entry in the list \n");
-  }
-
-  for (int i = 0; i < receivedHeader->length; i++) {
-    list_listeners_command *listListenersCommand =
-        (list_listeners_command *)(receivedPayload +
-                                   (i * sizeof(list_listeners_command)));
-
-    addrString = utils_CommandAddressToString(listListenersCommand->addressType,
-                                              &listListenersCommand->address,
-                                              &listListenersCommand->port);
-
-    PARCBufferComposer *composer = parcBufferComposer_Create();
-
-    if (strcmp(listenerType[listListenersCommand->encapType], "UDP") == 0 ||
-        strcmp(listenerType[listListenersCommand->encapType], "TCP") == 0) {
-      parcBufferComposer_Format(composer, "%6u %.*s %50.70s %6s %10s",
-	      listListenersCommand->connid,
-              SYMBOLIC_NAME_LEN, listListenersCommand->listenerName,
-              addrString,
-	      listenerType[listListenersCommand->encapType],
-	      listListenersCommand->interfaceName);
-    } else {
-      parcBufferComposer_Format(composer, "%6u %.*s %50.70s %6s",
-	      listListenersCommand->connid,
-              SYMBOLIC_NAME_LEN, listListenersCommand->listenerName,
-              addrString,
-	      listenerType[listListenersCommand->encapType]);
-    }
-
-    PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(composer);
-    char *result = parcBuffer_ToString(tempBuffer);
-    parcBuffer_Release(&tempBuffer);
-
-    if (!controlState_IsInteractive(state)) {
-      strncpy(commandOutputMain[i], result, 128);
-    }
-    output_offset += snprintf(output + output_offset, output_size - output_offset, "%s\n", result);
-    parcMemory_Deallocate((void **)&result);
-    parcBufferComposer_Release(&composer);
-  }
-
-  controlState_SetCommandOutput(state, commandOutputMain);
-
-  // DEALLOCATE
-  parcMemory_Deallocate((void **)&addrString);
-  parcMemory_Deallocate(&receivedHeader);   // free response[0].iov_base
-  parcMemory_Deallocate(&receivedPayload);  // free response[1].iov_base
-  parcMemory_Deallocate(&response);         // free iovec pointer
-
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlListListeners.h b/hicn-light/src/hicn/config/controlListListeners.h
deleted file mode 100644
index 11ec07579..000000000
--- a/hicn-light/src/hicn/config/controlListListeners.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * 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 control_ListListeners.h
- * @brief List the icn-light listeners
- *
- * Implements the "list listeners" and "help list listeners" nodes of the
- * command tree
- *
- */
-
-#ifndef Control_ListListeners_h
-#define Control_ListListeners_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlListListeners_Create(ControlState *state);
-CommandOps *controlListListeners_HelpCreate(ControlState *state);
-#endif  // Control_ListListeners_h
diff --git a/hicn-light/src/hicn/config/controlListPolicies.c b/hicn-light/src/hicn/config/controlListPolicies.c
deleted file mode 100644
index 8eae6453b..000000000
--- a/hicn-light/src/hicn/config/controlListPolicies.c
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
- * 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.
- */
-
-#ifdef WITH_POLICY
-#include <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Time.h>
-
-#include <hicn/config/controlListPolicies.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlListPolicies_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size);
-static CommandReturn _controlListPolicies_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size);
-
-static const char *_commandListPolicies = "list policies";
-static const char *_commandListPoliciesHelp = "help list policies";
-
-// ====================================================
-
-CommandOps *controlListPolicies_Create(ControlState *state) {
-  return commandOps_Create(state, _commandListPolicies, NULL,
-                           _controlListPolicies_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlListPolicies_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandListPoliciesHelp, NULL,
-                           _controlListPolicies_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlListPolicies_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size) {
-  snprintf(output, output_size, "command: list policies\n\n");
-  return CommandReturn_Success;
-}
-
-#define MAX(x,y) (x > y ? x : y)
-#define MAXSZ_COLUMN MAX(MAXSZ_POLICY_TAG, MAXSZ_POLICY_TAG_STATE)
-
-#define MAXSZ_STR_STAT 10
-#define MAXSZ_APP_NAME 25
-
-typedef struct {
-  #define _(x, y) char x[MAXSZ_POLICY_TAG_STATE];
-  foreach_policy_tag
-  #undef _
-} tag_state_str_t;
-
-static CommandReturn _controlListPolicies_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size) {
-  if (parcList_Size(args) != 2) {
-    _controlListPolicies_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  ControlState *state = ops->closure;
-
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(state, LIST_POLICIES, NULL, 0);
-  if (!response) {  // get NULL pointer = FAILURE
-    return CommandReturn_Failure;
-  }
-
-  // Process/Print message
-  header_control_message *receivedHeader =
-      (header_control_message *)response[0].iov_base;
-  uint8_t *receivedPayload = (uint8_t *)response[1].iov_base;
-  if (!receivedPayload) {
-      snprintf(output, output_size, "No payload!\n");
-      return CommandReturn_Failure;
-  }
-
-  // Allocate output to pass to the main function if the call is not interactive
-  char **commandOutputMain = NULL;
-  if (!controlState_IsInteractive(state) && receivedHeader->length > 0) {
-    commandOutputMain =
-        parcMemory_Allocate(sizeof(char *) * receivedHeader->length);
-    for (size_t j = 0; j < receivedHeader->length; j++) {
-      commandOutputMain[j] = parcMemory_Allocate(sizeof(char) * 128);
-    }
-  }
-
-  char *addrString = NULL;
-  in_port_t port = htons(1234);  // this is a random port number that is ignored
-  size_t output_offset = 0;
-  if (receivedHeader->length > 0) {
-    output_offset += snprintf(output, output_size, "%*s %*s", MAXSZ_PREFIX, "prefix", MAXSZ_APP_NAME /*APP_NAME_LEN*/, "app_name");
-    #define _(x, y) output_offset += snprintf(output + output_offset, output_size - output_offset, " %*s",MAXSZ_COLUMN, policy_tag_str[POLICY_TAG_ ## x]);
-    foreach_policy_tag
-    #undef _
-    output_offset += snprintf(output + output_offset, output_size - output_offset, "\n");
-  } else {
-    output_offset += snprintf(output, output_size, " --- No entry in the list \n");
-  }
-
-  tag_state_str_t str;
-
-  for (int i = 0; i < receivedHeader->length; i++) {
-    list_policies_command *listPoliciesCommand =
-        (list_policies_command *)(receivedPayload +
-                                (i * sizeof(list_policies_command)));
-
-#if 0
-    char tag_s[MAXSZ_POLICY_TAG_STATE * POLICY_TAG_N];
-
-        policy_tag_state_snprintf((char*)&tag_s[MAXSZ_POLICY_TAG_STATE * POLICY_TAG_ ## x],      \
-                MAXSZ_POLICY_TAG_STATE,                                 \
-                &listPoliciesCommand->policy.tags[POLICY_TAG_ ## x]);
-#endif
-
-    #define _(x, y) policy_tag_state_snprintf(str.x, MAXSZ_POLICY_TAG_STATE, &listPoliciesCommand->policy.tags[POLICY_TAG_ ## x]);
-    foreach_policy_tag
-    #undef _
-
-    addrString = utils_CommandAddressToString(
-        listPoliciesCommand->addressType, &listPoliciesCommand->address, &port);
-
-#if 0
-    PARCBufferComposer *composer = parcBufferComposer_Create();
-
-    parcBufferComposer_Format(
-        composer, "%*s %*s"
-        #define _(x, y) " %*s"
-        foreach_policy_tag
-        #undef _
-        "%s",
-        MAXSZ_PREFIX, addrString, APP_NAME_LEN, listPoliciesCommand->policy.app_name,
-        #define _(x, y) MAXSZ_COLUMN, str.x,
-        foreach_policy_tag
-        #undef _
-        "");
-
-    PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(composer);
-    char *result = parcBuffer_ToString(tempBuffer);
-    parcBuffer_Release(&tempBuffer);
-
-    if (!controlState_IsInteractive(state)) {
-      strcpy(commandOutputMain[i], result);
-    }
-
-    puts(result);
-    parcMemory_Deallocate((void **)&result);
-    parcBufferComposer_Release(&composer);
-#else
-    
-    output_offset = snprintf(output + output_offset, output_size - output_offset, "%*s %*s",
-    MAXSZ_PREFIX, addrString, MAXSZ_APP_NAME /*APP_NAME_LEN*/, listPoliciesCommand->policy.app_name);
-    #define _(x, y) output_offset += snprintf(output + output_offset, output_size - output_offset, " %*s", MAXSZ_COLUMN, str.x);
-    foreach_policy_tag
-    #undef _
-
-    output_offset = snprintf(output + output_offset, output_size - output_offset, "\n");
-
-    
-    /*printf("%*s %*s"
-        #define _(x, y) " %*s"
-        foreach_policy_tag
-        #undef _
-        "%s\n",
-        MAXSZ_PREFIX, addrString, MAXSZ_APP_NAME *//*APP_NAME_LEN*//*, listPoliciesCommand->policy.app_name,
-        #define _(x, y) MAXSZ_COLUMN, str.x,
-        foreach_policy_tag
-        #undef _
-        "");*/
-
-#endif
-  }
-
-  output_offset += snprintf(output + output_offset, output_size - output_offset, "\nSTATISTICS\n\n");
-  // STATISTICS
-  output_offset += snprintf(output + output_offset, output_size - output_offset, "%*s %*s %*s | %*s | %*s | %*s\n",
-          MAXSZ_PREFIX, "", MAXSZ_APP_NAME /*APP_NAME_LEN*/, "",
-          3*MAXSZ_STR_STAT+2, "WIRED", 3*MAXSZ_STR_STAT+2, "WIFI", 3*MAXSZ_STR_STAT+2, "CELLULAR", 3*MAXSZ_STR_STAT+2, "ALL");
-  output_offset += snprintf(output + output_offset, output_size - output_offset, "%*s %*s %*s %*s %*s | %*s %*s %*s | %*s %*s %*s | %*s %*s %*s\n",
-            MAXSZ_PREFIX, "prefix", MAXSZ_APP_NAME /*APP_NAME_LEN*/, "app_name",
-            MAXSZ_STR_STAT, "throughput", MAXSZ_STR_STAT, "latency", MAXSZ_STR_STAT, "loss_rate",
-            MAXSZ_STR_STAT, "throughput", MAXSZ_STR_STAT, "latency", MAXSZ_STR_STAT, "loss_rate",
-            MAXSZ_STR_STAT, "throughput", MAXSZ_STR_STAT, "latency", MAXSZ_STR_STAT, "loss_rate",
-            MAXSZ_STR_STAT, "throughput", MAXSZ_STR_STAT, "latency", MAXSZ_STR_STAT, "loss_rate");
-  for (int i = 0; i < receivedHeader->length; i++) {
-    list_policies_command *listPoliciesCommand =
-        (list_policies_command *)(receivedPayload +
-                                (i * sizeof(list_policies_command)));
-    addrString = utils_CommandAddressToString(
-        listPoliciesCommand->addressType, &listPoliciesCommand->address, &port);
-    output_offset += snprintf(output + output_offset, output_size - output_offset, "%*s %*s %*.2f %*.2f %*.2f | %*.2f %*.2f %*.2f | %*.2f %*.2f %*.2f | %*.2f %*.2f %*.2f\n",
-        MAXSZ_PREFIX, addrString, MAXSZ_APP_NAME, listPoliciesCommand->policy.app_name,
-        MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.wired.throughput,
-        MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.wired.latency,
-        MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.wired.loss_rate,
-        MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.wifi.throughput,
-        MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.wifi.latency,
-        MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.wifi.loss_rate,
-        MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.cellular.throughput,
-        MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.cellular.latency,
-        MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.cellular.loss_rate,
-        MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.all.throughput,
-        MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.all.latency,
-        MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.all.loss_rate);
- }
-
-  controlState_SetCommandOutput(state, commandOutputMain);
-
-  // DEALLOCATE
-  parcMemory_Deallocate((void **)&addrString);
-  parcMemory_Deallocate(&receivedHeader);   // free response[0].iov_base
-  parcMemory_Deallocate(&receivedPayload);  // free response[1].iov_base
-  parcMemory_Deallocate(&response);         // free iovec pointer
-
-  return CommandReturn_Success;
-}
-
-#endif /* WITH_POLICY */
diff --git a/hicn-light/src/hicn/config/controlListPolicies.h b/hicn-light/src/hicn/config/controlListPolicies.h
deleted file mode 100644
index 7aa0bdd26..000000000
--- a/hicn-light/src/hicn/config/controlListPolicies.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * 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 control_ListPolicies.h
- * @brief List the icn-light policies
- *
- * Implements the "list policies" and "help list policies" nodes of the command tree
- *
- */
-#ifndef Control_ListPolicies_h
-#define Control_ListPolicies_h
-
-#ifdef WITH_POLICY
-
-#include <hicn/config/controlState.h>
-CommandOps *controlListPolicies_Create(ControlState *state);
-CommandOps *controlListPolicies_HelpCreate(ControlState *state);
-
-#endif /* WITH_POLICY */
-
-#endif  // Control_ListPolicies_h
diff --git a/hicn-light/src/hicn/config/controlListRoutes.c b/hicn-light/src/hicn/config/controlListRoutes.c
deleted file mode 100644
index 395251b94..000000000
--- a/hicn-light/src/hicn/config/controlListRoutes.c
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Time.h>
-
-#include <hicn/config/controlListRoutes.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlListRoutes_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size);
-static CommandReturn _controlListRoutes_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size);
-
-static const char *_commandListRoutes = "list routes";
-static const char *_commandListRoutesHelp = "help list routes";
-
-// ====================================================
-
-CommandOps *controlListRoutes_Create(ControlState *state) {
-  return commandOps_Create(state, _commandListRoutes, NULL,
-                           _controlListRoutes_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlListRoutes_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandListRoutesHelp, NULL,
-                           _controlListRoutes_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlListRoutes_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size) {
-  snprintf(output, output_size, "command: list routes\n"
-                                "\n"
-                                "This command will fetch the prefix routing table.  For each route, it "
-                                "will list:\n"
-                                "   iface:    interface\n"
-                                "   protocol: the routing protocol, such as STATIC, CONNECTED, etc.\n"
-                                "   type:     LMP or EXACT (longest matching prefix or exact match)\n"
-                                "   cost:     The route cost, lower being preferred\n"
-                                "   next:     List of next hops by interface id\n"
-                                "   prefix:   name prefix\n"
-                                "\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlListRoutes_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size) {
-  if (parcList_Size(args) != 2) {
-    _controlListRoutes_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  ControlState *state = ops->closure;
-
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(state, LIST_ROUTES, NULL, 0);
-  if (!response) {  // get NULL pointer = FAILURE
-    return CommandReturn_Failure;
-  }
-
-  // Process/Print message
-  header_control_message *receivedHeader =
-      (header_control_message *)response[0].iov_base;
-  uint8_t *receivedPayload = (uint8_t *)response[1].iov_base;
-
-  // Allocate output to pass to the main function if the call is not interactive
-  char **commandOutputMain = NULL;
-  if (!controlState_IsInteractive(state) && receivedHeader->length > 0) {
-    commandOutputMain =
-        parcMemory_Allocate(sizeof(char *) * receivedHeader->length);
-    for (size_t j = 0; j < receivedHeader->length; j++) {
-      commandOutputMain[j] = parcMemory_Allocate(sizeof(char) * 128);
-    }
-  }
-
-  char *addrString = NULL;
-  in_port_t port = htons(1234);  // this is a random port number that is ignored
-  size_t output_offset = 0;
-  if (receivedHeader->length > 0) {
-    output_offset = snprintf(output, output_size, "%6.6s %8.8s %70.70s %s\n", "iface", "cost", "prefix", "len");
-  } else {
-    output_offset = snprintf(output, output_size, " --- No entry in the list \n");
-  }
-
-  for (int i = 0; i < receivedHeader->length; i++) {
-    list_routes_command *listRoutesCommand =
-        (list_routes_command *)(receivedPayload +
-                                (i * sizeof(list_routes_command)));
-
-    addrString = utils_CommandAddressToString(
-        listRoutesCommand->addressType, &listRoutesCommand->address, &port);
-
-    PARCBufferComposer *composer = parcBufferComposer_Create();
-
-    parcBufferComposer_Format(
-        composer, "%6u %8u %70.70s %3d", listRoutesCommand->connid,
-        listRoutesCommand->cost, addrString, listRoutesCommand->len);
-
-    PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(composer);
-    char *result = parcBuffer_ToString(tempBuffer);
-    parcBuffer_Release(&tempBuffer);
-
-    if (!controlState_IsInteractive(state)) {
-      strcpy(commandOutputMain[i], result);
-    }
-
-    output_offset += snprintf(output + output_offset, output_size - output_offset, "%s\n", result);
-    parcMemory_Deallocate((void **)&result);
-    parcBufferComposer_Release(&composer);
-  }
-
-  controlState_SetCommandOutput(state, commandOutputMain);
-
-  // DEALLOCATE
-  parcMemory_Deallocate((void **)&addrString);
-  parcMemory_Deallocate(&receivedHeader);   // free response[0].iov_base
-  parcMemory_Deallocate(&receivedPayload);  // free response[1].iov_base
-  parcMemory_Deallocate(&response);         // free iovec pointer
-
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlListRoutes.h b/hicn-light/src/hicn/config/controlListRoutes.h
deleted file mode 100644
index 341552add..000000000
--- a/hicn-light/src/hicn/config/controlListRoutes.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * 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 control_ListRoutes.h
- * @brief List the icn-light routes
- *
- * Implements the "list routes" and "help list routes" nodes of the command tree
- *
- */
-#ifndef Control_ListRoutes_h
-#define Control_ListRoutes_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlListRoutes_Create(ControlState *state);
-CommandOps *controlListRoutes_HelpCreate(ControlState *state);
-#endif  // Control_ListRoutes_h
diff --git a/hicn-light/src/hicn/config/controlMapMe.c b/hicn-light/src/hicn/config/controlMapMe.c
deleted file mode 100644
index b292ee0f0..000000000
--- a/hicn-light/src/hicn/config/controlMapMe.c
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-
-#include <hicn/config/controlMapMe.h>
-#include <hicn/config/controlMapMeDiscovery.h>
-#include <hicn/config/controlMapMeEnable.h>
-#include <hicn/config/controlMapMeRetx.h>
-#include <hicn/config/controlMapMeTimescale.h>
-
-static void _controlMapMe_Init(CommandParser *parser, CommandOps *ops);
-static CommandReturn _controlMapMe_Execute(CommandParser *parser,
-                                           CommandOps *ops,
-                                           PARCList *args,
-                                           char *output,
-                                           size_t output_size);
-static CommandReturn _controlMapMe_HelpExecute(CommandParser *parser,
-                                               CommandOps *ops,
-                                               PARCList *args,
-                                               char *output,
-                                               size_t output_size);
-
-static const char *_commandMapMe = "mapme";
-static const char *_commandMapMeHelp = "help mapme";
-
-CommandOps *controlMapMe_Create(ControlState *state) {
-  return commandOps_Create(state, _commandMapMe, _controlMapMe_Init,
-                           _controlMapMe_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlMapMe_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandMapMeHelp, NULL,
-                           _controlMapMe_HelpExecute, commandOps_Destroy);
-}
-
-// =====================================================
-
-static CommandReturn _controlMapMe_HelpExecute(CommandParser *parser,
-                                               CommandOps *ops,
-                                               PARCList *args,
-                                               char *output,
-                                               size_t output_size) {
-  CommandOps *ops_mapme_enable = controlMapMeEnable_HelpCreate(NULL);
-  CommandOps *ops_mapme_discovery = controlMapMeDiscovery_HelpCreate(NULL);
-  CommandOps *ops_mapme_timescale = controlMapMeTimescale_HelpCreate(NULL);
-  CommandOps *ops_mapme_retx = controlMapMeRetx_HelpCreate(NULL);
-
-  snprintf(output, output_size, "Available commands:\n"
-                                "   %s\n   %s\n   %s\n   %s\n\n",
-                                ops_mapme_enable->command,
-                                ops_mapme_discovery->command,
-                                ops_mapme_timescale->command,
-                                ops_mapme_retx->command);
-
-  commandOps_Destroy(&ops_mapme_enable);
-  commandOps_Destroy(&ops_mapme_discovery);
-  commandOps_Destroy(&ops_mapme_timescale);
-  commandOps_Destroy(&ops_mapme_retx);
-
-  return CommandReturn_Success;
-}
-
-static void _controlMapMe_Init(CommandParser *parser, CommandOps *ops) {
-  ControlState *state = ops->closure;
-  controlState_RegisterCommand(state, controlMapMeEnable_HelpCreate(state));
-  controlState_RegisterCommand(state, controlMapMeDiscovery_HelpCreate(state));
-  controlState_RegisterCommand(state, controlMapMeTimescale_HelpCreate(state));
-  controlState_RegisterCommand(state, controlMapMeRetx_HelpCreate(state));
-  controlState_RegisterCommand(state, controlMapMeEnable_Create(state));
-  controlState_RegisterCommand(state, controlMapMeDiscovery_Create(state));
-  controlState_RegisterCommand(state, controlMapMeTimescale_Create(state));
-  controlState_RegisterCommand(state, controlMapMeRetx_Create(state));
-}
-
-static CommandReturn _controlMapMe_Execute(CommandParser *parser,
-                                           CommandOps *ops,
-                                           PARCList *args,
-                                           char *output,
-                                           size_t output_size) {
-  return _controlMapMe_HelpExecute(parser, ops, args, output, output_size);
-}
-
-// ======================================================================
diff --git a/hicn-light/src/hicn/config/controlMapMe.h b/hicn-light/src/hicn/config/controlMapMe.h
deleted file mode 100644
index 3edd78989..000000000
--- a/hicn-light/src/hicn/config/controlMapMe.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 controlMapMe_h
-#define controlMapMe_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlMapMe_Create(ControlState *state);
-CommandOps *controlMapMe_HelpCreate(ControlState *state);
-#endif  // controlMapMe_h
diff --git a/hicn-light/src/hicn/config/controlMapMeDiscovery.c b/hicn-light/src/hicn/config/controlMapMeDiscovery.c
deleted file mode 100644
index 6ec941141..000000000
--- a/hicn-light/src/hicn/config/controlMapMeDiscovery.c
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/config/controlMapMeDiscovery.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlMapMeDiscovery_Execute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size);
-static CommandReturn _controlMapMeDiscovery_HelpExecute(CommandParser *parser,
-                                                        CommandOps *ops,
-                                                        PARCList *args,
-                                                        char *output,
-                                                        size_t output_size);
-
-static const char *_commandMapMeDiscovery = "mapme discovery";
-static const char *_commandMapMeDiscoveryHelp = "help mapme discovery";
-
-// ====================================================
-
-CommandOps *controlMapMeDiscovery_Create(ControlState *state) {
-  return commandOps_Create(state, _commandMapMeDiscovery, NULL,
-                           _controlMapMeDiscovery_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlMapMeDiscovery_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandMapMeDiscoveryHelp, NULL,
-                           _controlMapMeDiscovery_HelpExecute,
-                           commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlMapMeDiscovery_HelpExecute(CommandParser *parser,
-                                                        CommandOps *ops,
-                                                        PARCList *args,
-                                                        char *output,
-                                                        size_t output_size) {
-  snprintf(output, output_size, "mapme discovery [on|off]\n\n");
-
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlMapMeDiscovery_Execute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size) {
-  if (parcList_Size(args) != 3) {
-    _controlMapMeDiscovery_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  bool active;
-  if (strcmp(parcList_GetAtIndex(args, 2), "on") == 0) {
-    active = true;
-  } else if (strcmp(parcList_GetAtIndex(args, 2), "off") == 0) {
-    active = false;
-  } else {
-    _controlMapMeDiscovery_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  mapme_activator_command *mapmeDiscoveryCommand =
-      parcMemory_AllocateAndClear(sizeof(mapme_activator_command));
-  if (active) {
-    mapmeDiscoveryCommand->activate = ACTIVATE_ON;
-  } else {
-    mapmeDiscoveryCommand->activate = ACTIVATE_OFF;
-  }
-
-  ControlState *state = ops->closure;
-  // send message and receive response
-  struct iovec *response =
-      utils_SendRequest(state, MAPME_DISCOVERY, mapmeDiscoveryCommand,
-                        sizeof(mapme_activator_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlMapMeDiscovery.h b/hicn-light/src/hicn/config/controlMapMeDiscovery.h
deleted file mode 100644
index c2832632a..000000000
--- a/hicn-light/src/hicn/config/controlMapMeDiscovery.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 Control_MapMeDiscovery_h
-#define Control_MapMeDiscovery_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlMapMeDiscovery_Create(ControlState *state);
-CommandOps *controlMapMeDiscovery_HelpCreate(ControlState *state);
-#endif  // Control_MapMeDiscovery_h
diff --git a/hicn-light/src/hicn/config/controlMapMeEnable.c b/hicn-light/src/hicn/config/controlMapMeEnable.c
deleted file mode 100644
index 0595cc346..000000000
--- a/hicn-light/src/hicn/config/controlMapMeEnable.c
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/config/controlMapMeEnable.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlMapMeEnable_Execute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size);
-static CommandReturn _controlMapMeEnable_HelpExecute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size);
-
-static const char *_commandMapMeEnable = "mapme enable";
-static const char *_commandMapMeEnableHelp = "help mapme enable";
-
-// ====================================================
-
-CommandOps *controlMapMeEnable_Create(ControlState *state) {
-  return commandOps_Create(state, _commandMapMeEnable, NULL,
-                           _controlMapMeEnable_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlMapMeEnable_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandMapMeEnableHelp, NULL,
-                           _controlMapMeEnable_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlMapMeEnable_HelpExecute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size) {
-  snprintf(output, output_size, "mapme enable [on|off]\n\n");
-
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlMapMeEnable_Execute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size) {
-  if (parcList_Size(args) != 3) {
-    _controlMapMeEnable_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  bool active;
-  if (strcmp(parcList_GetAtIndex(args, 2), "on") == 0) {
-    active = true;
-  } else if (strcmp(parcList_GetAtIndex(args, 2), "off") == 0) {
-    active = false;
-  } else {
-    _controlMapMeEnable_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  mapme_activator_command *mapmeEnableCommand =
-      parcMemory_AllocateAndClear(sizeof(mapme_activator_command));
-  if (active) {
-    mapmeEnableCommand->activate = ACTIVATE_ON;
-  } else {
-    mapmeEnableCommand->activate = ACTIVATE_OFF;
-  }
-
-  ControlState *state = ops->closure;
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(
-      state, MAPME_ENABLE, mapmeEnableCommand, sizeof(mapme_activator_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlMapMeEnable.h b/hicn-light/src/hicn/config/controlMapMeEnable.h
deleted file mode 100644
index 0ce4970f3..000000000
--- a/hicn-light/src/hicn/config/controlMapMeEnable.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 Control_MapMeEnable_h
-#define Control_MapMeEnable_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlMapMeEnable_Create(ControlState *state);
-CommandOps *controlMapMeEnable_HelpCreate(ControlState *state);
-#endif  // Control_MapMeEnable_h
diff --git a/hicn-light/src/hicn/config/controlMapMeRetx.c b/hicn-light/src/hicn/config/controlMapMeRetx.c
deleted file mode 100644
index 9f37ca6f5..000000000
--- a/hicn-light/src/hicn/config/controlMapMeRetx.c
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/config/controlMapMeRetx.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlMapMeRetx_Execute(CommandParser *parser,
-                                               CommandOps *ops,
-                                               PARCList *args,
-                                               char *output,
-                                               size_t output_size);
-static CommandReturn _controlMapMeRetx_HelpExecute(CommandParser *parser,
-                                                   CommandOps *ops,
-                                                   PARCList *args,
-                                                   char *output,
-                                                   size_t output_size);
-
-static const char *_commandMapMeRetx = "mapme retx";
-static const char *_commandMapMeRetxHelp = "help mapme retx";
-
-// ====================================================
-
-CommandOps *controlMapMeRetx_Create(ControlState *state) {
-  return commandOps_Create(state, _commandMapMeRetx, NULL,
-                           _controlMapMeRetx_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlMapMeRetx_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandMapMeRetxHelp, NULL,
-                           _controlMapMeRetx_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlMapMeRetx_HelpExecute(CommandParser *parser,
-                                                   CommandOps *ops,
-                                                   PARCList *args,
-                                                   char *output,
-                                                   size_t output_size) {
-  snprintf(output, output_size,  "mapme retx <milliseconds>\n\n");
-
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlMapMeRetx_Execute(CommandParser *parser,
-                                               CommandOps *ops,
-                                               PARCList *args,
-                                               char *output,
-                                               size_t output_size) {
-  if (parcList_Size(args) != 3) {
-    _controlMapMeRetx_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  const char *rtx = parcList_GetAtIndex(args, 2);
-  if (!utils_IsNumber(rtx)) {
-    snprintf(output, output_size,
-        "ERROR: retransmission value (expressed in ms) must be a positive "
-        "integer \n");
-    return CommandReturn_Failure;
-  }
-
-  mapme_timing_command *mapmeRetxCommand =
-      parcMemory_AllocateAndClear(sizeof(mapme_timing_command));
-  mapmeRetxCommand->timePeriod = (unsigned)strtold(rtx, NULL);
-
-  ControlState *state = ops->closure;
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(
-      state, MAPME_RETX, mapmeRetxCommand, sizeof(mapme_timing_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlMapMeRetx.h b/hicn-light/src/hicn/config/controlMapMeRetx.h
deleted file mode 100644
index 3e3b2de15..000000000
--- a/hicn-light/src/hicn/config/controlMapMeRetx.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 Control_MapMeRetx_h
-#define Control_MapMeRetx_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlMapMeRetx_Create(ControlState *state);
-CommandOps *controlMapMeRetx_HelpCreate(ControlState *state);
-#endif  // Control_MapMeRetx_h
diff --git a/hicn-light/src/hicn/config/controlMapMeTimescale.c b/hicn-light/src/hicn/config/controlMapMeTimescale.c
deleted file mode 100644
index 51701aa2f..000000000
--- a/hicn-light/src/hicn/config/controlMapMeTimescale.c
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/config/controlMapMeTimescale.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlMapMeTimescale_Execute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size);
-static CommandReturn _controlMapMeTimescale_HelpExecute(CommandParser *parser,
-                                                        CommandOps *ops,
-                                                        PARCList *args,
-                                                        char *output,
-                                                        size_t output_size);
-
-static const char *_commandMapMeTimescale = "mapme timescale";
-static const char *_commandMapMeTimescaleHelp = "help mapme timescale";
-
-// ====================================================
-
-CommandOps *controlMapMeTimescale_Create(ControlState *state) {
-  return commandOps_Create(state, _commandMapMeTimescale, NULL,
-                           _controlMapMeTimescale_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlMapMeTimescale_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandMapMeTimescaleHelp, NULL,
-                           _controlMapMeTimescale_HelpExecute,
-                           commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlMapMeTimescale_HelpExecute(CommandParser *parser,
-                                                        CommandOps *ops,
-                                                        PARCList *args,
-                                                        char *output,
-                                                        size_t output_size) {
-  snprintf(output, output_size, "mapme timescale <milliseconds>\n\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlMapMeTimescale_Execute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size) {
-  if (parcList_Size(args) != 3) {
-    _controlMapMeTimescale_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  const char *ts = parcList_GetAtIndex(args, 2);
-  if (!utils_IsNumber(ts)) {
-    snprintf(output, output_size, 
-        "ERROR: timescale value (expressed in ms) must be a positive integer "
-        "\n");
-    return CommandReturn_Failure;
-  }
-
-  mapme_timing_command *mapmeTimescaleCommand =
-      parcMemory_AllocateAndClear(sizeof(mapme_timing_command));
-  mapmeTimescaleCommand->timePeriod = (unsigned)strtold(ts, NULL);
-
-  ControlState *state = ops->closure;
-  // send message and receive response
-  struct iovec *response =
-      utils_SendRequest(state, MAPME_TIMESCALE, mapmeTimescaleCommand,
-                        sizeof(mapme_timing_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlMapMeTimescale.h b/hicn-light/src/hicn/config/controlMapMeTimescale.h
deleted file mode 100644
index 947d00a5d..000000000
--- a/hicn-light/src/hicn/config/controlMapMeTimescale.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 Control_MapMeTimescale_h
-#define Control_MapMeTimescale_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlMapMeTimescale_Create(ControlState *state);
-CommandOps *controlMapMeTimescale_HelpCreate(ControlState *state);
-#endif  // Control_MapMeTimescale_h
diff --git a/hicn-light/src/hicn/config/controlQuit.c b/hicn-light/src/hicn/config/controlQuit.c
deleted file mode 100644
index 621880d13..000000000
--- a/hicn-light/src/hicn/config/controlQuit.c
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/security/parc_Security.h>
-
-#include <hicn/config/controlQuit.h>
-
-static CommandReturn _controlQuit_Execute(CommandParser *parser,
-                                          CommandOps *ops,
-                                          PARCList *args,
-                                          char *output,
-                                          size_t output_size);
-static CommandReturn _controlQuit_HelpExecute(CommandParser *parser,
-                                              CommandOps *ops,
-                                              PARCList *args,
-                                              char *output,
-                                              size_t output_size);
-
-static const char *_commandQuit = "quit";
-static const char *_commandQuitHelp = "help quit";
-
-// ====================================================
-
-CommandOps *controlQuit_Create(ControlState *state) {
-  return commandOps_Create(state, _commandQuit, NULL, _controlQuit_Execute,
-                           commandOps_Destroy);
-}
-
-CommandOps *controlQuit_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandQuitHelp, NULL,
-                           _controlQuit_HelpExecute, commandOps_Destroy);
-}
-
-// ==============================================
-
-static CommandReturn _controlQuit_HelpExecute(CommandParser *parser,
-                                              CommandOps *ops,
-                                              PARCList *args,
-                                              char *output,
-                                              size_t output_size) {
-  snprintf(output, output_size, "Exits the interactive control program\n\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlQuit_Execute(CommandParser *parser,
-                                          CommandOps *ops,
-                                          PARCList *args,
-                                          char *output,
-                                          size_t output_size) {
-  snprintf(output, output_size, "exiting interactive shell\n");
-  return CommandReturn_Exit;
-}
diff --git a/hicn-light/src/hicn/config/controlQuit.h b/hicn-light/src/hicn/config/controlQuit.h
deleted file mode 100644
index b45d5e215..000000000
--- a/hicn-light/src/hicn/config/controlQuit.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * 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 control_Quit.h
- * @brief The quit command
- *
- * Implements the "quit" and "help quit" nodes of the command tree
- *
- */
-#ifndef Control_Quit_h
-#define Control_Quit_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlQuit_Create(ControlState *state);
-CommandOps *controlQuit_HelpCreate(ControlState *state);
-#endif  // Control_Quit_h
diff --git a/hicn-light/src/hicn/config/controlRemove.c b/hicn-light/src/hicn/config/controlRemove.c
deleted file mode 100644
index b1a88b5c1..000000000
--- a/hicn-light/src/hicn/config/controlRemove.c
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/security/parc_Security.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/config/controlRemove.h>
-#include <hicn/config/controlRemoveListener.h>
-#include <hicn/config/controlRemoveConnection.h>
-#include <hicn/config/controlRemovePunting.h>
-#include <hicn/config/controlRemoveRoute.h>
-#ifdef WITH_POLICY
-#include <hicn/config/controlRemovePolicy.h>
-#endif /* WITH_POLICY */
-
-static void _controlRemove_Init(CommandParser *parser, CommandOps *ops);
-static CommandReturn _controlRemove_Execute(CommandParser *parser,
-                                            CommandOps *ops,
-                                            PARCList *args,
-                                            char *output,
-                                            size_t output_size);
-static CommandReturn _controlRemove_HelpExecute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size);
-
-static const char *_commandRemove = "remove";
-static const char *_commandRemoveHelp = "help remove";
-
-// ====================================================
-
-CommandOps *controlRemove_Create(ControlState *state) {
-  return commandOps_Create(state, _commandRemove, _controlRemove_Init,
-                           _controlRemove_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlRemove_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandRemoveHelp, NULL,
-                           _controlRemove_HelpExecute, commandOps_Destroy);
-}
-
-// ==============================================
-
-static CommandReturn _controlRemove_HelpExecute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size) {
-  CommandOps *ops_remove_connection = controlRemoveConnection_Create(NULL);
-  CommandOps *ops_remove_listener = controlRemoveListener_Create(NULL);
-  CommandOps *ops_remove_route = controlRemoveRoute_Create(NULL);
-  CommandOps *ops_remove_punting = controlRemovePunting_Create(NULL);
-#ifdef WITH_POLICY
-  CommandOps *ops_remove_policy = controlRemovePolicy_Create(NULL);
-#endif /* WITH_POLICY */
-
-  snprintf(output, output_size, "Available commands:\n"
-                                "   %s\n"
-                                "   %s\n"
-                                "   %s\n"
-                                "   %s\n"
-#ifdef WITH_POLICY
-                                "   %s\n"
-#endif /* WITH_POLICY */
-                                "\n",
-                                ops_remove_connection->command,
-                                ops_remove_listener->command,
-                                ops_remove_route->command,
-                                ops_remove_punting->command
-#ifdef WITH_POLICY
-                                , ops_remove_policy->command
-#endif /* WITH_POLICY */
-  );
-
-  commandOps_Destroy(&ops_remove_connection);
-  commandOps_Destroy(&ops_remove_listener);
-  commandOps_Destroy(&ops_remove_route);
-  commandOps_Destroy(&ops_remove_punting);
-#ifdef WITH_POLICY
-  commandOps_Destroy(&ops_remove_policy);
-#endif /* WITH_POLICY */
-  return CommandReturn_Success;
-}
-
-static void _controlRemove_Init(CommandParser *parser, CommandOps *ops) {
-  ControlState *state = ops->closure;
-  controlState_RegisterCommand(state,
-                               controlRemoveConnection_HelpCreate(state));
-  controlState_RegisterCommand(state,
-                               controlRemoveListener_HelpCreate(state));
-  controlState_RegisterCommand(state, controlRemoveRoute_HelpCreate(state));
-  controlState_RegisterCommand(state, controlRemoveConnection_Create(state));
-  controlState_RegisterCommand(state, controlRemoveListener_Create(state));
-  controlState_RegisterCommand(state, controlRemoveRoute_Create(state));
-  controlState_RegisterCommand(state, controlRemovePunting_Create(state));
-  controlState_RegisterCommand(state, controlRemovePunting_HelpCreate(state));
-#ifdef WITH_POLICY
-  controlState_RegisterCommand(state, controlRemovePolicy_HelpCreate(state));
-  controlState_RegisterCommand(state, controlRemovePolicy_Create(state));
-#endif /* WITH_POLICY */
-}
-
-static CommandReturn _controlRemove_Execute(CommandParser *parser,
-                                            CommandOps *ops,
-                                            PARCList *args,
-                                            char *output,
-                                            size_t output_size) {
-  return _controlRemove_HelpExecute(parser, ops, args, output, output_size);
-}
diff --git a/hicn-light/src/hicn/config/controlRemove.h b/hicn-light/src/hicn/config/controlRemove.h
deleted file mode 100644
index 863555728..000000000
--- a/hicn-light/src/hicn/config/controlRemove.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * 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 control_Remove.h
- * @brief Implements the remove node of the CLI tree
- *
- * Implements the "remove" and "help remove" nodes of the command tree
- *
- */
-#ifndef controlRemove_h
-#define controlRemove_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlRemove_Create(ControlState *state);
-CommandOps *controlRemove_HelpCreate(ControlState *state);
-#endif  // controlRemove_h
diff --git a/hicn-light/src/hicn/config/controlRemoveConnection.c b/hicn-light/src/hicn/config/controlRemoveConnection.c
deleted file mode 100644
index a6cfae1e5..000000000
--- a/hicn-light/src/hicn/config/controlRemoveConnection.c
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <ctype.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-#include <hicn/utils/address.h>
-
-#include <hicn/config/controlRemoveConnection.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlRemoveConnection_Execute(CommandParser *parser,
-                                                      CommandOps *ops,
-                                                      PARCList *args,
-                                                      char *output,
-                                                      size_t output_size);
-static CommandReturn _controlRemoveConnection_HelpExecute(CommandParser *parser,
-                                                          CommandOps *ops,
-                                                          PARCList *args,
-                                                          char *output,
-                                                          size_t output_size);
-
-// ===================================================
-
-static const char *_commandRemoveConnection = "remove connection";
-static const char *_commandRemoveConnectionHelp = "help remove connection";
-
-// ====================================================
-
-CommandOps *controlRemoveConnection_Create(ControlState *state) {
-  return commandOps_Create(state, _commandRemoveConnection, NULL,
-                           _controlRemoveConnection_Execute,
-                           commandOps_Destroy);
-}
-
-CommandOps *controlRemoveConnection_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandRemoveConnectionHelp, NULL,
-                           _controlRemoveConnection_HelpExecute,
-                           commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlRemoveConnection_HelpExecute(CommandParser *parser,
-                                                          CommandOps *ops,
-                                                          PARCList *args,
-                                                          char *output,
-                                                          size_t output_size) {
-  snprintf(output, output_size, "command:\n"
-                                "    remove connection <symbolic|id>\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlRemoveConnection_Execute(CommandParser *parser,
-                                                      CommandOps *ops,
-                                                      PARCList *args,
-                                                      char *output,
-                                                      size_t output_size) {
-  ControlState *state = ops->closure;
-
-  if (parcList_Size(args) != 3) {
-    _controlRemoveConnection_HelpExecute(parser, ops, args, output, output_size);
-    return false;
-  }
-
-  if ((strcmp(parcList_GetAtIndex(args, 0), "remove") != 0) ||
-      (strcmp(parcList_GetAtIndex(args, 1), "connection") != 0)) {
-    _controlRemoveConnection_HelpExecute(parser, ops, args, output, output_size);
-    return false;
-  }
-
-  const char *symbolicOrConnid = parcList_GetAtIndex(args, 2);
-
-  if (!utils_ValidateSymbolicName(symbolicOrConnid) &&
-      !utils_IsNumber(symbolicOrConnid)) {
-    snprintf(output, output_size, 
-        "ERROR: Invalid symbolic or connid:\nsymbolic name must begin with an "
-        "alpha followed by alphanum;\nconnid must be an integer\n");
-    return CommandReturn_Failure;
-  }
-
-  // allocate command payload
-  remove_connection_command *removeConnectionCommand =
-      parcMemory_AllocateAndClear(sizeof(remove_connection_command));
-  // fill payload
-  strcpy(removeConnectionCommand->symbolicOrConnid, symbolicOrConnid);
-
-  // send message and receive response
-  struct iovec *response =
-      utils_SendRequest(state, REMOVE_CONNECTION, removeConnectionCommand,
-                        sizeof(remove_connection_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlRemoveConnection.h b/hicn-light/src/hicn/config/controlRemoveConnection.h
deleted file mode 100644
index 51d3a52a8..000000000
--- a/hicn-light/src/hicn/config/controlRemoveConnection.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * 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 control_RemoveConnection.h
- * @brief Remove a connection from the connection table
- *
- * Implements the "remove connection" and "help remove connection" nodes of the
- * CLI tree
- *
- */
-
-#ifndef Control_RemoveConnection_h
-#define Control_RemoveConnection_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlRemoveConnection_Create(ControlState *state);
-CommandOps *controlRemoveConnection_HelpCreate(ControlState *state);
-#endif  // Control_RemoveConnection_h
diff --git a/hicn-light/src/hicn/config/controlRemoveListener.c b/hicn-light/src/hicn/config/controlRemoveListener.c
deleted file mode 100644
index 7525316f1..000000000
--- a/hicn-light/src/hicn/config/controlRemoveListener.c
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <ctype.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-#include <hicn/utils/address.h>
-
-#include <hicn/config/controlRemoveListener.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlRemoveListener_Execute(CommandParser *parser,
-                                                      CommandOps *ops,
-                                                      PARCList *args,
-                                                      char *output,
-                                                      size_t output_size);
-static CommandReturn _controlRemoveListener_HelpExecute(CommandParser *parser,
-                                                          CommandOps *ops,
-                                                          PARCList *args,
-                                                          char *output,
-                                                          size_t output_size);
-
-// ===================================================
-
-static const char *_commandRemoveListener = "remove listener";
-static const char *_commandRemoveListenerHelp = "help remove listener";
-
-// ====================================================
-
-CommandOps *controlRemoveListener_Create(ControlState *state) {
-  return commandOps_Create(state, _commandRemoveListener, NULL,
-                           _controlRemoveListener_Execute,
-                           commandOps_Destroy);
-}
-
-CommandOps *controlRemoveListener_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandRemoveListenerHelp, NULL,
-                           _controlRemoveListener_HelpExecute,
-                           commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlRemoveListener_HelpExecute(CommandParser *parser,
-                                                          CommandOps *ops,
-                                                          PARCList *args,
-                                                          char *output,
-                                                          size_t output_size) {
-  snprintf(output, output_size, "command:\n"
-                                "    remove listener <symbolic|id>\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlRemoveListener_Execute(CommandParser *parser,
-                                                      CommandOps *ops,
-                                                      PARCList *args,
-                                                      char *output,
-                                                      size_t output_size) {
-  ControlState *state = ops->closure;
-
-  if (parcList_Size(args) != 3) {
-    _controlRemoveListener_HelpExecute(parser, ops, args, output, output_size);
-    return false;
-  }
-
-  if ((strcmp(parcList_GetAtIndex(args, 0), "remove") != 0) ||
-      (strcmp(parcList_GetAtIndex(args, 1), "listener") != 0)) {
-    _controlRemoveListener_HelpExecute(parser, ops, args, output, output_size);
-    return false;
-  }
-
-  const char *listenerId = parcList_GetAtIndex(args, 2);
-
-if (!utils_ValidateSymbolicName(listenerId) &&
-      !utils_IsNumber(listenerId)) {
-    snprintf(output, output_size,
-        "ERROR: Invalid symbolic or listenerId:\nsymbolic name must begin with an "
-        "alpha followed by alphanum;\nlistenerId must be an integer\n");
-    return CommandReturn_Failure;
-  }
-
-  // allocate command payload
-  remove_listener_command *removeListenerCommand =
-      parcMemory_AllocateAndClear(sizeof(remove_listener_command));
-  // fill payload
-  //removeListenerCommand->listenerId = atoi(listenerId);
-  snprintf(removeListenerCommand->symbolicOrListenerid, SYMBOLIC_NAME_LEN, "%s", listenerId);
-
-  // send message and receive response
-  struct iovec *response =
-      utils_SendRequest(state, REMOVE_LISTENER, removeListenerCommand,
-                        sizeof(remove_listener_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlRemoveListener.h b/hicn-light/src/hicn/config/controlRemoveListener.h
deleted file mode 100644
index 794d1e1a9..000000000
--- a/hicn-light/src/hicn/config/controlRemoveListener.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * 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 control_RemoveConnection.h
- * @brief Remove a connection from the connection table
- *
- * Implements the "remove connection" and "help remove connection" nodes of the
- * CLI tree
- *
- */
-
-#ifndef Control_RemoveListener_h
-#define Control_RemoveListener_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlRemoveListener_Create(ControlState *state);
-CommandOps *controlRemoveListener_HelpCreate(ControlState *state);
-#endif  // Control_RemoveListener_h
diff --git a/hicn-light/src/hicn/config/controlRemovePolicy.c b/hicn-light/src/hicn/config/controlRemovePolicy.c
deleted file mode 100644
index 35741396e..000000000
--- a/hicn-light/src/hicn/config/controlRemovePolicy.c
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * 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.
- */
-
-#ifdef WITH_POLICY
-
-#include <hicn/hicn-light/config.h>
-
-#include <ctype.h>
-#include <parc/algol/parc_List.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-#include <parc/assert/parc_Assert.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <hicn/utils/address.h>
-
-#include <hicn/config/controlRemovePolicy.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlRemovePolicy_Execute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size);
-static CommandReturn _controlRemovePolicy_HelpExecute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size);
-
-// ===================================================
-
-static const char *_commandRemovePolicy = "remove policy";
-static const char *_commandRemovePolicyHelp = "help remove policy";
-
-// ====================================================
-
-CommandOps *controlRemovePolicy_Create(ControlState *state) {
-  return commandOps_Create(state, _commandRemovePolicy, NULL,
-                           _controlRemovePolicy_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlRemovePolicy_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandRemovePolicyHelp, NULL,
-                           _controlRemovePolicy_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlRemovePolicy_HelpExecute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size) {
-  snprintf(output, output_size, "commands:\n"
-                                "    remove policy <prefix>\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlRemovePolicy_Execute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size) {
-  ControlState *state = ops->closure;
-
-  if (parcList_Size(args) != 3) {
-    _controlRemovePolicy_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  const char *prefixStr = parcList_GetAtIndex(args, 2);
-  char *addr = (char *)malloc(sizeof(char) * (strlen(prefixStr) + 1));
-
-  // separate address and len
-  char *slash;
-  uint32_t len = 0;
-  strcpy(addr, prefixStr);
-  slash = strrchr(addr, '/');
-  if (slash != NULL) {
-    len = atoi(slash + 1);
-    *slash = '\0';
-  }
-
-  // allocate command payload
-  remove_policy_command *removePolicyCommand =
-      parcMemory_AllocateAndClear(sizeof(remove_policy_command));
-
-  // check and set IP address
-  if (inet_pton(AF_INET, addr, &removePolicyCommand->address.v4.as_u32) == 1) {
-    if (len > 32) {
-      snprintf(output, output_size, "ERROR: exceeded INET mask length, max=32\n");
-      parcMemory_Deallocate(&removePolicyCommand);
-      free(addr);
-      return CommandReturn_Failure;
-    }
-    removePolicyCommand->addressType = ADDR_INET;
-  } else if (inet_pton(AF_INET6, addr, &removePolicyCommand->address.v6.as_in6addr) ==
-             1) {
-    if (len > 128) {
-      snprintf(output, output_size, "ERROR: exceeded INET6 mask length, max=128\n");
-      parcMemory_Deallocate(&removePolicyCommand);
-      free(addr);
-      return CommandReturn_Failure;
-    }
-    removePolicyCommand->addressType = ADDR_INET6;
-  } else {
-    snprintf(output, output_size, "Error: %s is not a valid network address \n", addr);
-    parcMemory_Deallocate(&removePolicyCommand);
-    free(addr);
-    return CommandReturn_Failure;
-  }
-
-  free(addr);
-  // Fill remaining payload fields
-  removePolicyCommand->len = len;
-
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(
-      state, REMOVE_POLICY, removePolicyCommand, sizeof(remove_policy_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
-
-#endif /* WITH_POLICY */
diff --git a/hicn-light/src/hicn/config/controlRemovePunting.c b/hicn-light/src/hicn/config/controlRemovePunting.c
deleted file mode 100644
index 84d096b81..000000000
--- a/hicn-light/src/hicn/config/controlRemovePunting.c
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <ctype.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-#include <hicn/utils/address.h>
-
-#include <hicn/config/controlRemovePunting.h>
-
-static CommandReturn _controlRemovePunting_Execute(CommandParser *parser,
-                                                   CommandOps *ops,
-                                                   PARCList *args,
-                                                   char *output,
-                                                   size_t output_size);
-static CommandReturn _controlRemovePunting_HelpExecute(CommandParser *parser,
-                                                       CommandOps *ops,
-                                                       PARCList *args,
-                                                       char *output,
-                                                       size_t output_size);
-
-// ===================================================
-
-static const char *_commandRemovePunting = "remove punting";
-static const char *_commandRemovePuntingHelp = "help punting connection";
-
-// ====================================================
-
-CommandOps *controlRemovePunting_Create(ControlState *state) {
-  return commandOps_Create(state, _commandRemovePunting, NULL,
-                           _controlRemovePunting_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlRemovePunting_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandRemovePuntingHelp, NULL,
-                           _controlRemovePunting_HelpExecute,
-                           commandOps_Destroy);
-}
-
-// ====================================================
-
-// ====================================================
-
-static CommandReturn _controlRemovePunting_HelpExecute(CommandParser *parser,
-                                                       CommandOps *ops,
-                                                       PARCList *args,
-                                                       char *output,
-                                                       size_t output_size) {
-  snprintf(output, output_size, "remove punting <symbolic> <prefix>\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlRemovePunting_Execute(CommandParser *parser,
-                                                   CommandOps *ops,
-                                                   PARCList *args,
-                                                   char *output,
-                                                   size_t output_size) {
-  snprintf(output, output_size, "command not implemented\n");
-  return _controlRemovePunting_HelpExecute(parser, ops, args, output, output_size);
-}
-
-// ==================================================
diff --git a/hicn-light/src/hicn/config/controlRemoveRoute.c b/hicn-light/src/hicn/config/controlRemoveRoute.c
deleted file mode 100644
index eb5642d98..000000000
--- a/hicn-light/src/hicn/config/controlRemoveRoute.c
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <ctype.h>
-#include <parc/algol/parc_List.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-#include <parc/assert/parc_Assert.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <hicn/utils/address.h>
-
-#include <hicn/config/controlRemoveRoute.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlRemoveRoute_Execute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size);
-static CommandReturn _controlRemoveRoute_HelpExecute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size);
-
-// ===================================================
-
-static const char *_commandRemoveRoute = "remove route";
-static const char *_commandRemoveRouteHelp = "help remove route";
-
-// ====================================================
-
-CommandOps *controlRemoveRoute_Create(ControlState *state) {
-  return commandOps_Create(state, _commandRemoveRoute, NULL,
-                           _controlRemoveRoute_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlRemoveRoute_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandRemoveRouteHelp, NULL,
-                           _controlRemoveRoute_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlRemoveRoute_HelpExecute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size) {
-  snprintf(output, output_size, "commands:\n"
-                                "    remove route <symbolic | connid> <prefix>\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlRemoveRoute_Execute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size) {
-  ControlState *state = ops->closure;
-
-  if (parcList_Size(args) != 4) {
-    _controlRemoveRoute_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  const char *symbolicOrConnid = parcList_GetAtIndex(args, 2);
-
-  if (!utils_ValidateSymbolicName(symbolicOrConnid) &&
-      !utils_IsNumber(symbolicOrConnid)) {
-    snprintf(output, output_size,
-        "ERROR: Invalid symbolic or connid:\nsymbolic name must begin with an "
-        "alpha followed by alphanum;\nconnid must be an integer\n");
-    return CommandReturn_Failure;
-  }
-
-  const char *prefixStr = parcList_GetAtIndex(args, 3);
-  char *addr = (char *)malloc(sizeof(char) * (strlen(prefixStr) + 1));
-
-  // separate address and len
-  char *slash;
-  uint32_t len = 0;
-  strcpy(addr, prefixStr);
-  slash = strrchr(addr, '/');
-  if (slash != NULL) {
-    len = atoi(slash + 1);
-    *slash = '\0';
-  }
-
-  // allocate command payload
-  remove_route_command *removeRouteCommand =
-      parcMemory_AllocateAndClear(sizeof(remove_route_command));
-
-  // check and set IP address
-  if (inet_pton(AF_INET, addr, &removeRouteCommand->address.v4.as_u32) == 1) {
-    if (len > 32) {
-      snprintf(output, output_size, "ERROR: exceeded INET mask length, max=32\n");
-      parcMemory_Deallocate(&removeRouteCommand);
-      free(addr);
-      return CommandReturn_Failure;
-    }
-    removeRouteCommand->addressType = ADDR_INET;
-  } else if (inet_pton(AF_INET6, addr, &removeRouteCommand->address.v6.as_in6addr) ==
-             1) {
-    if (len > 128) {
-      snprintf(output, output_size, "ERROR: exceeded INET6 mask length, max=128\n");
-      parcMemory_Deallocate(&removeRouteCommand);
-      free(addr);
-      return CommandReturn_Failure;
-    }
-    removeRouteCommand->addressType = ADDR_INET6;
-  } else {
-    snprintf(output, output_size, "Error: %s is not a valid network address \n", addr);
-    parcMemory_Deallocate(&removeRouteCommand);
-    free(addr);
-    return CommandReturn_Failure;
-  }
-
-  free(addr);
-  // Fill remaining payload fields
-  removeRouteCommand->len = len;
-  strcpy(removeRouteCommand->symbolicOrConnid, symbolicOrConnid);
-
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(
-      state, REMOVE_ROUTE, removeRouteCommand, sizeof(remove_route_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlRemoveRoute.h b/hicn-light/src/hicn/config/controlRemoveRoute.h
deleted file mode 100644
index 5e152b2fd..000000000
--- a/hicn-light/src/hicn/config/controlRemoveRoute.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * 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 control_RemoveRoute.h
- * @brief Remove a route from the FIB
- *
- * Implements the "remove route" and "help remove route" nodes of the command
- * tree
- *
- */
-
-#ifndef Control_RemoveRoute_h
-#define Control_RemoveRoute_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlRemoveRoute_Create(ControlState *state);
-CommandOps *controlRemoveRoute_HelpCreate(ControlState *state);
-#endif  // Control_RemoveRoute_h
diff --git a/hicn-light/src/hicn/config/controlRoot.c b/hicn-light/src/hicn/config/controlRoot.c
deleted file mode 100644
index 39a1fa6b5..000000000
--- a/hicn-light/src/hicn/config/controlRoot.c
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <hicn/config/controlAdd.h>
-#include <hicn/config/controlCache.h>
-#include <hicn/config/controlList.h>
-#include <hicn/config/controlMapMe.h>
-#include <hicn/config/controlQuit.h>
-#include <hicn/config/controlRemove.h>
-#include <hicn/config/controlRoot.h>
-#include <hicn/config/controlSet.h>
-#include <hicn/config/controlUnset.h>
-#ifdef WITH_POLICY
-#include <hicn/config/controlUpdate.h>
-#endif /* WITH_POLICY */
-
-static void _controlRoot_Init(CommandParser *parser, CommandOps *ops);
-static CommandReturn _controlRoot_Execute(CommandParser *parser,
-                                          CommandOps *ops,
-                                          PARCList *args,
-                                          char *output,
-                                          size_t output_size);
-static CommandReturn _controlRoot_HelpExecute(CommandParser *parser,
-                                              CommandOps *ops,
-                                              PARCList *args,
-                                              char *output,
-                                              size_t output_size);
-
-static const char *_commandRoot = "";
-static const char *_commandRootHelp = "help";
-
-// ====================================================
-
-CommandOps *controlRoot_Create(ControlState *state) {
-  return commandOps_Create(state, _commandRoot, _controlRoot_Init,
-                           _controlRoot_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlRoot_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandRootHelp, NULL,
-                           _controlRoot_HelpExecute, commandOps_Destroy);
-}
-
-// ===================================================
-
-static CommandReturn _controlRoot_HelpExecute(CommandParser *parser,
-                                              CommandOps *ops,
-                                              PARCList *args,
-                                              char *output,
-                                              size_t output_size) {
-  size_t output_offset = snprintf(output, output_size, "Command-line execution:\n"
-                                "   controller [--server <server-ip>] [--port <server-port>] "
-                                "command\n"
-                                "\n"
-                                "Interactive execution:\n"
-                                "   controller [--server <server-ip>] [--port <server-port>]\n"
-                                "\n"
-                                "If the keystore is not specified, the default path is used. Keystore "
-                                "must exist prior to running program.\n"
-                                "If the password is not specified, the user will be prompted.\n"
-                                "\n");
-
-  CommandOps *ops_help_add = controlAdd_CreateHelp(NULL);
-  CommandOps *ops_help_list = controlList_HelpCreate(NULL);
-  CommandOps *ops_help_quit = controlQuit_HelpCreate(NULL);
-  CommandOps *ops_help_remove = controlRemove_HelpCreate(NULL);
-  CommandOps *ops_help_set = controlSet_HelpCreate(NULL);
-  CommandOps *ops_help_unset = controlUnset_HelpCreate(NULL);
-  CommandOps *ops_help_cache = controlCache_HelpCreate(NULL);
-  CommandOps *ops_help_mapme = controlMapMe_HelpCreate(NULL);
-#ifdef WITH_POLICY
-  CommandOps *ops_help_update = controlUpdate_HelpCreate(NULL);
-#endif /* WITH_POLICY */
-
-  snprintf(output + output_offset, output_size - output_offset,"Available commands:\n"
-                                                               "   %s\n"
-                                                               "   %s\n"
-                                                               "   %s\n"
-                                                               "   %s\n"
-                                                               "   %s\n"
-                                                               "   %s\n"
-                                                               "   %s\n"
-                                                               "   %s\n"
-#ifdef WITH_POLICY
-                                                               "   %s\n"
-#endif /* WITH_POLICY */
-                                                               "\n",
-                                                               ops_help_add->command,
-                                                               ops_help_list->command,
-                                                               ops_help_quit->command,
-                                                               ops_help_remove->command,
-                                                               ops_help_set->command,
-                                                               ops_help_unset->command,
-                                                               ops_help_cache->command,
-                                                               ops_help_mapme->command
-#ifdef WITH_POLICY
-                                                               , ops_help_update->command
-#endif /* WITH_POLICY */
-  );
-
-  commandOps_Destroy(&ops_help_add);
-  commandOps_Destroy(&ops_help_list);
-  commandOps_Destroy(&ops_help_quit);
-  commandOps_Destroy(&ops_help_remove);
-  commandOps_Destroy(&ops_help_set);
-  commandOps_Destroy(&ops_help_unset);
-  commandOps_Destroy(&ops_help_cache);
-  commandOps_Destroy(&ops_help_mapme);
-#ifdef WITH_POLICY
-  commandOps_Destroy(&ops_help_update);
-#endif /* WITH_POLICY */
-
-  return CommandReturn_Success;
-}
-
-static void _controlRoot_Init(CommandParser *parser, CommandOps *ops) {
-  ControlState *state = ops->closure;
-
-  controlState_RegisterCommand(state, controlAdd_CreateHelp(state));
-  controlState_RegisterCommand(state, controlList_HelpCreate(state));
-  controlState_RegisterCommand(state, controlQuit_HelpCreate(state));
-  controlState_RegisterCommand(state, controlRemove_HelpCreate(state));
-  controlState_RegisterCommand(state, controlSet_HelpCreate(state));
-  controlState_RegisterCommand(state, controlUnset_HelpCreate(state));
-  controlState_RegisterCommand(state, controlCache_HelpCreate(state));
-  controlState_RegisterCommand(state, controlMapMe_HelpCreate(state));
-#ifdef WITH_POLICY
-  controlState_RegisterCommand(state, controlUpdate_HelpCreate(state));
-#endif /* WITH_POLICY */
-
-  controlState_RegisterCommand(state, webControlAdd_Create(state));
-  controlState_RegisterCommand(state, controlList_Create(state));
-  controlState_RegisterCommand(state, controlQuit_Create(state));
-  controlState_RegisterCommand(state, controlRemove_Create(state));
-  controlState_RegisterCommand(state, controlSet_Create(state));
-  controlState_RegisterCommand(state, controlUnset_Create(state));
-  controlState_RegisterCommand(state, controlCache_Create(state));
-  controlState_RegisterCommand(state, controlMapMe_Create(state));
-#ifdef WITH_POLICY
-  controlState_RegisterCommand(state, controlUpdate_Create(state));
-#endif /* WITH_POLICY */
-}
-
-static CommandReturn _controlRoot_Execute(CommandParser *parser,
-                                          CommandOps *ops,
-                                          PARCList *args,
-                                          char *output,
-                                          size_t output_size) {
-  return CommandReturn_Success;
-}
-
-// ======================================================================
diff --git a/hicn-light/src/hicn/config/controlRoot.h b/hicn-light/src/hicn/config/controlRoot.h
deleted file mode 100644
index 154b81a80..000000000
--- a/hicn-light/src/hicn/config/controlRoot.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * 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 control_Root.h
- * @brief Root of the command tree
- *
- * Implements the root of the command tree.  This is the one module that
- * needs to be seeded to the control state to build the whole tree.
- *
- */
-
-#ifndef Control_Root_h
-#define Control_Root_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlRoot_Create(ControlState *state);
-CommandOps *controlRoot_HelpCreate(ControlState *state);
-#endif  // Control_Root_h
diff --git a/hicn-light/src/hicn/config/controlSet.c b/hicn-light/src/hicn/config/controlSet.c
deleted file mode 100644
index 37d56e593..000000000
--- a/hicn-light/src/hicn/config/controlSet.c
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/security/parc_Security.h>
-
-#include <hicn/config/controlSet.h>
-#include <hicn/config/controlSetDebug.h>
-#include <hicn/config/controlSetStrategy.h>
-#include <hicn/config/controlSetWldr.h>
-
-static void _controlSet_Init(CommandParser *parser, CommandOps *ops);
-static CommandReturn _controlSet_Execute(CommandParser *parser,
-                                         CommandOps *ops,
-                                         PARCList *args,
-                                         char *output,
-                                         size_t output_size);
-static CommandReturn _controlSet_HelpExecute(CommandParser *parser,
-                                             CommandOps *ops,
-                                             PARCList *args,
-                                             char *output,
-                                             size_t output_size);
-
-static const char *_commandSet = "set";
-static const char *_commandSetHelp = "help set";
-
-// ===========================================================
-
-CommandOps *controlSet_Create(ControlState *state) {
-  return commandOps_Create(state, _commandSet, _controlSet_Init,
-                           _controlSet_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlSet_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandSetHelp, NULL,
-                           _controlSet_HelpExecute, commandOps_Destroy);
-}
-
-// ===========================================================
-
-static void _controlSet_Init(CommandParser *parser, CommandOps *ops) {
-  ControlState *state = ops->closure;
-  controlState_RegisterCommand(state, controlSetDebug_Create(state));
-  controlState_RegisterCommand(state, controlSetDebug_HelpCreate(state));
-  controlState_RegisterCommand(state, controlSetStrategy_Create(state));
-  controlState_RegisterCommand(state, controlSetStrategy_HelpCreate(state));
-  controlState_RegisterCommand(state, controlSetWldr_Create(state));
-  controlState_RegisterCommand(state, controlSetWldr_HelpCreate(state));
-}
-
-static CommandReturn _controlSet_HelpExecute(CommandParser *parser,
-                                             CommandOps *ops,
-                                             PARCList *args,
-                                             char *output,
-                                             size_t output_size) {
-  CommandOps *ops_help_set_debug = controlSetDebug_HelpCreate(NULL);
-  CommandOps *ops_help_set_strategy = controlSetStrategy_HelpCreate(NULL);
-  CommandOps *ops_help_set_wldr = controlSetWldr_HelpCreate(NULL);
-
-  snprintf(output, output_size, "Available commands:\n   %s\n   %s\n   %s\n\n",
-                                ops_help_set_debug->command,
-                                ops_help_set_strategy->command,
-                                ops_help_set_wldr->command);
-
-  commandOps_Destroy(&ops_help_set_debug);
-  commandOps_Destroy(&ops_help_set_strategy);
-  commandOps_Destroy(&ops_help_set_wldr);
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlSet_Execute(CommandParser *parser,
-                                         CommandOps *ops,
-                                         PARCList *args,
-                                         char *output,
-                                         size_t output_size) {
-  return _controlSet_HelpExecute(parser, ops, args, output, output_size);
-}
diff --git a/hicn-light/src/hicn/config/controlSet.h b/hicn-light/src/hicn/config/controlSet.h
deleted file mode 100644
index abe2a611d..000000000
--- a/hicn-light/src/hicn/config/controlSet.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * 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 control_Set.h
- * @brief Implements the set node of the CLI tree
- *
- * Implements the "set" and "help set" nodes of the command tree
- *
- */
-#ifndef Control_Set_h
-#define Control_Set_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlSet_Create(ControlState *state);
-CommandOps *controlSet_HelpCreate(ControlState *state);
-#endif  // Control_Set_h
diff --git a/hicn-light/src/hicn/config/controlSetDebug.c b/hicn-light/src/hicn/config/controlSetDebug.c
deleted file mode 100644
index a5dcc89c1..000000000
--- a/hicn-light/src/hicn/config/controlSetDebug.c
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/config/controlSetDebug.h>
-#include <hicn/core/dispatcher.h>
-#include <hicn/core/forwarder.h>
-
-static CommandReturn _controlSetDebug_Execute(CommandParser *parser,
-                                              CommandOps *ops, PARCList *args,
-                                              char *output,
-                                              size_t output_size);
-static CommandReturn _controlSetDebug_HelpExecute(CommandParser *parser,
-                                                  CommandOps *ops,
-                                                  PARCList *args,
-                                                  char *output,
-                                                  size_t output_size);
-
-static const char *_commandSetDebug = "set debug";
-static const char *_commandSetDebugHelp = "help set debug";
-
-// ====================================================
-
-CommandOps *controlSetDebug_Create(ControlState *state) {
-  return commandOps_Create(state, _commandSetDebug, NULL,
-                           _controlSetDebug_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlSetDebug_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandSetDebugHelp, NULL,
-                           _controlSetDebug_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlSetDebug_HelpExecute(CommandParser *parser,
-                                                  CommandOps *ops,
-                                                  PARCList *args,
-                                                  char *output,
-                                                  size_t output_size) {
-  snprintf(output, output_size, "set debug: will enable the debug flag for more verbose output\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlSetDebug_Execute(CommandParser *parser,
-                                              CommandOps *ops,
-                                              PARCList *args,
-                                              char *output,
-                                              size_t output_size) {
-  if (parcList_Size(args) != 2) {
-    _controlSetDebug_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  ControlState *state = ops->closure;
-  controlState_SetDebug(state, true);
-  snprintf(output, output_size, "Debug flag set\n\n");
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlSetDebug.h b/hicn-light/src/hicn/config/controlSetDebug.h
deleted file mode 100644
index fabeb6952..000000000
--- a/hicn-light/src/hicn/config/controlSetDebug.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 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 control_SetDebug.h
- * @brief Sets the debug flag for more verbose output
- *
- * Implements the "set debug" and "help set debug" nodes of the command tree
- *
- */
-
-#ifndef Control_SetDebug_h
-#define Control_SetDebug_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlSetDebug_Create(ControlState *state);
-CommandOps *controlSetDebug_HelpCreate(ControlState *state);
-#endif  // Control_SetDebug_h
diff --git a/hicn-light/src/hicn/config/controlSetStrategy.c b/hicn-light/src/hicn/config/controlSetStrategy.c
deleted file mode 100644
index fe0ba84a0..000000000
--- a/hicn-light/src/hicn/config/controlSetStrategy.c
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-
-#include <hicn/config/controlSetDebug.h>
-#include <hicn/core/dispatcher.h>
-#include <hicn/core/forwarder.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlSetStrategy_Execute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size);
-static CommandReturn _controlSetStrategy_HelpExecute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size);
-
-static const char *_commandSetStrategy = "set strategy";
-static const char *_commandSetStrategyHelp = "help set strategy";
-
-static const char *_commandSetStrategyOptions[LAST_STRATEGY_VALUE] = {
-    "loadbalancer",
-    "random",
-    "low_latency",
-};
-
-// ====================================================
-
-CommandOps *controlSetStrategy_Create(ControlState *state) {
-  return commandOps_Create(state, _commandSetStrategy, NULL,
-                           _controlSetStrategy_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlSetStrategy_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandSetStrategyHelp, NULL,
-                           _controlSetStrategy_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-strategy_type _validStrategy(const char *strategy) {
-  strategy_type validStrategy = LAST_STRATEGY_VALUE;
-
-  for (int i = 0; i < LAST_STRATEGY_VALUE; i++) {
-    if (strcmp(_commandSetStrategyOptions[i], strategy) == 0) {
-      validStrategy = i;
-      break;
-    }
-  }
-  return validStrategy;
-}
-
-static void _getAddressAndLen(const char * prefixStr, char *addr, uint32_t *len){
-  char *slash;
-  strcpy(addr, prefixStr);
-  slash = strrchr(addr, '/');
-  if (slash != NULL) {
-    *len = atoi(slash + 1);
-    *slash = '\0';
-  }
-}
-
-static bool _checkAndSetIp(set_strategy_command * setStrategyCommand,
-                           int index,
-                           char * addr,
-                           uint32_t len,
-                           char *output,
-                          size_t output_size){
-  // check and set IP address
-  int res;
-  if(index == -1)
-    res = inet_pton(AF_INET, addr, &setStrategyCommand->address.v4.as_u32);
-  else
-    res = inet_pton(AF_INET, addr,
-              &setStrategyCommand->addresses[index].v4.as_u32);
-
-  if(res == 1) {
-    if (len == UINT32_MAX) {
-      snprintf(output, output_size, "Netmask not specified: set to 32 by default\n");
-      len = 32;
-    } else if (len > 32) {
-      snprintf(output, output_size, "ERROR: exceeded INET mask length, max=32\n");
-      return false;
-    }
-    if(index == -1)
-      setStrategyCommand->addressType = ADDR_INET;
-    else
-      setStrategyCommand->addresses_type[index] = ADDR_INET;
-
-  } else {
-
-    if(index == -1)
-      res = inet_pton(AF_INET6, addr,
-            &setStrategyCommand->address.v6.as_in6addr);
-    else
-      res = inet_pton(AF_INET6, addr,
-            &setStrategyCommand->addresses[index].v6.as_in6addr);
-
-    if(res == 1) {
-      if (len == UINT32_MAX) {
-        snprintf(output, output_size, "Netmask not specified: set to 128 by default\n");
-        len = 128;
-      } else if (len > 128) {
-        snprintf(output, output_size, "ERROR: exceeded INET6 mask length, max=128\n");
-        return false;
-      }
-
-      if(index == -1)
-        setStrategyCommand->addressType = ADDR_INET6;
-      else
-        setStrategyCommand->addresses_type[index] = ADDR_INET6;
-
-    } else {
-      snprintf(output, output_size, "Error: %s is not a valid network address \n", addr);
-
-      return false;
-    }
-  }
-  return true;
-}
-
-static CommandReturn _controlSetStrategy_HelpExecute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size) {
-  snprintf(output, output_size,
-                     "set strategy <prefix> <strategy> "
-                     "[related_prefix1 related_preifx2  ...]\n"
-                     "prefix: ipv4/ipv6 address (ex: 1234::/64)\n"
-                     "strategy: strategy identifier\n"
-                     "optinal: list of related prefixes (max %u)\n"
-                     "available strategies:\n"
-                     "    random\n"
-                     "    loadbalancer\n"
-                     "    low_latency\n\n",
-                     MAX_FWD_STRATEGY_RELATED_PREFIXES);
-  return CommandReturn_Success;
-}
-
-
-static CommandReturn _controlSetStrategy_Execute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size) {
-  if (output) {
-    output[0] = '\0';
-  }
-  ControlState *state = ops->closure;
-
-  if (parcList_Size(args) < 4 ||
-          parcList_Size(args) > (4 + MAX_FWD_STRATEGY_RELATED_PREFIXES)) {
-    _controlSetStrategy_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  if (((strcmp(parcList_GetAtIndex(args, 0), "set") != 0) ||
-       (strcmp(parcList_GetAtIndex(args, 1), "strategy") != 0))) {
-    _controlSetStrategy_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  const char *prefixStr = parcList_GetAtIndex(args, 2);
-  char *addr = (char *)malloc(sizeof(char) * (strlen(prefixStr) + 1));
-  uint32_t len = UINT32_MAX;
-  _getAddressAndLen(prefixStr, addr, &len);
-
-  // allocate command payload
-  set_strategy_command *setStrategyCommand =
-      parcMemory_AllocateAndClear(sizeof(set_strategy_command));
-
-  bool success = _checkAndSetIp(setStrategyCommand, -1, addr, len, output, output_size);
-  if(!success){
-    parcMemory_Deallocate(&setStrategyCommand);
-    free(addr);
-    return CommandReturn_Failure;
-  }
-
-  const char *strategyStr = parcList_GetAtIndex(args, 3);
-  // check valid strategy
-  strategy_type strategy;
-  if ((strategy = _validStrategy(strategyStr)) == LAST_STRATEGY_VALUE) {
-    size_t output_offset = strlen(output);
-    output_offset += snprintf(output + output_offset, output_size - output_offset, "Error: invalid strategy \n");
-    
-    parcMemory_Deallocate(&setStrategyCommand);
-    _controlSetStrategy_HelpExecute(parser, ops, args, output + output_offset, output_size - output_offset);
-    free(addr);
-    return CommandReturn_Failure;
-  }
-
-  free(addr);
-
-  // Fill remaining payload fields
-  setStrategyCommand->len = len;
-  setStrategyCommand->strategyType = strategy;
-  size_t output_offset = strlen(output);
-  //check additional prefixes
-  if(parcList_Size(args) > 4){
-    uint32_t index = 4; //first realted prefix
-    uint32_t addr_index = 0;
-    setStrategyCommand->related_prefixes = (uint8_t)parcList_Size(args) - 4;
-    while(index < parcList_Size(args)){
-      const char *str = parcList_GetAtIndex(args, index);
-      char *rel_addr = (char *)malloc(sizeof(char) * (strlen(str) + 1));
-      uint32_t rel_len = UINT32_MAX;
-      _getAddressAndLen(str, rel_addr, &rel_len);
-      bool success = _checkAndSetIp(setStrategyCommand, addr_index,
-                                          rel_addr, rel_len, output + output_offset, output_size - output_offset);
-      if(!success){
-        parcMemory_Deallocate(&setStrategyCommand);
-        free(rel_addr);
-        return CommandReturn_Failure;
-      }
-      output_offset = strlen(output);
-      setStrategyCommand->lens[addr_index] = rel_len;
-      free(rel_addr);
-      index++;
-      addr_index++;
-    }
-  }else{
-    setStrategyCommand->related_prefixes = 0;
-  }
-
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(
-      state, SET_STRATEGY, setStrategyCommand, sizeof(set_strategy_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlSetStrategy.h b/hicn-light/src/hicn/config/controlSetStrategy.h
deleted file mode 100644
index 7ad56ccba..000000000
--- a/hicn-light/src/hicn/config/controlSetStrategy.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 Control_SetStrategy_h
-#define Control_SetStrategy_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlSetStrategy_Create(ControlState *state);
-CommandOps *controlSetStrategy_HelpCreate(ControlState *state);
-#endif  // Control_SetStrategy_h
diff --git a/hicn-light/src/hicn/config/controlSetWldr.c b/hicn-light/src/hicn/config/controlSetWldr.c
deleted file mode 100644
index 0d4a7eca2..000000000
--- a/hicn-light/src/hicn/config/controlSetWldr.c
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/config/controlSetDebug.h>
-#include <hicn/core/dispatcher.h>
-#include <hicn/core/forwarder.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlSetWldr_Execute(CommandParser *parser,
-                                             CommandOps *ops,
-                                             PARCList *args,
-                                             char *output,
-                                             size_t output_size);
-static CommandReturn _controlSetWldr_HelpExecute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size);
-
-static const char *_commandSetWldr = "set wldr";
-static const char *_commandSetWldrHelp = "help set wldr";
-
-// ====================================================
-
-CommandOps *controlSetWldr_Create(ControlState *state) {
-  return commandOps_Create(state, _commandSetWldr, NULL,
-                           _controlSetWldr_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlSetWldr_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandSetWldrHelp, NULL,
-                           _controlSetWldr_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlSetWldr_HelpExecute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size) {
-  snprintf(output, output_size, "set wldr <on|off> <connection_id>\n\n");
-
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlSetWldr_Execute(CommandParser *parser,
-                                             CommandOps *ops,
-                                             PARCList *args,
-                                             char *output,
-                                             size_t output_size) {
-  ControlState *state = ops->closure;
-
-  if (parcList_Size(args) != 4) {
-    _controlSetWldr_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  if (((strcmp(parcList_GetAtIndex(args, 0), "set") != 0) ||
-       (strcmp(parcList_GetAtIndex(args, 1), "wldr") != 0))) {
-    _controlSetWldr_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  bool active;
-  if (strcmp(parcList_GetAtIndex(args, 2), "on") == 0) {
-    active = true;
-  } else if (strcmp(parcList_GetAtIndex(args, 2), "off") == 0) {
-    active = false;
-  } else {
-    _controlSetWldr_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  // check if valid connid
-  const char *symbolicOrConnid = parcList_GetAtIndex(args, 3);
-
-  if (!utils_ValidateSymbolicName(symbolicOrConnid) &&
-      !utils_IsNumber(symbolicOrConnid)) {
-    snprintf(output, output_size,
-        "ERROR: Invalid symbolic or connid:\nsymbolic name must begin with an "
-        "alpha followed by alphanum;\nconnid must be an integer\n");
-    return CommandReturn_Failure;
-  }
-
-  // allocate command payload
-  set_wldr_command *setWldrCommand =
-      parcMemory_AllocateAndClear(sizeof(set_wldr_command));
-  strcpy(setWldrCommand->symbolicOrConnid, symbolicOrConnid);
-  if (active) {
-    setWldrCommand->activate = ACTIVATE_ON;
-  } else {
-    setWldrCommand->activate = ACTIVATE_OFF;
-  }
-
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(state, SET_WLDR, setWldrCommand,
-                                             sizeof(set_wldr_command));
-
-  if (!response) {  // get NULL pointer
-    return CommandReturn_Failure;
-  }
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlSetWldr.h b/hicn-light/src/hicn/config/controlSetWldr.h
deleted file mode 100644
index 3c01110e4..000000000
--- a/hicn-light/src/hicn/config/controlSetWldr.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 Control_SetWldr_h
-#define Control_SetWldr_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlSetWldr_Create(ControlState *state);
-CommandOps *controlSetWldr_HelpCreate(ControlState *state);
-#endif  // Control_SetWldr_h
diff --git a/hicn-light/src/hicn/config/controlState.c b/hicn-light/src/hicn/config/controlState.c
deleted file mode 100644
index acdae9e52..000000000
--- a/hicn-light/src/hicn/config/controlState.c
+++ /dev/null
@@ -1,243 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-#include <string.h>
-
-#include <parc/security/parc_Security.h>
-
-#include <parc/algol/parc_List.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-#include <parc/algol/parc_Time.h>
-#include <parc/algol/parc_TreeRedBlack.h>
-
-#include <hicn/config/commandParser.h>
-#include <hicn/config/controlRoot.h>
-#include <hicn/config/controlState.h>
-
-#include <hicn/utils/commands.h>
-
-struct controller_state {
-  CommandParser *parser;
-  bool debugFlag;
-
-  void *userdata;
-  struct iovec *(*writeRead)(ControlState *state, struct iovec *msg);
-  int sockfd;
-  char **commandOutput;
-  bool isInteractive;
-};
-
-int controlState_connectToFwdDeamon(char *server_ip, uint16_t port) {
-  int sockfd;
-  struct sockaddr_in servaddr;
-
-  if ((sockfd = (int)socket(AF_INET, SOCK_STREAM, 0)) < 0) {
-    printf("\nSocket Creation Failed \n");
-      return EXIT_FAILURE;
-  }
-
-  memset(&servaddr, 0, sizeof(servaddr));
-
-  // Filling server information
-  servaddr.sin_family = AF_INET;
-  servaddr.sin_port = htons(port);
-  inet_pton(AF_INET, server_ip, &(servaddr.sin_addr.s_addr));
-
-  // Establish connection
-  if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
-    printf("\nConnection Failed: hicn-light Daemon is not running \n");
-    return -1;
-  }
-
-  return sockfd;
-}
-
-ControlState *controlState_Create(
-    void *userdata,
-    struct iovec *(*writeRead)(ControlState *state, struct iovec *msg),
-      bool openControllerConnetion,
-      char *server_ip, uint16_t port) {
-  ControlState *state = parcMemory_AllocateAndClear(sizeof(ControlState));
-  parcAssertNotNull(state, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(ControlState));
-  state->parser = commandParser_Create();
-
-  state->userdata = userdata;
-  state->writeRead = writeRead;
-  state->debugFlag = false;
-  state->commandOutput = NULL;
-  state->isInteractive = true;
-
-  if (openControllerConnetion) {
-    state->sockfd = controlState_connectToFwdDeamon(server_ip, port);
-    if (state->sockfd == -1) {
-        return NULL;
-    }
-  } else {
-    state->sockfd = 2;  // stderr
-  }
-
-  return state;
-}
-
-void controlState_Destroy(ControlState **statePtr) {
-  parcAssertNotNull(statePtr, "Parameter statePtr must be non-null");
-  parcAssertNotNull(*statePtr,
-                    "Parameter statePtr must dereference t non-null");
-  ControlState *state = *statePtr;
-  // printf("sockid destroyed: %d\n", state->sockfd);
-  // close the connection with the fwd deamon
-  shutdown(state->sockfd, 2);
-
-  commandParser_Destroy(&state->parser);
-  parcMemory_Deallocate((void **)&state);
-  *statePtr = NULL;
-}
-
-void controlState_SetDebug(ControlState *state, bool debugFlag) {
-  parcAssertNotNull(state, "Parameter state must be non-null");
-  state->debugFlag = debugFlag;
-  commandParser_SetDebug(state->parser, debugFlag);
-}
-
-bool controlState_GetDebug(ControlState *state) {
-  parcAssertNotNull(state, "Parameter state must be non-null");
-  return state->debugFlag;
-}
-
-void controlState_RegisterCommand(ControlState *state, CommandOps *ops) {
-  parcAssertNotNull(state, "Parameter state must be non-null");
-  commandParser_RegisterCommand(state->parser, ops);
-}
-
-struct iovec *controlState_WriteRead(ControlState *state, struct iovec *msg) {
-  parcAssertNotNull(state, "Parameter state must be non-null");
-  parcAssertNotNull(msg, "Parameter msg must be non-null");
-
-  return state->writeRead(state, msg);
-}
-
-static PARCList *_controlState_ParseStringIntoTokens(
-    const char *originalString) {
-  PARCList *list =
-      parcList(parcArrayList_Create(parcArrayList_StdlibFreeFunction),
-               PARCArrayListAsPARCList);
-
-  char *token;
-
-  char *tofree =
-      parcMemory_StringDuplicate(originalString, strlen(originalString) + 1);
-  char *string = tofree;
-
-  token = strtok(string, " \t\n");
-  while (token != NULL) {
-    if (strlen(token) > 0) {
-      parcList_Add(list, strdup(token));
-    }
-    token = strtok(NULL, " \t\n");
-  }
-
-  parcMemory_Deallocate((void **)&tofree);
-
-  return list;
-}
-
-CommandReturn controlState_DispatchCommand(ControlState *state,
-                                           PARCList *args,
-                                           char *output,
-                                           size_t output_size) {
-  parcAssertNotNull(state, "Parameter state must be non-null");
-  return commandParser_DispatchCommand(state->parser, args, output, output_size);
-}
-
-int controlState_Interactive(ControlState *state) {
-  parcAssertNotNull(state, "Parameter state must be non-null");
-  char *line = NULL;
-  size_t linecap = 0;
-  CommandReturn controlReturn = CommandReturn_Success;
-  char output[8192];
-  while (controlReturn != CommandReturn_Exit && !feof(stdin)) {
-    fputs("> ", stdout);
-    fflush(stdout);
-    ssize_t failure = getline(&line, &linecap, stdin);
-    parcAssertTrue(failure > -1, "Error getline");
-
-    PARCList *args = _controlState_ParseStringIntoTokens(line);
-    
-    controlReturn = controlState_DispatchCommand(state, args, output, sizeof(output));
-    printf("%s", output);
-    // release and get command
-    parcList_Release(&args);
-  }
-  return 0;
-}
-
-void controlState_SetCommandOutput(ControlState *state, char **commandData) {
-  state->commandOutput = commandData;
-}
-
-void controlState_ReleaseCommandOutput(ControlState *state, char **commandData,
-                                       size_t commandLenght) {
-  for (size_t i = 0; i < commandLenght; i++) {
-    parcMemory_Deallocate(&commandData[i]);
-  }
-  parcMemory_Deallocate(&commandData);
-  state->commandOutput = NULL;
-}
-
-char **controlState_GetCommandOutput(ControlState *state) {
-  return state->commandOutput;
-}
-
-// size_t
-// controlState_GetCommandLen(ControlState *state){
-
-// }
-
-void controlState_SetInteractiveFlag(ControlState *state, bool interactive) {
-  state->isInteractive = interactive;
-}
-
-bool controlState_IsInteractive(ControlState *state) {
-  return state->isInteractive;
-}
-
-int controlState_GetSockfd(ControlState *state) {
-  parcAssertNotNull(state, "Parameter state must be non-null");
-  return state->sockfd;
-}
-
-void *controlState_GetUserdata(ControlState *state) {
-  parcAssertNotNull(state, "Parameter state must be non-null");
-  return state->userdata;
-}
-
-bool controlState_isConfigFile(ControlState *state) {
-  parcAssertNotNull(state, "Parameter state must be non-null");
-  if (state->sockfd != 2) {
-    return false;
-  } else {
-    return true;
-  }
-}
diff --git a/hicn-light/src/hicn/config/controlState.h b/hicn-light/src/hicn/config/controlState.h
deleted file mode 100644
index 52b1f6655..000000000
--- a/hicn-light/src/hicn/config/controlState.h
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- * 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 controlState.h
- * @brief A control program for hicn-light using CLI commands
- *
- * Implements the state machine for the control program.  It takes a "writeRead"
- * function as part of the constructor.  This abstracts out the backend.  It
- * could be a Portal from hicnLightControl program down to the forwarder or it
- * could be an internal function within hicn-light.
- *
- */
-
-#ifndef control_h
-#define control_h
-
-#include <parc/algol/parc_List.h>
-#include <hicn/config/commandParser.h>
-
-#include <hicn/utils/commands.h>
-
-#define SRV_CTRL_IP "127.0.0.1"
-#define SRV_CTRL_PORT 9695
-
-struct controller_state;
-typedef struct controller_state ControlState;
-
-/**
- * controlState_Create
- *
- * Creates the global state for the Control program.  The user provides the
- * writeRead function for sending and receiving the message wrapping command
- * arguments.  For configuration file inside hicn-light, it would make direct
- * calls to Configuration -> Dispatcher.
- *
- * @param [in] userdata A closure passed back to the user when calling
- * writeRead.
- * @param [in] writeRead The function to write then read configuration messages
- * to hicn-light
- *
- * @return non-null The control state
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-
-ControlState *controlState_Create(
-    void *userdata,
-    struct iovec *(*writeRead)(ControlState *state, struct iovec *msg),
-    bool openControllerConnetion,
-    char * server_ip, uint16_t port);
-
-/**
- * Destroys the control state, closing all network connections
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in out in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void controlState_Destroy(ControlState **statePtr);
-
-/**
- * Registers a CommandOps with the system.
- *
- * Each command has its complete command prefix in the "command" field.
- * RegisterCommand will put these command prefixes in to a tree and then match
- * what a user types against the longest-matching prefix in the tree.  If
- * there's a match, it will call the "execute" function.
- *
- * @param [in] state An allocated ControlState
- * @param [in] command The command to register with the system
- *
- * Example:
- * @code
- *      static CommandReturn
- *      control_Root_Execute(CommandParser *parser, CommandOps *ops, PARCList
- * *args)
- *      {
- *          printf("Root Command\n");
- *          return CommandReturn_Success;
- *      }
- *
- *      static CommandReturn
- *      control_FooBar_Execute(CommandParser *parser, CommandOps *ops, PARCList
- * *args)
- *      {
- *          printf("Foo Bar Command\n");
- *          return CommandReturn_Success;
- *      }
- *
- *      const CommandOps control_Root = {
- *      .command = "", // empty string for root
- *      .init    = NULL,
- *      .execute = control_Root_Execute
- *      };
- *
- *      const CommandOps control_FooBar = {
- *      .command = "foo bar", // empty string for root
- *      .init    = NULL,
- *      .execute = control_FooBar_Execute
- *      };
- *
- *   void startup(void)
- *   {
- *      ControlState *state = controlState_Create("happy", "day");
- *      controlState_RegisterCommand(state, control_FooBar);
- *      controlState_RegisterCommand(state, control_Root);
- *
- *      // this executes "root"
- *      controlState_DispatchCommand(state, "foo");
- *      controlState_Destroy(&state);
- *  }
- * @endcode
- */
-void controlState_RegisterCommand(ControlState *state, CommandOps *command);
-
-/**
- * Performs a longest-matching prefix of the args to the command tree
- *
- * The command tree is created with controlState_RegisterCommand.
- *
- * @param [in] state The allocated ControlState
- * @param [in] args  Each command_line word parsed to the ordered list
- * @param [in] output Output string
- * @param [in] output_length output string max length
- *
- * @return CommandReturn_Success the command was successful
- * @return CommandReturn_Failure the command failed or was not found
- * @return CommandReturn_Exit the command indicates that the interactive mode
- * should exit
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-CommandReturn controlState_DispatchCommand(ControlState *state,
-                                           PARCList *args,
-                                           char *output,
-                                           size_t output_length);
-
-/**
- * Begin an interactive shell
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in out in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-int controlState_Interactive(ControlState *state);
-
-/**
- * Write then Read a command
- *
- * @param [<#in out in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-struct iovec *controlState_WriteRead(ControlState *state, struct iovec *msg);
-
-/**
- * Sets the Debug mode, which will print out much more information.
- *
- * Prints out much more diagnostic information about what hicn-light controller
- * is doing. yes, you would make a CommandOps to set and unset this :)
- *
- * @param [in] debugFlag true means to print debug info, false means to turn it
- * off
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void controlState_SetDebug(ControlState *state, bool debugFlag);
-
-/**
- * Returns the debug state of ControlState
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in out in,out#>] <#name#> <#description#>
- *
- * @return <#value#> <#explanation#>
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-bool controlState_GetDebug(ControlState *state);
-#endif  // control_h
-
-void controlState_SetCommandOutput(ControlState *state, char **commandData);
-
-void controlState_ReleaseCommandOutput(ControlState *state, char **commandData,
-                                       size_t commandLenght);
-
-char **controlState_GetCommandOutput(ControlState *state);
-
-void controlState_SetInteractiveFlag(ControlState *state, bool interactive);
-
-bool controlState_IsInteractive(ControlState *state);
-
-void *controlState_GetUserdata(ControlState *state);
-
-bool controlState_isConfigFile(ControlState *state);
-
-int controlState_GetSockfd(ControlState *state);
diff --git a/hicn-light/src/hicn/config/controlUnset.c b/hicn-light/src/hicn/config/controlUnset.c
deleted file mode 100644
index e05ba2286..000000000
--- a/hicn-light/src/hicn/config/controlUnset.c
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/security/parc_Security.h>
-
-#include <hicn/config/controlUnset.h>
-#include <hicn/config/controlUnsetDebug.h>
-
-static void _controlUnset_Init(CommandParser *parser, CommandOps *ops);
-
-static CommandReturn _controlUnset_Execute(CommandParser *parser,
-                                           CommandOps *ops,
-                                           PARCList *args,
-                                           char *output,
-                                           size_t output_size);
-static CommandReturn _controlUnset_HelpExecute(CommandParser *parser,
-                                               CommandOps *ops,
-                                               PARCList *args,
-                                               char *output,
-                                               size_t output_size);
-
-static const char *_commandUnset = "unset";
-static const char *_commandUnsetHelp = "help unset";
-
-// ===========================================================
-
-CommandOps *controlUnset_Create(ControlState *state) {
-  return commandOps_Create(state, _commandUnset, _controlUnset_Init,
-                           _controlUnset_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlUnset_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandUnsetHelp, NULL,
-                           _controlUnset_HelpExecute, commandOps_Destroy);
-}
-
-// ===========================================================
-
-static void _controlUnset_Init(CommandParser *parser, CommandOps *ops) {
-  ControlState *state = ops->closure;
-  controlState_RegisterCommand(state, controlUnsetDebug_Create(state));
-  controlState_RegisterCommand(state, controlUnsetDebug_HelpCreate(state));
-}
-
-static CommandReturn _controlUnset_HelpExecute(CommandParser *parser,
-                                               CommandOps *ops,
-                                               PARCList *args,
-                                               char *output,
-                                               size_t output_size) {
-  CommandOps *ops_help_unset_debug = controlUnsetDebug_HelpCreate(NULL);
-  snprintf(output, output_size, "Available commands:\n   %s\n\n", ops_help_unset_debug->command);
-
-  commandOps_Destroy(&ops_help_unset_debug);
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlUnset_Execute(CommandParser *parser,
-                                           CommandOps *ops,
-                                           PARCList *args,
-                                           char *output,
-                                           size_t output_size) {
-  return _controlUnset_HelpExecute(parser, ops, args, output, output_size);
-}
diff --git a/hicn-light/src/hicn/config/controlUnset.h b/hicn-light/src/hicn/config/controlUnset.h
deleted file mode 100644
index 9d9cb5c44..000000000
--- a/hicn-light/src/hicn/config/controlUnset.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * 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 control_Unset.h
- * @brief Implements the unset node of the CLI tree
- *
- * Implements the "unset" and "help unset" nodes of the command tree
- *
- */
-#ifndef Control_Unset_h
-#define Control_Unset_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlUnset_Create(ControlState *state);
-CommandOps *controlUnset_HelpCreate(ControlState *state);
-#endif  // Control_Unset_h
diff --git a/hicn-light/src/hicn/config/controlUnsetDebug.c b/hicn-light/src/hicn/config/controlUnsetDebug.c
deleted file mode 100644
index ac2a4e028..000000000
--- a/hicn-light/src/hicn/config/controlUnsetDebug.c
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/config/controlUnsetDebug.h>
-#include <hicn/core/dispatcher.h>
-#include <hicn/core/forwarder.h>
-
-static CommandReturn _controlUnsetDebug_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size);
-static CommandReturn _controlUnsetDebug_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size);
-
-static const char *_commandUnsetDebug = "unset debug";
-static const char *_commandUnsetDebugHelp = "help unset debug";
-
-// ====================================================
-
-CommandOps *controlUnsetDebug_Create(ControlState *state) {
-  return commandOps_Create(state, _commandUnsetDebug, NULL,
-                           _controlUnsetDebug_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlUnsetDebug_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandUnsetDebugHelp, NULL,
-                           _controlUnsetDebug_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static CommandReturn _controlUnsetDebug_HelpExecute(CommandParser *parser,
-                                                    CommandOps *ops,
-                                                    PARCList *args,
-                                                    char *output,
-                                                    size_t output_size) {
-  snprintf(output, output_size, "unset debug: will disable the debug flag\n\n");
-  return CommandReturn_Success;
-}
-
-static CommandReturn _controlUnsetDebug_Execute(CommandParser *parser,
-                                                CommandOps *ops,
-                                                PARCList *args,
-                                                char *output,
-                                                size_t output_size) {
-  if (parcList_Size(args) != 2) {
-    _controlUnsetDebug_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  ControlState *state = ops->closure;
-  controlState_SetDebug(state, false);
-  snprintf(output, output_size, "Debug flag cleared\n\n");
-
-  return CommandReturn_Success;
-}
diff --git a/hicn-light/src/hicn/config/controlUnsetDebug.h b/hicn-light/src/hicn/config/controlUnsetDebug.h
deleted file mode 100644
index c76ba8c98..000000000
--- a/hicn-light/src/hicn/config/controlUnsetDebug.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 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 control_UnsetDebug.h
- * @brief Unsets the debug flag for more verbose output
- *
- * Implements the "unset debug" and "help unset debug" nodes of the CLI tree
- *
- */
-
-#ifndef Control_UnsetDebug_h
-#define Control_UnsetDebug_h
-
-#include <hicn/config/controlState.h>
-CommandOps *controlUnsetDebug_Create(ControlState *state);
-CommandOps *controlUnsetDebug_HelpCreate(ControlState *state);
-#endif  // Control_UnsetDebug_h
diff --git a/hicn-light/src/hicn/config/controlUpdate.c b/hicn-light/src/hicn/config/controlUpdate.c
deleted file mode 100644
index 095bbf01e..000000000
--- a/hicn-light/src/hicn/config/controlUpdate.c
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * 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.
- */
-
-#ifdef WITH_POLICY
-
-#include <hicn/hicn-light/config.h>
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/security/parc_Security.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/config/controlUpdate.h>
-#include <hicn/config/controlUpdateConnection.h>
-
-static void _controlUpdate_Init(CommandParser *parser, CommandOps *ops);
-static CommandReturn _controlUpdate_Execute(CommandParser *parser,
-                                          CommandOps *ops,
-                                          PARCList *args,
-                                          char *output,
-                                          size_t output_size);
-static CommandReturn _controlUpdate_HelpExecute(CommandParser *parser,
-                                              CommandOps *ops,
-                                              PARCList *args,
-                                              char *output,
-                                              size_t output_size);
-
-static const char *_commandUpdate = "update";
-static const char *_commandUpdateHelp = "help update";
-
-CommandOps *controlUpdate_Create(ControlState *state) {
-  return commandOps_Create(state, _commandUpdate, _controlUpdate_Init,
-                           _controlUpdate_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlUpdate_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, _commandUpdateHelp, NULL,
-                           _controlUpdate_HelpExecute, commandOps_Destroy);
-}
-
-// =====================================================
-
-static CommandReturn _controlUpdate_HelpExecute(CommandParser *parser,
-                                              CommandOps *ops,
-                                              PARCList *args,
-                                              char *output,
-                                              size_t output_size) {
-  //CommandOps *ops_update_connections = controlUpdateConnections_HelpCreate(NULL);
-  // CommandOps *ops_update_interfaces = controlUpdateInterfaces_HelpCreate(NULL);
-  //CommandOps *ops_update_routes = controlUpdateRoutes_HelpCreate(NULL);
-  CommandOps *ops_update_listeners = controlUpdateConnection_HelpCreate(NULL);
-  snprintf(output, output_size,
-                     "Available commands:\n   %s\n\n",
-                     ops_update_listeners->command);
-
-  
-
- // commandOps_Destroy(&ops_update_connections);
-  // commandOps_Destroy(&ops_update_interfaces);
-  //commandOps_Destroy(&ops_update_routes);
-  commandOps_Destroy(&ops_update_listeners);
-
-  return CommandReturn_Success;
-}
-
-static void _controlUpdate_Init(CommandParser *parser, CommandOps *ops) {
-  ControlState *state = ops->closure;
-  //controlState_RegisterCommand(state, controlUpdateConnections_HelpCreate(state));
-  // controlState_RegisterCommand(state,
-  // controlUpdateInterfaces_HelpCreate(state));
-  controlState_RegisterCommand(state, controlUpdateConnection_HelpCreate(state));
-  //controlState_RegisterCommand(state, controlUpdateRoutes_HelpCreate(state));
-  //controlState_RegisterCommand(state, controlUpdateConnections_Create(state));
-  // controlState_RegisterCommand(state, controlUpdateInterfaces_Create(state));
-  //controlState_RegisterCommand(state, controlUpdateRoutes_Create(state));
-  controlState_RegisterCommand(state, controlUpdateConnection_Create(state));
-}
-
-static CommandReturn _controlUpdate_Execute(CommandParser *parser,
-                                          CommandOps *ops,
-                                          PARCList *args,
-                                          char *output,
-                                          size_t output_size) {
-  return _controlUpdate_HelpExecute(parser, ops, args, output, output_size);
-}
-
-#endif /* WITH_POLICY */
diff --git a/hicn-light/src/hicn/config/controlUpdateConnection.c b/hicn-light/src/hicn/config/controlUpdateConnection.c
deleted file mode 100644
index 70a017d4f..000000000
--- a/hicn-light/src/hicn/config/controlUpdateConnection.c
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * 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.
- */
-
-#ifdef WITH_POLICY
-
-#include <hicn/hicn-light/config.h>
-
-#include <ctype.h>
-#include <inttypes.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-
-#include <hicn/config/controlUpdateConnection.h>
-
-#include <hicn/policy.h>
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-static CommandReturn _controlUpdateConnection_Execute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size);
-static CommandReturn _controlUpdateConnection_HelpExecute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size);
-
-static const char *command_update_connection = "update connection";
-static const char *command_help_update_connection = "help update connection";
-
-CommandOps *controlUpdateConnection_Create(ControlState *state) {
-  return commandOps_Create(state, command_update_connection, NULL,
-                           _controlUpdateConnection_Execute, commandOps_Destroy);
-}
-
-CommandOps *controlUpdateConnection_HelpCreate(ControlState *state) {
-  return commandOps_Create(state, command_help_update_connection, NULL,
-                           _controlUpdateConnection_HelpExecute, commandOps_Destroy);
-}
-
-// ====================================================
-
-static const int _indexSymbolic = 2;
-static const int _indexTags = 3;
-
-static CommandReturn _controlUpdateConnection_HelpExecute(CommandParser *parser,
-                                                     CommandOps *ops,
-                                                     PARCList *args,
-                                                     char *output,
-                                                     size_t output_size) {
-  
-  snprintf(output, output_size,
-                     "commands:\n"
-                     "   update connection <symbolic | id> <tags> \n"
-                     "\n"
-                     "   symbolic:        User defined name for connection, must start with "
-                     "alpha and be alphanum\n"
-                     "         id:        Identifier for the connection\n"
-                     "   tags:            A string representing tags\n");
-  return CommandReturn_Success;
-}
-
-
-static CommandReturn _controlUpdateConnection_Execute(CommandParser *parser,
-                                                 CommandOps *ops,
-                                                 PARCList *args,
-                                                 char *output,
-                                                 size_t output_size) {
-  if ((parcList_Size(args) != 3) && (parcList_Size(args) != 4)) {
-    _controlUpdateConnection_HelpExecute(parser, ops, args, output, output_size);
-    return CommandReturn_Failure;
-  }
-
-  const char *symbolicOrConnid = parcList_GetAtIndex(args, _indexSymbolic);
-
-  if (!utils_ValidateSymbolicName(symbolicOrConnid) &&
-      !utils_IsNumber(symbolicOrConnid)) {
-    snprintf(output, output_size,
-        "ERROR: Invalid symbolic or connid:\nsymbolic name must begin with an "
-        "alpha followed by alphanum;\nconnid must be an integer\n");
-    return CommandReturn_Failure;
-  }
-
-  policy_tags_t tags = POLICY_TAGS_EMPTY;
-  if (parcList_Size(args) == 4) {
-    const char *str_tags = parcList_GetAtIndex(args, _indexTags);
-  
-    for (unsigned i = 0; str_tags[i] != 0; i++) {
-      switch(tolower(str_tags[i])) {
-        case 'e':
-          policy_tags_add(&tags, POLICY_TAG_WIRED);
-          break;
-        case 'w':
-          policy_tags_add(&tags, POLICY_TAG_WIFI);
-          break;
-        case 'c':
-          policy_tags_add(&tags, POLICY_TAG_CELLULAR);
-          break;
-        case 'b':
-          policy_tags_add(&tags, POLICY_TAG_BEST_EFFORT);
-          break;
-        case 'r':
-          policy_tags_add(&tags, POLICY_TAG_REALTIME);
-          break;
-        case 'm':
-          policy_tags_add(&tags, POLICY_TAG_MULTIPATH);
-          break;
-        case 't':
-          policy_tags_add(&tags, POLICY_TAG_TRUSTED);
-          break;
-      }
-    }
-  }
-  ControlState *state = ops->closure;
-
-  // allocate command payload
-  update_connection_command *updateConnectionCommand =
-      parcMemory_AllocateAndClear(sizeof(update_connection_command));
-  updateConnectionCommand->tags = tags;
-  strcpy(updateConnectionCommand->symbolicOrConnid, symbolicOrConnid);
-
-  // send message and receive response
-  struct iovec *response = utils_SendRequest(
-      state, UPDATE_CONNECTION, updateConnectionCommand, sizeof(update_connection_command));
-
-  if (!response)  // get NULL pointer
-    return CommandReturn_Failure;
-
-  parcMemory_Deallocate(&response);  // free iovec pointer
-  return CommandReturn_Success;
-}
-
-#endif /* WITH_POLICY */
diff --git a/hicn-light/src/hicn/config/parse.c b/hicn-light/src/hicn/config/parse.c
new file mode 100644
index 000000000..ba9c0b348
--- /dev/null
+++ b/hicn-light/src/hicn/config/parse.c
@@ -0,0 +1,402 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+//#include <hicn/ctrl/cli.h>
+#include <hicn/util/log.h>
+#include <hicn/util/sstrncpy.h>
+#include "parse.h"
+
+/*
+ * As there is no portable way to generate a va_list to use with sscanf to
+ * support a variable number of arguments, and no way to use a variable array
+ * initialize in a nested struct, we use a fixed maximum number of parameters
+ *
+ * NOTE: update sscanf accordingly
+ */
+
+#include "command.h"
+
+const char *action_str[] = {
+#define _(x) [ACTION_##x] = #x,
+    foreach_action
+#undef _
+};
+
+#define action_str(x) action_str[x]
+
+hc_action_t action_from_str(const char *action_str) {
+#define _(x)                           \
+  if (strcasecmp(action_str, #x) == 0) \
+    return ACTION_##x;                 \
+  else
+  foreach_action
+#undef _
+      if (strcasecmp(action_str, "add") == 0) return ACTION_CREATE;
+  else if (strcasecmp(action_str, "remove") == 0) return ACTION_DELETE;
+  else return ACTION_UNDEFINED;
+}
+
+const char *object_str[] = {
+#define _(x) [OBJECT_##x] = #x,
+    foreach_object
+#undef _
+};
+
+#define object_str(x) object_str[x]
+
+hc_object_type_t object_from_str(const char *object_str) {
+#define _(x)                           \
+  if (strcasecmp(object_str, #x) == 0) \
+    return OBJECT_##x;                 \
+  else
+  foreach_object
+#undef _
+      return OBJECT_UNDEFINED;
+}
+
+const char *action_to_cmd_action(hc_action_t action) {
+  switch (action) {
+    case ACTION_CREATE:
+      return "add";
+    case ACTION_UPDATE:
+      return "update";
+    case ACTION_DELETE:
+      return "remove";
+    case ACTION_LIST:
+      return "list";
+    case ACTION_SET:
+      return "set";
+    case ACTION_SERVE:
+      return "serve";
+    case ACTION_STORE:
+      return "store";
+    case ACTION_CLEAR:
+      return "clear";
+    default:
+      return "UNDEFINED";
+  }
+}
+
+const char *parser_type_fmt(const parser_type_t *type) {
+  switch (type->name) {
+    case TYPENAME_INT:
+      return TYPE_FMT_INT;
+    case TYPENAME_UINT:
+      return TYPE_FMT_UINT;
+    case TYPENAME_STR:
+      return TYPE_FMT_STRN(type->str.max_size);
+    case TYPENAME_SYMBOLIC_OR_ID:
+      return TYPE_FMT_SYMBOLIC_OR_ID;
+    case TYPENAME_INTERFACE_NAME:
+      return TYPE_FMT_INTERFACE_NAME;
+    case TYPENAME_IP_ADDRESS:
+      return TYPE_FMT_IP_ADDRESS;
+    case TYPENAME_IP_PREFIX:
+      return TYPE_FMT_IP_PREFIX;
+    case TYPENAME_ON_OFF:
+      return TYPE_FMT_ON_OFF;
+    case TYPENAME_ENUM:
+      return TYPE_FMT_ENUM;
+    case TYPENAME_POLICY_STATE:
+      return TYPE_FMT_POLICY_STATE;
+    case TYPENAME_UNDEFINED:
+    default:
+      return NULL;
+  }
+}
+
+int parser_type_func(const parser_type_t *type, void *src, void *dst,
+                     void *dst2, void *dst3) {
+  ip_address_t addr;
+  char *addr_str;
+  char *len_str;
+  int len, tmp, rc;
+
+  switch (type->name) {
+    case TYPENAME_INT:
+      tmp = *(int *)src;
+      if (tmp < type->sint.min || tmp > type->sint.max) {
+        ERROR("Input number (%d) not inside range [%d, %d]", tmp,
+              type->sint.min, type->sint.max);
+        return -1;
+      }
+      *(int *)dst = *(int *)src;
+      break;
+    case TYPENAME_UINT:
+      tmp = *(int *)src;
+      if (tmp < type->uint.min || tmp > type->uint.max) {
+        ERROR("Input number (%d) not inside range [%d, %d]", tmp,
+              type->uint.min, type->uint.max);
+        return -1;
+      }
+      *(unsigned *)dst = *(unsigned *)src;
+      break;
+    case TYPENAME_STR:
+      rc = strcpy_s(dst, type->str.max_size, src);
+      if (rc != EOK) {
+        ERROR("Input string is too long");
+        return -1;
+      }
+      break;
+    case TYPENAME_IP_ADDRESS:
+      rc = ip_address_pton((char *)src, &addr);
+      if (rc < 0) {
+        ERROR("Wrong IP address format");
+        return -1;
+      }
+
+      *(ip_address_t *)dst = addr;
+      *(int *)dst2 = ip_address_get_family((char *)src);
+      break;
+    case TYPENAME_ON_OFF:
+      if (strcmp((char *)src, "off") == 0) {
+        *(unsigned *)dst = 0;
+      } else if (strcmp((char *)src, "on") == 0) {
+        *(unsigned *)dst = 1;
+      } else {
+        ERROR("on/off are the only possible values");
+        return -1;
+      }
+      break;
+    case TYPENAME_IP_PREFIX:
+      addr_str = strtok((char *)src, "/");
+      len_str = strtok(NULL, " ");
+      rc = ip_address_pton((char *)src, &addr);
+      if (rc < 0) {
+        ERROR("Wrong IP address format");
+        return -1;
+      }
+      len = atoi(len_str);
+
+      *(ip_address_t *)dst = addr;
+      *(int *)dst2 = len;
+      *(int *)dst3 = ip_address_get_family(addr_str);
+      break;
+    case TYPENAME_ENUM:
+      /* Enum index from string */
+      assert(type->enum_.from_str);
+      *(int *)dst = type->enum_.from_str((char *)src);
+      break;
+    case TYPENAME_POLICY_STATE: {
+      assert(IS_VALID_POLICY_TAG(type->policy_state.tag));
+      policy_tag_t tag = type->policy_state.tag;
+      /* Format string is "%ms" */
+      const char *str = *(const char **)src;
+      policy_tag_state_t *pts = ((policy_tag_state_t *)dst);
+      pts[tag].disabled = (str[0] == '!') ? 1 : 0;
+      pts[tag].state = policy_state_from_str(str + pts[tag].disabled);
+      break;
+    }
+    case TYPENAME_UNDEFINED:
+    default:
+      ERROR("Unknown format");
+      return -1;
+  }
+  return 0;
+}
+
+int parse_params(const command_parser_t *parser, const char *params_s,
+                 hc_command_t *command) {
+  char fmt[1024];
+  int n;
+  size_t size = 0;
+  char *pos = fmt;
+  /* Update MAX_PARAMETERS accordingly in command.h */
+  char sscanf_params[MAX_PARAMETERS][MAX_SCANF_PARAM_LEN];
+
+  unsigned count = 0;
+  for (unsigned i = 0; i < parser->nparams; i++) {
+    const command_parameter_t *p = &parser->parameters[i];
+    const char *_fmt = parser_type_fmt(&p->type);
+    // printf("    _fmt=%s\n", _fmt);
+    if (!_fmt) {
+      WARN("Ignored parameter %s with unknown type formatter", p->name);
+      continue;
+    }
+    n = snprintf(pos, 1024 - size, "%s", _fmt);
+    pos += n;
+
+    *pos = ' ';
+    pos++;
+
+    size += n + 1;
+    count++;
+  }
+  *pos = '\0';
+  DEBUG("parser format: %s", fmt);
+
+  int ret = sscanf(params_s, fmt, sscanf_params[0], sscanf_params[1],
+                   sscanf_params[2], sscanf_params[3], sscanf_params[4],
+                   sscanf_params[5], sscanf_params[6], sscanf_params[7],
+                   sscanf_params[8], sscanf_params[9]);
+  if (ret != parser->nparams) {
+    ERROR("Parsing failed: check for string used where integer was expected");
+    goto ERR;
+  }
+
+  for (unsigned i = 0; i < count; i++) {
+    const command_parameter_t *p = &parser->parameters[i];
+    if (parser_type_func(&p->type, sscanf_params[i],
+                         &command->object.as_uint8 + p->offset,
+                         &command->object.as_uint8 + p->offset2,
+                         &command->object.as_uint8 + p->offset3) < 0) {
+      ERROR("Error during parsing of parameter '%s' value", p->name);
+      goto ERR;
+    }
+  }
+  return 0;
+
+ERR:
+  return -1;
+}
+
+int parse(const char *cmd, hc_command_t *command) {
+  int nparams = 0;
+  char action_s[MAX_SCANF_PARAM_LEN];
+  char object_s[MAX_SCANF_PARAM_LEN];
+  char params_s[MAX_SCANF_PARAM_LEN];
+
+  // if n = 2 later, params_s is uninitialized
+  memset(params_s, 0, MAX_SCANF_PARAM_LEN * sizeof(char));
+
+  errno = 0;
+  int n = sscanf(cmd, "%s %s%[^\n]s", action_s, object_s, params_s);
+  if ((n < 2) || (n > 3)) {
+    if (errno != 0) perror("scanf");
+    return -1;
+  }
+
+  command->action = action_from_str(action_s);
+  command->object.type = object_from_str(object_s);
+
+  if (strnlen_s(params_s, MAX_SCANF_PARAM_LEN) > 0) {
+    for (char *ptr = params_s; (ptr = strchr(ptr, ' ')) != NULL; ptr++)
+      nparams++;
+  }
+
+  /*
+   * This checks is important even with 0 parameters as it checks whether the
+   * command exists.
+   */
+  const command_parser_t *parser =
+      command_search(command->action, command->object.type, nparams);
+  if (!parser) {
+    ERROR("Could not find parser for command '%s %s'", action_s, object_s);
+    return -1;
+  }
+
+  if (strnlen_s(params_s, MAX_SCANF_PARAM_LEN) > 0) {
+    if (parse_params(parser, params_s, command) < 0) return -1;
+  }
+
+  if (parser->post_hook) parser->post_hook(&command->object.as_uint8);
+  return 0;
+}
+
+int help(const char *cmd) {
+  int nparams = 1;
+  char action_s[MAX_SCANF_PARAM_LEN];
+  char object_s[MAX_SCANF_PARAM_LEN];
+  char params_s[MAX_SCANF_PARAM_LEN];
+  hc_object_type_t object = OBJECT_UNDEFINED;
+  hc_action_t action = ACTION_UNDEFINED;
+
+  int n = sscanf(cmd, "help %[^\n]s", params_s);
+
+  // No arguments provided to the help command: just list available objects
+  if (n != 1) goto CMD_LIST;
+
+  // Count number of provided parameters
+  for (char *ptr = params_s; (ptr = strchr(ptr, ' ')) != NULL; ptr++) nparams++;
+  if (nparams > 2) {
+    fprintf(stderr, "Error: too many arguments.\n");
+    return -1;
+  }
+
+  // Object specified: list actions available for that object
+  if (nparams == 1) {
+    object = object_from_str(params_s);
+    if (object == OBJECT_UNDEFINED) {
+      fprintf(stderr, "Error: undefined object.\n");
+      return -1;
+    }
+
+    goto CMD_LIST;
+  }
+
+  // Object and action specified: list detailed commands
+  n = sscanf(params_s, "%s %[^\n]s", object_s, action_s);
+  assert(n == 2);
+  object = object_from_str(object_s);
+  action = action_from_str(action_s);
+  if (object == OBJECT_UNDEFINED || action == ACTION_UNDEFINED) {
+    fprintf(stderr, "Error: undefined object and/or action.\n");
+    return -1;
+  }
+
+CMD_LIST:
+  printf("Available commands:\n");
+  command_list(object, action);
+  return 0;
+}
+
+#if 0  // tests
+/* For the tests, we will need to test all non-compliant inputs */
+const char * cmds[] = {
+        "add connection hicn conn1 8.8.8.8 127.0.0.1 eth0",
+        "add connection udp <symbolic> <remote_ip> <port> <local_ip> <port> eth0",
+        "add listener udp lst1 127.0.0.1 9695 eth0",
+        //"add face",
+        "add route 3 b001::/16 1",
+        //"add punting",
+        //"add strategy",
+        "add policy b001::/16 webex require avoid prohibit !prohibit neutral !require prefer",
+        "list connection", // need pluralize
+        "list listener",
+        "list face",
+        "list route",
+        "list punting",
+        "list strategy",
+        "list policy",
+        "remove connection 1",
+        "remove listener 1",
+        //"remove face",
+        "remove route 1 b001::/16",
+        //"remove punting",
+        //"remove policy",
+        "set debug",
+        "unset debug",
+        "set strategy b001::/16 random", // related prefixes (10 max) ?
+        "set strategy b001::/16 load_balancer",
+        "set strategy b001::/16 low_latency",
+        "set strategy b001::/16 replication",
+        "set strategy b001::/16 bestpath",
+        "set wldr <on|off> <connection_id>", // on-off vs unset
+        "cache clear",
+        "cache store on/off", // set/unset
+        "cache serve on/off",
+        "mapme enable on/off",
+        "mapme discovery on/off",
+        "mapme timescale 500ms",
+        "mapme retx 500ms",
+        "update connection conn1 WT",
+};
+
+#define array_size(x) sizeof(x) / sizeof(typeof(x[0]))
+int main()
+{
+    for (unsigned i = 0; i < array_size(cmds); i++) {
+        printf("PARSING [%d] %s\n", i, cmds[i]);
+        if (parse(cmds[i]) < 0) {
+            ERROR("Could not parse command: %s\n", cmds[i]);
+            continue;
+        }
+    }
+    exit(EXIT_SUCCESS);
+
+ERR:
+    exit(EXIT_FAILURE);
+}
+#endif
diff --git a/hicn-light/src/hicn/config/parse.h b/hicn-light/src/hicn/config/parse.h
new file mode 100644
index 000000000..06269208a
--- /dev/null
+++ b/hicn-light/src/hicn/config/parse.h
@@ -0,0 +1,15 @@
+#ifndef HICNLIGHT_PARSE_CMD
+#define HICNLIGHT_PARSE_CMD
+
+#include <hicn/ctrl/api.h>
+
+int parse(const char* cmd, hc_command_t* command);
+int help(const char* cmd);
+
+/**
+ * @brief Convert the action enum to the action name used in the commands (e.g.
+ * from ACTION_CREATE to "add").
+ */
+const char* action_to_cmd_action(hc_action_t action);
+
+#endif /* HICNLIGHT_PARSE_CMD */
diff --git a/hicn-light/src/hicn/config/symbolicNameTable.c b/hicn-light/src/hicn/config/symbolicNameTable.c
deleted file mode 100644
index e5ae81d3e..000000000
--- a/hicn-light/src/hicn/config/symbolicNameTable.c
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
- * 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 <ctype.h>
-#include <parc/algol/parc_Hash.h>
-#include <parc/algol/parc_HashCodeTable.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <hicn/config/symbolicNameTable.h>
-
-struct symblic_name_table {
-  PARCHashCodeTable *symbolicNameTable;
-  PARCHashCodeTable *indexToNameTable;
-};
-
-// ========================================================================================
-// symbolic name table functions
-
-static bool _symbolicNameEquals(const void *keyA, const void *keyB) {
-  return (strcasecmp((const char *)keyA, (const char *)keyB) == 0);
-}
-
-static HashCodeType _symbolicNameHash(const void *keyA) {
-  const char *str = (const char *)keyA;
-  size_t length = strlen(str);
-  return parcHash32_Data(str, length);
-}
-
-static bool _connectionIdEquals(const void *keyA, const void *keyB) {
-  unsigned idA = *((unsigned *)keyA);
-  unsigned idB = *((unsigned *)keyB);
-  return (idA == idB);
-}
-
-static HashCodeType _connectionIdHash(const void *keyA) {
-  unsigned idA = *((unsigned *)keyA);
-  return parcHash32_Int32(idA);
-}
-
-// ========================================================================================
-
-SymbolicNameTable *symbolicNameTable_Create(void) {
-  SymbolicNameTable *table = parcMemory_Allocate(sizeof(SymbolicNameTable));
-
-  if (table) {
-    // key = char *
-    // value = uint32_t *
-    table->symbolicNameTable = parcHashCodeTable_Create(
-        _symbolicNameEquals, _symbolicNameHash, parcMemory_DeallocateImpl,
-        parcMemory_DeallocateImpl);
-    table->indexToNameTable = parcHashCodeTable_Create(
-        _connectionIdEquals, _connectionIdHash, parcMemory_DeallocateImpl,
-        parcMemory_DeallocateImpl);
-  }
-
-  return table;
-}
-
-void symbolicNameTable_Destroy(SymbolicNameTable **tablePtr) {
-  SymbolicNameTable *table = *tablePtr;
-  parcHashCodeTable_Destroy(&table->symbolicNameTable);
-  parcHashCodeTable_Destroy(&table->indexToNameTable);
-  parcMemory_Deallocate((void **)&table);
-  *tablePtr = NULL;
-}
-
-static char *_createKey(const char *symbolicName) {
-  char *key = parcMemory_StringDuplicate(symbolicName, strlen(symbolicName));
-
-  // convert key to upper case
-  char *p = key;
-
-  // keeps looping until the first null
-  while ((*p = toupper(*p))) {
-    p++;
-  }
-  return key;
-}
-
-bool symbolicNameTable_Exists(SymbolicNameTable *table,
-                              const char *symbolicName) {
-  parcAssertNotNull(table, "Parameter table must be non-null");
-  parcAssertNotNull(symbolicName, "Parameter symbolicName must be non-null");
-
-  char *key = _createKey(symbolicName);
-  bool found = (parcHashCodeTable_Get(table->symbolicNameTable, key) != NULL);
-  parcMemory_Deallocate((void **)&key);
-  return found;
-}
-
-void symbolicNameTable_Remove(SymbolicNameTable *table,
-                              const char *symbolicName) {
-  parcAssertNotNull(table, "Parameter table must be non-null");
-  parcAssertNotNull(symbolicName, "Parameter symbolicName must be non-null");
-
-  char *key = _createKey(symbolicName);
-
-  unsigned id = symbolicNameTable_Get(table, symbolicName);
-  uint32_t *value = parcMemory_Allocate(sizeof(uint32_t));
-  *value = id;
-
-  parcHashCodeTable_Del(table->symbolicNameTable, key);
-  parcHashCodeTable_Del(table->indexToNameTable, value);
-  parcMemory_Deallocate((void **)&key);
-  parcMemory_Deallocate((void **)&value);
-}
-
-bool symbolicNameTable_Add(SymbolicNameTable *table, const char *symbolicName,
-                           unsigned connid) {
-  parcAssertNotNull(table, "Parameter table must be non-null");
-  parcAssertNotNull(symbolicName, "Parameter symbolicName must be non-null");
-  parcAssertTrue(connid < UINT32_MAX, "Parameter connid must be less than %u",
-                 UINT32_MAX);
-
-  char *key1 = _createKey(symbolicName);
-
-  uint32_t *value1 = parcMemory_Allocate(sizeof(uint32_t));
-  *value1 = connid;
-
-  bool success = parcHashCodeTable_Add(table->symbolicNameTable, key1, value1);
-  if (!success)
-      goto ERR_NAME;
-
-  char *key2 = _createKey(symbolicName);
-
-  uint32_t *value2 = parcMemory_Allocate(sizeof(uint32_t));
-  *value2 = connid;
-
-  success = parcHashCodeTable_Add(table->indexToNameTable, value2, key2);
-  if (!success)
-      goto ERR_INDEX;
-
-  goto END;
-
-ERR_INDEX:
-    parcMemory_Deallocate((void **)&key2);
-    parcMemory_Deallocate((void **)&value2);
-    parcHashCodeTable_Del(table->symbolicNameTable, key1);
-ERR_NAME:
-    parcMemory_Deallocate((void **)&key1);
-    parcMemory_Deallocate((void **)&value1);
-END:
-  return success;
-
-}
-
-unsigned symbolicNameTable_Get(SymbolicNameTable *table,
-                               const char *symbolicName) {
-  parcAssertNotNull(table, "Parameter table must be non-null");
-  parcAssertNotNull(symbolicName, "Parameter symbolicName must be non-null");
-
-  unsigned connid = UINT32_MAX;
-
-  char *key = _createKey(symbolicName);
-
-  uint32_t *value = parcHashCodeTable_Get(table->symbolicNameTable, key);
-  if (value)
-    connid = *value;
-
-  parcMemory_Deallocate((void **)&key);
-  return connid;
-}
-
-const char *symbolicNameTable_GetNameByIndex(SymbolicNameTable *table,
-                                             unsigned id) {
-  parcAssertNotNull(table, "Parameter table must be non-null");
-
-  uint32_t *value = parcMemory_Allocate(sizeof(uint32_t));
-  *value = id;
-
-  const char *name = parcHashCodeTable_Get(table->indexToNameTable, value);
-  if (name == NULL) name = "";
-
-  parcMemory_Deallocate((void **)&value);
-  return name;
-}
diff --git a/hicn-light/src/hicn/config/symbolicNameTable.h b/hicn-light/src/hicn/config/symbolicNameTable.h
deleted file mode 100644
index 69919cf00..000000000
--- a/hicn-light/src/hicn/config/symbolicNameTable.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * 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 symbolicNameTable.h
- * @brief The symbolic name table maps a string name to a connection id
- *
- * When configuring tunnels/connections, the user provides a string name
- * (symbolic name) that they will use to refer to that connection.  The symblic
- * name table translates that symbolic name to a connection id.
- *
- */
-
-#ifndef symbolicNameTable_h
-#define symbolicNameTable_h
-
-struct symblic_name_table;
-typedef struct symblic_name_table SymbolicNameTable;
-
-#include <stdbool.h>
-
-/**
- * Creates a symbolic name table
- *
- * Allocates a SymbolicNameTable, which will store the symbolic names
- * in a hash table.
- *
- * @retval non-null An allocated SymbolicNameTable
- * @retval null An error
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-SymbolicNameTable *symbolicNameTable_Create(void);
-
-/**
- * Destroys a name table
- *
- * All keys and data are released.
- *
- * @param [in,out] tablePtr A pointer to a SymbolicNameTable, which will be
- * NULL'd
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void symbolicNameTable_Destroy(SymbolicNameTable **tablePtr);
-
-/**
- * Checks if the name (case insensitive) is in the table
- *
- * Does a case-insensitive match to see if the name is in the table
- *
- * @param [in] table An allocated SymbolicNameTable
- * @param [in] symbolicName The name to check for
- *
- * @retval true The name is in the table
- * @retval false The name is not in the talbe
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-bool symbolicNameTable_Exists(SymbolicNameTable *table,
-                              const char *symbolicName);
-
-/**
- * Adds a (name, connid) pair to the table.
- *
- * The name is stored case insensitive.  The value UINT_MAX is used to indicate
- * a non-existent key, so it should not be stored as a value in the table.
- *
- * @param [in] table An allocated SymbolicNameTable
- * @param [in] symbolicName The name to save (will make a copy)
- * @param [in] connid The connection id to associate with the name
- *
- * @retval true The pair was added
- * @retval false The pair was not added (likely duplicate key)
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-bool symbolicNameTable_Add(SymbolicNameTable *table, const char *symbolicName,
-                           unsigned connid);
-
-/**
- * Returns the connection id associated with the symbolic name
- *
- * This function will look for the given name (case insensitive) and return the
- * corresponding connid.  If the name is not in the table, the function will
- * return UINT_MAX.
- *
- * @param [in] table An allocated SymbolicNameTable
- * @param [in] symbolicName The name to retrieve
- *
- * @retval UINT_MAX symbolicName not found
- * @retval number the corresponding connid.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-unsigned symbolicNameTable_Get(SymbolicNameTable *table,
-                               const char *symbolicName);
-
-void symbolicNameTable_Remove(SymbolicNameTable *table,
-                              const char *symbolicName);
-const char *symbolicNameTable_GetNameByIndex(SymbolicNameTable *table,
-                                             unsigned id);
-
-#endif /* defined(symbolicNameTable_h) */
diff --git a/hicn-light/src/hicn/content_store/CMakeLists.txt b/hicn-light/src/hicn/content_store/CMakeLists.txt
index aaf256118..f7cfc26b6 100644
--- a/hicn-light/src/hicn/content_store/CMakeLists.txt
+++ b/hicn-light/src/hicn/content_store/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -12,20 +12,12 @@
 # limitations under the License.
 
 list(APPEND HEADER_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/contentStoreEntry.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/contentStoreInterface.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/contentStoreLRU.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/listTimeOrdered.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/listLRU.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/lru.h
 )
 
 list(APPEND SOURCE_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/contentStoreInterface.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/contentStoreLRU.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/listLRU.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/listTimeOrdered.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/contentStoreEntry.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/lru.c
 )
 
 set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
-set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
\ No newline at end of file
+set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
diff --git a/hicn-light/src/hicn/content_store/contentStoreEntry.c b/hicn-light/src/hicn/content_store/contentStoreEntry.c
deleted file mode 100644
index 45f98881e..000000000
--- a/hicn-light/src/hicn/content_store/contentStoreEntry.c
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <hicn/content_store/contentStoreEntry.h>
-
-#include <parc/assert/parc_Assert.h>
-
-const uint64_t contentStoreEntry_MaxExpiryTime = UINT64_MAX;
-
-struct contentstore_entry {
-  Message *message;
-  ListLruEntry *lruEntry;
-  unsigned refcount;
-  bool hasExpiryTimeTicks;
-  uint64_t expiryTimeTicks;
-};
-
-ContentStoreEntry *contentStoreEntry_Create(Message *contentMessage,
-                                            ListLru *listLRU) {
-  parcAssertNotNull(contentMessage, "Parameter objectMessage must be non-null");
-
-  ContentStoreEntry *entry =
-      parcMemory_AllocateAndClear(sizeof(ContentStoreEntry));
-  parcAssertNotNull(entry, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(ContentStoreEntry));
-  entry->message = message_Acquire(contentMessage);
-  entry->refcount = 1;
-
-  if (listLRU != NULL) {
-    entry->lruEntry = listLRU_NewHeadEntry(listLRU, entry);
-  }
-
-  entry->hasExpiryTimeTicks = message_HasContentExpiryTime(contentMessage);
-
-  if (entry->hasExpiryTimeTicks) {
-    entry->expiryTimeTicks = message_GetContentExpiryTimeTicks(contentMessage);
-  }
-
-  return entry;
-}
-
-ContentStoreEntry *contentStoreEntry_Acquire(
-    const ContentStoreEntry *original) {
-  parcAssertNotNull(original, "Parameter must be non-null");
-  ((ContentStoreEntry *)original)->refcount++;
-  return (ContentStoreEntry *)original;
-}
-
-void contentStoreEntry_Release(ContentStoreEntry **entryPtr) {
-  parcAssertNotNull(entryPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*entryPtr,
-                    "Parameter must dereference to non-null pointer");
-
-  ContentStoreEntry *entry = *entryPtr;
-  parcAssertTrue(entry->refcount > 0, "Illegal state: has refcount of 0");
-
-  entry->refcount--;
-  if (entry->refcount == 0) {
-    if (entry->lruEntry) {
-      listLRU_EntryDestroy(&entry->lruEntry);
-    }
-    message_Release(&entry->message);
-    parcMemory_Deallocate((void **)&entry);
-  }
-  *entryPtr = NULL;
-}
-
-Message *contentStoreEntry_GetMessage(const ContentStoreEntry *storeEntry) {
-  parcAssertNotNull(storeEntry, "Parameter must be non-null");
-  return storeEntry->message;
-}
-
-bool contentStoreEntry_HasExpiryTimeTicks(const ContentStoreEntry *storeEntry) {
-  parcAssertNotNull(storeEntry, "Parameter must be non-null");
-  return storeEntry->hasExpiryTimeTicks;
-}
-
-uint64_t contentStoreEntry_GetExpiryTimeTicks(
-    const ContentStoreEntry *storeEntry) {
-  parcAssertNotNull(storeEntry, "Parameter must be non-null");
-  parcAssertTrue(storeEntry->hasExpiryTimeTicks,
-                 "storeEntry has no ExpiryTimeTicks. Did you call "
-                 "contentStoreEntry_HasExpiryTimeTicks() first?");
-  return storeEntry->expiryTimeTicks;
-}
-
-int contentStoreEntry_CompareExpiryTime(const ContentStoreEntry *value1,
-                                        const ContentStoreEntry *value2) {
-  // A signum comparison. negative if key 1 is smaller, 0 if key1 == key2,
-  // greater than 0 if key1 is bigger.
-
-  ContentStoreEntry *v1 = (ContentStoreEntry *)value1;
-  ContentStoreEntry *v2 = (ContentStoreEntry *)value2;
-
-  if (v1->expiryTimeTicks < v2->expiryTimeTicks) {
-    return -1;
-  } else if (v1->expiryTimeTicks > v2->expiryTimeTicks) {
-    return +1;
-  } else {
-    // At this point, the times are the same. Use the address of the message as
-    // the decider. This allows us to store multiple messages with the same
-    // expiry/cache time.
-    if (v1->message < v2->message) {
-      return -1;
-    } else if (v1->message > v2->message) {
-      return +1;
-    }
-  }
-
-  return 0;  // The same message has been encountered.
-}
-
-void contentStoreEntry_MoveToHead(ContentStoreEntry *storeEntry) {
-  parcAssertNotNull(storeEntry, "Parameter must be non-null");
-  parcAssertNotNull(storeEntry->lruEntry,
-                    "ContentStoreEntry is not attached to an ListLru");
-  if (storeEntry->lruEntry) {
-    listLRU_EntryMoveToHead(storeEntry->lruEntry);
-  }
-}
diff --git a/hicn-light/src/hicn/content_store/contentStoreEntry.h b/hicn-light/src/hicn/content_store/contentStoreEntry.h
deleted file mode 100644
index 4f0fd19c1..000000000
--- a/hicn-light/src/hicn/content_store/contentStoreEntry.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * 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 contentStoreEntry_h
-#define contentStoreEntry_h
-
-#include <hicn/content_store/listLRU.h>
-#include <hicn/core/message.h>
-
-struct contentstore_entry;
-typedef struct contentstore_entry ContentStoreEntry;
-
-/**
- * The max time allowed for an ExpiryTime. Will never be exceeded.
- */
-extern const uint64_t contentStoreEntry_MaxExpiryTime;
-
-/**
- * Creates a new `ContentStoreEntry` instance, acquiring a reference to the
- * supplied `Message`.
- *
- * @param message the message to store
- * @param listLRU the LRU list that this entry will be stored in.
- * @return A newly created `ContentStoreEntry` instance that must eventually be
- * released by calling
- *         {@link contentStoreEntry_Release}.
- *
- * @see contentStoreEntry_Release
- */
-ContentStoreEntry *contentStoreEntry_Create(Message *objectMessage,
-                                            ListLru *listLRU);
-
-/**
- * Returns a reference counted copy of the supplied `ContentStoreEntry`.
- *
- * @param original the ContentStoreEntry to return a reference to.
- * @return Reference counted copy, must call
- * <code>contentStoreEntry_Destroy()</code> on it.
- */
-ContentStoreEntry *contentStoreEntry_Acquire(const ContentStoreEntry *original);
-
-/**
- * Releases one reference count and destroys object when reaches zero
- *
- * @param [in,out] entryPtr A pointer to an allocated ContentStoreEntry
- *
- */
-void contentStoreEntry_Release(ContentStoreEntry **entryPtr);
-
-/**
- * Returns a pointer to the contained {@link Message}.
- * The caller must called {@link message_Acquire()} if they want to keep a
- * reference to the returned message.
- *
- * @param storeEntry the ContentStoreEntry from which to retrieve the `Message`
- * pointer.
- * @return the address of the `Message` contained in the storeEntry.
- * @see message_Acquire
- */
-Message *contentStoreEntry_GetMessage(const ContentStoreEntry *storeEntry);
-
-/**
- * Return true if the message stored in this `ContentStoreEntry` has an
- * ExpiryTime.
- *
- * @param storeEntry the ContentStoreEntry containing the message.
- * @return true if the referenced message has an ExpiryTime. False, otherwise.
- */
-bool contentStoreEntry_HasExpiryTimeTicks(const ContentStoreEntry *storeEntry);
-
-/**
- * Return the ExpiryTime stored in this `ContentStoreEntry`.
- *
- * @param storeEntry the ContentStoreEntry from which to retrieve the `Message`
- * pointer.
- * @return the address of the `Message` contained in the storeEntry.
- */
-uint64_t contentStoreEntry_GetExpiryTimeTicks(
-    const ContentStoreEntry *storeEntry);
-
-/**
- * A signum function comparing two `ContentStoreEntry` instances, using their
- * ExpiryTime and, if necessary, the addresses of the referenced Message. In
- * other words, if two ContentStoreEntries have the same ExpiryTime, the
- * comparison will then be made on the memory addresses of the Messages
- * referenced by the ContentStoreEntrys. So, the only way two ContentStoreEntrys
- * will compare equally (0) is if they both have the same ExpiryTime and
- * reference the same Message.
- *
- * Used to determine the ordering relationship of two `ContentStoreEntry`
- * instances. This is used by the {@link ListTimeOrdered} to keep a list of
- * ContentStoreEntrys, sorted by ExpiryTime.
- *
- * @param [in] storeEntry1 A pointer to a `ContentStoreEntry` instance.
- * @param [in] storeEntry2 A pointer to a `ContentStoreEntry` instance to be
- * compared to `storeEntry1`.
- *
- * @return 0 if `storeEntry1` and `storeEntry2` are equivalent
- * @return < 0 if `storeEntry1` < `storeEntry2`
- * @return > 0 if `storeEntry1` > `storeEntry2`
- *
- * Example:
- * @code
- * {
- *     ContentStoreEntry *entry1 = contentStoreEntry_Create(...);
- *     ContentStoreEntry *entry2 = contentStoreEntry_Create(...);
- *
- *     int val = contentStoreEntry_CompareExpiryTime(entry1, entry2);
- *     if (val < 0) {
- *         // entry1 has a lower ExpiryTime, or the same ExpiryTime as entry2
- * and a different message. } else if (val > 0) {
- *         // entry2 has a lower ExpiryTime, or the same ExpiryTime as entry1
- * and a different message. } else {
- *         // entry1 and entry2 have the same ExpiryTime AND the same message.
- *     }
- *
- *     contentStoreEntry_Release(&entry1);
- *     contentStoreEntry_Release(&entry2);
- *
- * }
- * @endcode
- */
-int contentStoreEntry_CompareExpiryTime(const ContentStoreEntry *storeEntry1,
-                                        const ContentStoreEntry *storeEntry2);
-
-/**
- * Move this entry to the head of the LRU list
- *
- * Moves the entry to the head of the LRU list it was created with
- *
- * @param [in] storeEntry An allocated ContenstoreEntry
- */
-void contentStoreEntry_MoveToHead(ContentStoreEntry *storeEntry);
-#endif  // contentStoreEntry_h
diff --git a/hicn-light/src/hicn/content_store/contentStoreInterface.c b/hicn-light/src/hicn/content_store/contentStoreInterface.c
deleted file mode 100644
index 2f5ddb8c2..000000000
--- a/hicn-light/src/hicn/content_store/contentStoreInterface.c
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <hicn/content_store/contentStoreInterface.h>
-
-void contentStoreInterface_Release(ContentStoreInterface **storeImplPtr) {
-  (*storeImplPtr)->release(storeImplPtr);
-}
-
-bool contentStoreInterface_PutContent(ContentStoreInterface *storeImpl,
-                                      Message *content,
-                                      uint64_t currentTimeTicks) {
-  return storeImpl->putContent(storeImpl, content, currentTimeTicks);
-}
-
-bool contentStoreInterface_RemoveContent(ContentStoreInterface *storeImpl,
-                                         Message *content) {
-  return storeImpl->removeContent(storeImpl, content);
-}
-
-Message *contentStoreInterface_MatchInterest(ContentStoreInterface *storeImpl,
-                                             Message *interest,
-                                             uint64_t currentTimeTicks) {
-  return storeImpl->matchInterest(storeImpl, interest, currentTimeTicks);
-}
-
-size_t contentStoreInterface_GetObjectCapacity(
-    ContentStoreInterface *storeImpl) {
-  return storeImpl->getObjectCapacity(storeImpl);
-}
-
-size_t contentStoreInterface_GetObjectCount(ContentStoreInterface *storeImpl) {
-  return storeImpl->getObjectCount(storeImpl);
-}
-
-void contentStoreInterface_Log(ContentStoreInterface *storeImpl) {
-  storeImpl->log(storeImpl);
-}
-
-void *contentStoreInterface_GetPrivateData(ContentStoreInterface *storeImpl) {
-  return storeImpl->_privateData;
-}
diff --git a/hicn-light/src/hicn/content_store/contentStoreInterface.h b/hicn-light/src/hicn/content_store/contentStoreInterface.h
deleted file mode 100644
index b2bc3f919..000000000
--- a/hicn-light/src/hicn/content_store/contentStoreInterface.h
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * 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 contentStoreInterface_h
-#define contentStoreInterface_h
-
-#include <stdio.h>
-
-#include <hicn/core/message.h>
-
-typedef struct contentstore_config {
-  size_t objectCapacity;
-} ContentStoreConfig;
-
-typedef struct contentstore_interface ContentStoreInterface;
-
-struct contentstore_interface {
-  /**
-   * Place a Message representing a ContentObject into the ContentStore. If
-   * necessary to make room, remove expired content or content that has exceeded
-   * the Recommended Cache Time.
-   *
-   * @param storeImpl - a pointer to this ContentStoreInterface instance.
-   * @param content - a pointer to a `Message` to place in the store.
-   * @param currentTimeTicks - the current time, in hicn-light ticks, since the
-   * UTC epoch.
-   */
-  bool (*putContent)(ContentStoreInterface *storeImpl, Message *content,
-                     uint64_t currentTimeTicks);
-
-  /**
-   * The function to call to remove content from the ContentStore.
-   * It will Release any references that were created when the content was
-   * placed into the ContentStore.
-   *
-   * @param storeImpl - a pointer to this ContentStoreInterface instance.
-   * @param content - a pointer to a `Message` to remove from the store.
-   */
-  bool (*removeContent)(ContentStoreInterface *storeImpl, Message *content);
-
-  /**
-   * Given a Message that represents and Interest, try to find a matching
-   * ContentObject.
-   *
-   * @param storeImpl - a pointer to this ContentStoreInterface instance.
-   * @param interest - a pointer to a `Message` representing the Interest to
-   * match.
-   *
-   * @return a pointer to a Message containing the matching ContentObject
-   * @return NULL if no matching ContentObject was found
-   */
-  Message *(*matchInterest)(ContentStoreInterface *storeImpl, Message *interest,
-                            uint64_t currentTimeTicks);
-
-  /**
-   * Return the maximum number of ContentObjects that can be stored in this
-   * ContentStore. This is a raw count, not based on memory size.
-   *
-   * @param storeImpl - a pointer to this ContentStoreInterface instance.
-   *
-   * @return the maximum number of ContentObjects that can be stored
-   */
-  size_t (*getObjectCapacity)(ContentStoreInterface *storeImpl);
-
-  /**
-   * Return the number of ContentObjects currently stored in the ContentStore.
-   *
-   * @param storeImpl - a pointer to this ContentStoreInterface instance.
-   *
-   * @return the current number of ContentObjects in the ContentStore
-   */
-  size_t (*getObjectCount)(ContentStoreInterface *storeImpl);
-
-  /**
-   * Log a ContentStore implementation specific version of store-related
-   * information.
-   *
-   * @param storeImpl - a pointer to this ContentStoreInterface instance.
-   */
-  void (*log)(ContentStoreInterface *storeImpl);
-
-  /**
-   * Acquire a new reference to the specified ContentStore instance. This
-   * reference will eventually need to be released by calling {@link
-   * contentStoreInterface_Release}.
-   *
-   * @param storeImpl - a pointer to this ContentStoreInterface instance.
-   */
-  ContentStoreInterface *(*acquire)(const ContentStoreInterface *storeImpl);
-
-  /**
-   * Release the ContentStore, which will also Release any references held by
-   * it.
-   *
-   * @param storeImpl - a pointer to this ContentStoreInterface instance.
-   */
-  void (*release)(ContentStoreInterface **storeImpl);
-
-  /**
-   * A pointer to opaque private data used by the ContentStore instance
-   * represented by this instance of ContentStoreInterface.
-   */
-  void *_privateData;
-};
-
-/**
- * Place a Message representing a ContentObject into the ContentStore. If
- * necessary to make room, remove expired content or content that has exceeded
- * the Recommended Cache Time.
- *
- * @param storeImpl - a pointer to this ContentStoreInterface instance.
- * @param content - a pointer to a `Message` to place in the store.
- *
- * @param currentTimeTicks - the current time, in hicn-light ticks, since the
- * UTC epoch.
- */
-bool contentStoreInterface_PutContent(ContentStoreInterface *storeImpl,
-                                      Message *content,
-                                      uint64_t currentTimeTicks);
-
-/**
- * The function to call to remove content from the ContentStore.
- * It will Release any references that were created when the content was placed
- * into the ContentStore.
- *
- * @param storeImpl - a pointer to this ContentStoreInterface instance.
- * @param content - a pointer to a `Message` to remove from the store.
- */
-bool contentStoreInterface_RemoveContent(ContentStoreInterface *storeImpl,
-                                         Message *content);
-
-/**
- * Given a Message that represents and Interest, try to find a matching
- * ContentObject.
- *
- * @param storeImpl - a pointer to this ContentStoreInterface instance.
- * @param interest - a pointer to a `Message` representing the Interest to
- * match.
- *
- * @return a pointer to a Message containing the matching ContentObject
- * @return NULL if no matching ContentObject was found
- */
-Message *contentStoreInterface_MatchInterest(ContentStoreInterface *storeImpl,
-                                             Message *interest,
-                                             uint64_t currentTimeTicks);
-
-/**
- * Return the maximum number of ContentObjects that can be stored in this
- * ContentStore. This is a raw count, not based on memory size.
- *
- * @param storeImpl - a pointer to this ContentStoreInterface instance.
- *
- * @return the maximum number of ContentObjects that can be stored
- */
-size_t contentStoreInterface_GetObjectCapacity(
-    ContentStoreInterface *storeImpl);
-
-/**
- * Return the number of ContentObjects currently stored in the ContentStore.
- *
- * @param storeImpl - a pointer to this ContentStoreInterface instance.
- *
- * @return the current number of ContentObjects in the ContentStore
- */
-size_t contentStoreInterface_GetObjectCount(ContentStoreInterface *storeImpl);
-
-/**
- * Loga ContentStore implementation specific version of store-related
- * information.
- *
- * @param storeImpl - a pointer to this ContentStoreInterface instance.
- */
-void contentStoreInterface_Log(ContentStoreInterface *storeImpl);
-
-/**
- * Acquire a new reference to the specified ContentStore instance. This
- * reference will eventually need to be released by calling {@link
- * contentStoreInterface_Release}.
- *
- * @param storeImpl - a pointer to this ContentStoreInterface instance.
- */
-ContentStoreInterface *contentStoreInterface_Aquire(
-    const ContentStoreInterface *storeImpl);
-
-/**
- * Release the ContentStore, which will also Release any references held by it.
- *
- * @param storeImpl - a pointer to this ContentStoreInterface instance.
- */
-void contentStoreInterface_Release(ContentStoreInterface **storeImplPtr);
-
-/**
- * Return a pointer to the data private to this implementation of the
- * ContentStore interface.
- *
- * @param storeImpl - a pointer to this ContentStoreInterface instance.
- */
-void *contentStoreInterface_GetPrivateData(ContentStoreInterface *storeImpl);
-#endif  // contentStoreInterface_h
diff --git a/hicn-light/src/hicn/content_store/contentStoreLRU.c b/hicn-light/src/hicn/content_store/contentStoreLRU.c
deleted file mode 100644
index 76a2c8659..000000000
--- a/hicn-light/src/hicn/content_store/contentStoreLRU.c
+++ /dev/null
@@ -1,462 +0,0 @@
-/*
- * 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 _WIN32
-#include <sys/queue.h>
-#endif
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_DisplayIndented.h>
-#include <parc/algol/parc_HashCodeTable.h>
-#include <parc/algol/parc_Object.h>
-
-#include <hicn/core/logger.h>
-
-#include <hicn/content_store/contentStoreLRU.h>
-
-#include <hicn/content_store/contentStoreEntry.h>
-#include <hicn/content_store/contentStoreInterface.h>
-#include <hicn/content_store/listLRU.h>
-#include <hicn/content_store/listTimeOrdered.h>
-
-#include <parc/assert/parc_Assert.h>
-#include <hicn/processor/hashTableFunction.h>
-
-typedef struct contentstore_stats {
-  uint64_t countExpiryEvictions;
-  uint64_t countRCTEvictions;
-  uint64_t countLruEvictions;
-  uint64_t countAdds;
-  uint64_t countHits;
-  uint64_t countMisses;
-} _ContentStoreLRUStats;
-
-typedef struct contentstore_lru_data {
-  size_t objectCapacity;
-  size_t objectCount;
-
-  Logger *logger;
-
-  // This LRU is just for keeping track of insertion and access order.
-  ListLru *lru;
-
-  ListTimeOrdered *indexByExpirationTime;
-
-  PARCHashCodeTable *storageByName;
-
-  _ContentStoreLRUStats stats;
-} _ContentStoreLRU;
-
-static void _destroyIndexes(_ContentStoreLRU *store) {
-  if (store->indexByExpirationTime != NULL) {
-    listTimeOrdered_Release(&(store->indexByExpirationTime));
-  }
-
-  if (store->storageByName != NULL) {
-    parcHashCodeTable_Destroy(&(store->storageByName));
-  }
-
-  if (store->lru != NULL) {
-    listLRU_Destroy(&(store->lru));
-  }
-}
-
-static void _contentStoreInterface_Destroy(
-    ContentStoreInterface **storeImplPtr) {
-  _ContentStoreLRU *store = contentStoreInterface_GetPrivateData(*storeImplPtr);
-
-  parcObject_Release((PARCObject **)&store);
-}
-
-static bool _contentStoreLRU_Destructor(_ContentStoreLRU **storePtr) {
-  _ContentStoreLRU *store = *storePtr;
-
-  _destroyIndexes(store);
-  logger_Release(&store->logger);
-
-  return true;
-}
-
-parcObject_Override(_ContentStoreLRU, PARCObject,
-                    .destructor = (PARCObjectDestructor *)
-                        _contentStoreLRU_Destructor);
-
-parcObject_ExtendPARCObject(ContentStoreInterface,
-                            _contentStoreInterface_Destroy, NULL, NULL, NULL,
-                            NULL, NULL, NULL);
-
-static parcObject_ImplementAcquire(_contentStoreLRU, ContentStoreInterface);
-static parcObject_ImplementRelease(_contentStoreLRU, ContentStoreInterface);
-
-static void _hashTableFunction_ContentStoreEntryDestroyer(void **dataPtr) {
-  contentStoreEntry_Release((ContentStoreEntry **)dataPtr);
-}
-
-static bool _contentStoreLRU_Init(_ContentStoreLRU *store,
-                                  ContentStoreConfig *config, Logger *logger) {
-  bool result = false;
-
-  store->logger = logger_Acquire(logger);
-
-  size_t initialSize = config->objectCapacity * 2;
-  memset(&store->stats, 0, sizeof(_ContentStoreLRUStats));
-
-  store->objectCapacity = config->objectCapacity;
-  store->objectCount = 0;
-
-  // initial size must be at least 1 or else the data structures break.
-  initialSize = (initialSize == 0) ? 1 : initialSize;
-
-  store->indexByExpirationTime = listTimeOrdered_Create(
-      (TimeOrderList_KeyCompare *)contentStoreEntry_CompareExpiryTime);
-
-  store->storageByName = parcHashCodeTable_Create_Size(
-      hashTableFunction_MessageNameEquals,
-      hashTableFunction_MessageNameHashCode, NULL,
-      _hashTableFunction_ContentStoreEntryDestroyer, initialSize);
-
-  store->lru = listLRU_Create();
-
-  // If any of the index tables couldn't be allocated, we can't continue.
-  if ((store->indexByExpirationTime == NULL) ||
-      (store->storageByName == NULL) || (store->lru == NULL)) {
-    if (logger_IsLoggable(store->logger, LoggerFacility_Processor,
-                          PARCLogLevel_Error)) {
-      logger_Log(store->logger, LoggerFacility_Processor, PARCLogLevel_Error,
-                 __func__,
-                 "ContentStoreLRU could not be created. Could not allocate all "
-                 "index tables.",
-                 (void *)store, store->objectCapacity);
-    }
-
-    _destroyIndexes(store);
-    result = false;
-  } else {
-    result = true;
-  }
-  return result;
-}
-
-/**
- * Remove a ContentStoreEntry from all tables and indices.
- */
-static void _contentStoreLRU_PurgeStoreEntry(_ContentStoreLRU *store,
-                                             ContentStoreEntry *entryToPurge) {
-  if (contentStoreEntry_HasExpiryTimeTicks(entryToPurge)) {
-    listTimeOrdered_Remove(store->indexByExpirationTime, entryToPurge);
-  }
-
-  Message *content = contentStoreEntry_GetMessage(entryToPurge);
-
-  // This _Del call will call the Release/Destroy on the ContentStoreEntry,
-  // which will remove it from the LRU as well.
-  parcHashCodeTable_Del(store->storageByName, content);
-
-  store->objectCount--;
-}
-
-static bool _contentStoreLRU_RemoveLeastUsed(_ContentStoreLRU *store) {
-  bool result = false;
-
-  if (store->objectCount > 0) {
-    ListLruEntry *lruEntry = listLRU_PopTail(store->lru);
-    ContentStoreEntry *storeEntry =
-        (ContentStoreEntry *)listLRU_EntryGetData(lruEntry);
-
-    if (logger_IsLoggable(store->logger, LoggerFacility_Processor,
-                          PARCLogLevel_Debug)) {
-      logger_Log(
-          store->logger, LoggerFacility_Processor, PARCLogLevel_Debug, __func__,
-          "ContentStore %p evict message %p by LRU (LRU evictions %" PRIu64 ")",
-          (void *)store, (void *)contentStoreEntry_GetMessage(storeEntry),
-          store->stats.countLruEvictions);
-    }
-
-    _contentStoreLRU_PurgeStoreEntry(store, storeEntry);
-
-    result = true;
-  }
-  return result;
-}
-
-static void _evictByStorePolicy(_ContentStoreLRU *store,
-                                uint64_t currentTimeInTicks) {
-  // We need to make room. Here's the plan:
-  //  1) Check to see if anything has expired. If so, remove it and we're done.
-  //  If not, 2) Remove the least recently used item.
-
-  ContentStoreEntry *entry =
-      listTimeOrdered_GetOldest(store->indexByExpirationTime);
-  if (entry && contentStoreEntry_HasExpiryTimeTicks(entry) &&
-      (currentTimeInTicks > contentStoreEntry_GetExpiryTimeTicks(entry))) {
-    // Found an expired entry. Remove it, and we're done.
-
-    store->stats.countExpiryEvictions++;
-    if (logger_IsLoggable(store->logger, LoggerFacility_Processor,
-                          PARCLogLevel_Debug)) {
-      logger_Log(store->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-                 __func__,
-                 "ContentStore %p evict message %p by ExpiryTime (ExpiryTime "
-                 "evictions %" PRIu64 ")",
-                 (void *)store, (void *)contentStoreEntry_GetMessage(entry),
-                 store->stats.countExpiryEvictions);
-    }
-
-    _contentStoreLRU_PurgeStoreEntry(store, entry);
-  } else {
-    store->stats.countLruEvictions++;
-    _contentStoreLRU_RemoveLeastUsed(store);
-  }
-}
-
-static bool _contentStoreLRU_PutContent(ContentStoreInterface *storeImpl,
-                                        Message *content,
-                                        uint64_t currentTimeTicks)
-
-{
-  bool result = false;
-  _ContentStoreLRU *store =
-      (_ContentStoreLRU *)contentStoreInterface_GetPrivateData(storeImpl);
-  parcAssertNotNull(store, "Parameter store must be non-null");
-  parcAssertNotNull(content, "Parameter objectMessage must be non-null");
-
-  parcAssertTrue(message_GetType(content) == MessagePacketType_ContentObject,
-                 "Parameter objectMessage must be a Content Object");
-
-  if (store->objectCapacity == 0) {
-    return false;
-  }
-
-  ContentStoreEntry *storeEntry = parcHashCodeTable_Get(store->storageByName, content);
-  if(storeEntry){
-    _contentStoreLRU_PurgeStoreEntry(store, storeEntry);
-  }
-
-  uint64_t expiryTimeTicks = contentStoreEntry_MaxExpiryTime;
-
-  if (message_HasContentExpiryTime(content)) {
-    expiryTimeTicks = message_GetContentExpiryTimeTicks(content);
-  }
-  // Don't add anything that's already expired or has exceeded RCT.
-  if (currentTimeTicks >= expiryTimeTicks) {
-    return false;
-  }
-
-  if (store->objectCount >= store->objectCapacity) {
-    // Store is full. Need to make room.
-    _evictByStorePolicy(store, currentTimeTicks);
-  }
-
-  // And now add a new entry to the head of the LRU.
-
-  ContentStoreEntry *entry = contentStoreEntry_Create(content, store->lru);
-
-  if (entry != NULL) {
-    if (parcHashCodeTable_Add(store->storageByName, content, entry)) {
-      if (contentStoreEntry_HasExpiryTimeTicks(entry)) {
-        listTimeOrdered_Add(store->indexByExpirationTime, entry);
-      }
-
-      store->objectCount++;
-      store->stats.countAdds++;
-
-      if (logger_IsLoggable(store->logger, LoggerFacility_Processor,
-                            PARCLogLevel_Debug)) {
-        logger_Log(store->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-                   __func__,
-                   "ContentStoreLRU %p saved message %p (object count %" PRIu64
-                   ")",
-                   (void *)store, (void *)content, store->objectCount);
-      }
-
-      result = true;
-    } else {
-      // Free what we just created, but did not add. 'entry' has ownership of
-      // 'copy', and so will call _Release() on it
-      contentStoreEntry_Release(&entry);
-
-      if (logger_IsLoggable(store->logger, LoggerFacility_Processor,
-                            PARCLogLevel_Warning)) {
-        logger_Log(store->logger, LoggerFacility_Processor,
-                   PARCLogLevel_Warning, __func__,
-                   "ContentStoreLRU %p failed to add message %p to hash table",
-                   (void *)store, (void *)content);
-      }
-    }
-  }
-
-  return result;
-}
-
-static Message *_contentStoreLRU_MatchInterest(ContentStoreInterface *storeImpl,
-                                               Message *interest,
-                                               uint64_t currentTimeTicks) {
-  Message *result = NULL;
-
-  _ContentStoreLRU *store =
-      (_ContentStoreLRU *)contentStoreInterface_GetPrivateData(storeImpl);
-
-  parcAssertNotNull(store, "Parameter store must be non-null");
-  parcAssertNotNull(interest, "Parameter interestMessage must be non-null");
-  parcAssertTrue(message_GetType(interest) == MessagePacketType_Interest,
-                 "Parameter interestMessage must be an Interest");
-
-  PARCHashCodeTable *table;
-  table = store->storageByName;
-
-  ContentStoreEntry *storeEntry = parcHashCodeTable_Get(table, interest);
-
-  bool foundEntry = false;
-
-  if (storeEntry) {
-    if (contentStoreEntry_HasExpiryTimeTicks(storeEntry) &&
-        contentStoreEntry_GetExpiryTimeTicks(storeEntry) < currentTimeTicks) {
-      // the entry is expired, we can remove it
-      _contentStoreLRU_PurgeStoreEntry(store, storeEntry);
-    } else {
-      foundEntry = true;
-    }
-  }
-
-  if (foundEntry) {
-    contentStoreEntry_MoveToHead(storeEntry);
-    result = contentStoreEntry_GetMessage(storeEntry);
-
-    store->stats.countHits++;
-
-    if (logger_IsLoggable(store->logger, LoggerFacility_Processor,
-                          PARCLogLevel_Debug)) {
-      logger_Log(store->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-                 __func__,
-                 "ContentStoreLRU %p matched interest %p (hits %" PRIu64
-                 ", misses %" PRIu64 ")",
-                 (void *)store, (void *)interest, store->stats.countHits,
-                 store->stats.countMisses);
-    }
-  } else {
-    store->stats.countMisses++;
-
-    if (logger_IsLoggable(store->logger, LoggerFacility_Processor,
-                          PARCLogLevel_Debug)) {
-      logger_Log(store->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-                 __func__,
-                 "ContentStoreLRU %p missed interest %p (hits %" PRIu64
-                 ", misses %" PRIu64 ")",
-                 (void *)store, (void *)interest, store->stats.countHits,
-                 store->stats.countMisses);
-    }
-  }
-
-  return result;
-}
-
-static bool _contentStoreLRU_RemoveContent(ContentStoreInterface *storeImpl,
-                                           Message *content) {
-  bool result = false;
-  _ContentStoreLRU *store =
-      (_ContentStoreLRU *)contentStoreInterface_GetPrivateData(storeImpl);
-
-  ContentStoreEntry *storeEntry =
-      parcHashCodeTable_Get(store->storageByName, content);
-
-  if (storeEntry != NULL) {
-    _contentStoreLRU_PurgeStoreEntry(store, storeEntry);
-    result = true;
-  }
-
-  return result;
-}
-
-static void _contentStoreLRU_Log(ContentStoreInterface *storeImpl) {
-  _ContentStoreLRU *store =
-      (_ContentStoreLRU *)contentStoreInterface_GetPrivateData(storeImpl);
-
-  logger_Log(store->logger, LoggerFacility_Processor, PARCLogLevel_All,
-             __func__,
-             "ContentStoreLRU @%p {count = %zu, capacity = %zu {"
-             "stats = @%p {adds = %" PRIu64 ", hits = %" PRIu64
-             ", misses = %" PRIu64 ", LRUEvictons = %" PRIu64
-             ", ExpiryEvictions = %" PRIu64 ", RCTEvictions = %" PRIu64 "} }",
-             store, store->objectCount, store->objectCapacity, &store->stats,
-             store->stats.countAdds, store->stats.countHits,
-             store->stats.countMisses, store->stats.countLruEvictions,
-             store->stats.countExpiryEvictions, store->stats.countRCTEvictions);
-}
-
-static size_t _contentStoreLRU_GetObjectCapacity(
-    ContentStoreInterface *storeImpl) {
-  _ContentStoreLRU *store =
-      (_ContentStoreLRU *)contentStoreInterface_GetPrivateData(storeImpl);
-  return store->objectCapacity;
-}
-
-static size_t _contentStoreLRU_GetObjectCount(
-    ContentStoreInterface *storeImpl) {
-  _ContentStoreLRU *store =
-      (_ContentStoreLRU *)contentStoreInterface_GetPrivateData(storeImpl);
-  return store->objectCount;
-}
-
-static size_t _contentStoreLRU_SetObjectCapacity(
-    ContentStoreInterface *storeImpl, size_t newCapacity) {
-  _ContentStoreLRU *store =
-      (_ContentStoreLRU *)contentStoreInterface_GetPrivateData(storeImpl);
-  return store->objectCapacity = newCapacity;
-}
-
-ContentStoreInterface *contentStoreLRU_Create(ContentStoreConfig *config,
-                                              Logger *logger) {
-  ContentStoreInterface *storeImpl = NULL;
-
-  parcAssertNotNull(logger, "ContentStoreLRU requires a non-NULL logger");
-
-  storeImpl = parcObject_CreateAndClearInstance(ContentStoreInterface);
-
-  if (storeImpl != NULL) {
-    storeImpl->_privateData =
-        parcObject_CreateAndClearInstance(_ContentStoreLRU);
-
-    if (_contentStoreLRU_Init(storeImpl->_privateData, config, logger)) {
-      storeImpl->putContent = &_contentStoreLRU_PutContent;
-      storeImpl->removeContent = &_contentStoreLRU_RemoveContent;
-
-      storeImpl->matchInterest = &_contentStoreLRU_MatchInterest;
-
-      storeImpl->getObjectCount = &_contentStoreLRU_GetObjectCount;
-      storeImpl->getObjectCapacity = &_contentStoreLRU_GetObjectCapacity;
-
-      storeImpl->log = &_contentStoreLRU_Log;
-
-      storeImpl->acquire = &_contentStoreLRU_Acquire;
-      storeImpl->release = &_contentStoreLRU_Release;
-
-      // Initialize from the config passed to us.
-      _contentStoreLRU_SetObjectCapacity(storeImpl, config->objectCapacity);
-
-      if (logger_IsLoggable(logger, LoggerFacility_Processor,
-                            PARCLogLevel_Info)) {
-        logger_Log(logger, LoggerFacility_Processor, PARCLogLevel_Info,
-                   __func__, "ContentStoreLRU %p created with capacity %zu",
-                   (void *)storeImpl,
-                   contentStoreInterface_GetObjectCapacity(storeImpl));
-      }
-    }
-  } else {
-    parcObject_Release((void **)&storeImpl);
-  }
-
-  return storeImpl;
-}
diff --git a/hicn-light/src/hicn/content_store/contentStoreLRU.h b/hicn-light/src/hicn/content_store/contentStoreLRU.h
deleted file mode 100644
index 94ec4d6b2..000000000
--- a/hicn-light/src/hicn/content_store/contentStoreLRU.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * 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 contentStoreLRU_h
-#define contentStoreLRU_h
-
-#include <hicn/content_store/contentStoreInterface.h>
-#include <hicn/core/logger.h>
-#include <stdio.h>
-
-/**
- * Create and Initialize an instance of contentStoreLRU. A newly allocated
- * {@link ContentStoreInterface} object is initialized and returned. It must
- * eventually be released by calling {@link contentStoreInterface_Release}.
- *
- *
- * @param config An instance of `ContentStoreConfig`, specifying options to be
- * applied by the underlying contentStoreLRU instance.
- * @param logger An instance of a {@link Logger} to use for logging content
- * store events.
- *
- * @return a newly created contentStoreLRU instance.
- *
- */
-ContentStoreInterface *contentStoreLRU_Create(ContentStoreConfig *config,
-                                              Logger *logger);
-#endif  // contentStoreLRU_h
diff --git a/hicn-light/src/hicn/content_store/listLRU.c b/hicn-light/src/hicn/content_store/listLRU.c
deleted file mode 100644
index 242af4078..000000000
--- a/hicn-light/src/hicn/content_store/listLRU.c
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * 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 _WIN32
-#include <sys/queue.h>
-#endif
-#include <hicn/hicn-light/config.h>
-#include <stdbool.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/content_store/listLRU.h>
-
-struct list_lru_entry {
-  void *userData;
-
-  // always set to the list
-  ListLru *parentList;
-
-  // indicates if the Entry is currently in the list
-  bool inList;
-
-  TAILQ_ENTRY(list_lru_entry) list;
-};
-
-// this defines the TAILQ structure so we can access the tail pointer
-TAILQ_HEAD(lru_s, list_lru_entry);
-
-struct list_lru {
-  struct lru_s head;
-  size_t itemsInList;
-};
-
-void listLRU_EntryDestroy(ListLruEntry **entryPtr) {
-  parcAssertNotNull(entryPtr,
-                    "Parameter entryPtr must be non-null double pointer");
-
-  ListLruEntry *entry = *entryPtr;
-  if (entry->inList) {
-    TAILQ_REMOVE(&entry->parentList->head, entry, list);
-    parcAssertTrue(
-        entry->parentList->itemsInList > 0,
-        "Invalid state, removed entry from list, but itemsInList is 0");
-    entry->parentList->itemsInList--;
-  }
-
-  parcMemory_Deallocate((void **)&entry);
-  *entryPtr = NULL;
-}
-
-void listLRU_EntryMoveToHead(ListLruEntry *entry) {
-  parcAssertNotNull(entry, "Parameter entry must be non-null");
-
-  TAILQ_REMOVE(&entry->parentList->head, entry, list);
-  TAILQ_INSERT_HEAD(&entry->parentList->head, entry, list);
-}
-
-void *listLRU_EntryGetData(ListLruEntry *entry) { return entry->userData; }
-
-ListLru *listLRU_Create() {
-  ListLru *list = parcMemory_AllocateAndClear(sizeof(ListLru));
-  parcAssertNotNull(list, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(ListLru));
-  list->itemsInList = 0;
-  TAILQ_INIT(&list->head);
-  return list;
-}
-
-void listLRU_Destroy(ListLru **lruPtr) {
-  parcAssertNotNull(lruPtr, "Parameter lruPtr must be non-null double pointer");
-
-  ListLru *lru = *lruPtr;
-
-  ListLruEntry *entry = TAILQ_FIRST(&lru->head);
-  while (entry != NULL) {
-    ListLruEntry *next = TAILQ_NEXT(entry, list);
-    listLRU_EntryDestroy(&entry);
-    entry = next;
-  }
-
-  parcMemory_Deallocate((void **)&lru);
-  *lruPtr = NULL;
-}
-
-ListLruEntry *listLRU_NewHeadEntry(ListLru *lru, void *data) {
-  parcAssertNotNull(lru, "Parameter lru must be non-null");
-  parcAssertNotNull(data, "Parameter data must be non-null");
-
-  ListLruEntry *entry = parcMemory_AllocateAndClear(sizeof(ListLruEntry));
-  parcAssertNotNull(entry, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(ListLruEntry));
-  entry->userData = data;
-  entry->parentList = lru;
-  entry->inList = true;
-
-  TAILQ_INSERT_HEAD(&lru->head, entry, list);
-  lru->itemsInList++;
-
-  return entry;
-}
-
-ListLruEntry *listLRU_PopTail(ListLru *lru) {
-  parcAssertNotNull(lru, "Parameter lru must be non-null");
-
-  ListLruEntry *entry = TAILQ_LAST(&lru->head, lru_s);
-
-  if (entry) {
-    parcAssertTrue(
-        lru->itemsInList > 0,
-        "Invalid state, removed entry from list, but itemsInList is 0");
-    lru->itemsInList--;
-    TAILQ_REMOVE(&lru->head, entry, list);
-    entry->inList = false;
-  }
-
-  return entry;
-}
-
-size_t listLRU_Length(const ListLru *lru) {
-  parcAssertNotNull(lru, "Parameter lru must be non-null");
-  return lru->itemsInList;
-}
diff --git a/hicn-light/src/hicn/content_store/listLRU.h b/hicn-light/src/hicn/content_store/listLRU.h
deleted file mode 100644
index 75f698b61..000000000
--- a/hicn-light/src/hicn/content_store/listLRU.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * 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 listLRU.h
- * @brief Maintains an LRU for the content store
- *
- * An LRU list is make up of LRU entries.  The entries are bound to the list.
- * The user of the list is reponsible for knowing when there's too many things
- * and wants to remove one.  The LRU list will grow without bound otherwise.
- *
- * The LRU list is meant to be used as an auxiliary data structure, not the
- * primary storage of data elements.
- *
- */
-
-#ifndef listLRU_h
-#define listLRU_h
-
-struct list_lru_entry;
-typedef struct list_lru_entry ListLruEntry;
-
-struct list_lru;
-typedef struct list_lru ListLru;
-
-/**
- * @function lruEntry_Destroy
- * @abstract Destroys and element.  This will also remove it from the list.
- */
-void listLRU_EntryDestroy(ListLruEntry **entryPtr);
-
-/**
- * @function listLRU_EntryMoveToHead
- * @abstract move an element to head
- */
-void listLRU_EntryMoveToHead(ListLruEntry *entry);
-
-/**
- * @function lruEntry_GetData
- * @abstract Returns the user-supplied opaque data when the entry was created
- */
-void *listLRU_EntryGetData(ListLruEntry *entry);
-
-/**
- * @function listLRU_Create
- * @abstract Creates a new Least-Recently-Used list
- */
-ListLru *listLRU_Create();
-
-/**
- * @function listLRU_Destroy
- * @abstract Destroys a list and frees all the elements in it
- */
-void listLRU_Destroy(ListLru **listPtr);
-
-/**
- * Returns the number of items in the list
- *
- * @param [in] lru An allocated ListLru
- * @retval number The number of items in the LRU list
- */
-size_t listLRU_Length(const ListLru *lru);
-
-/**
- * @function listLRU_NewHeadEntry
- * @abstract Creates a new entry for the list.  It is inserted at the head of
- * the list.
- */
-ListLruEntry *listLRU_NewHeadEntry(ListLru *lru, void *data);
-
-/**
- * @function listLRU_PopTail
- * @abstract Removes the tail element from the list and returns it to the user
- * @discussion
- *   Pops the tail element.  The user should examine its data to destroy their
- *   tail object, then call <code>LruEntry_Destroy()</code> to free the
- *   LRU entry.
- *
- * @return The tail element, or NULL for an empty list
- */
-ListLruEntry *listLRU_PopTail(ListLru *list);
-#endif  // listLRU_h
diff --git a/hicn-light/src/hicn/content_store/listTimeOrdered.c b/hicn-light/src/hicn/content_store/listTimeOrdered.c
deleted file mode 100644
index 690c6e412..000000000
--- a/hicn-light/src/hicn/content_store/listTimeOrdered.c
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * 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 <parc/assert/parc_Assert.h>
-#include <hicn/hicn-light/config.h>
-#include <hicn/content_store/listTimeOrdered.h>
-
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_TreeRedBlack.h>
-
-/**
- * A list of ContentStoreEntrys, kept in sorted order by time. The ordering is
- * calculated by a key compare function (e.g. {@link TimeOrderList_KeyCompare}),
- * passed in.
- *
- * This container does not hold references to the objects that it contains. In
- * other words, it does not Acquire() the Messages that are placed in it. That
- * reference count is managed by the owning ContentStore. This is purely an
- * index, and provides an easy to way index Messages based on a specified time
- * value. Typically, that would be the Expiration Time.
- *
- * It maintains a tree, sorted by the time values passed in to the Add()
- * function. It does not manage capacity, and can grow uncontrollably if the
- * owning ContentStore does not manage it. Items are indexed first by time, then
- * address of the Message (just as a distringuishing attribute). This allows us
- * to store multiple items with the same expiration time.
- */
-
-struct list_timeordered {
-  PARCTreeRedBlack *timeOrderedTree;
-};
-
-static void _finalRelease(ListTimeOrdered **listP) {
-  ListTimeOrdered *list = *listP;
-  parcTreeRedBlack_Destroy(&list->timeOrderedTree);
-}
-
-parcObject_ExtendPARCObject(ListTimeOrdered, _finalRelease, NULL, NULL, NULL,
-                            NULL, NULL, NULL);
-
-parcObject_ImplementAcquire(listTimeOrdered, ListTimeOrdered);
-
-parcObject_ImplementRelease(listTimeOrdered, ListTimeOrdered);
-
-ListTimeOrdered *listTimeOrdered_Create(
-    TimeOrderList_KeyCompare *keyCompareFunction) {
-  ListTimeOrdered *result = parcObject_CreateInstance(ListTimeOrdered);
-  if (NULL != result) {
-    result->timeOrderedTree =
-        parcTreeRedBlack_Create(keyCompareFunction,  // keyCompare
-                                NULL,                // keyFree
-                                NULL,                // keyCopy
-                                NULL,                // valueEquals
-                                NULL,                // valueFree
-                                NULL);               // valueCopy
-  }
-  return result;
-}
-
-void listTimeOrdered_Add(ListTimeOrdered *list, ContentStoreEntry *entry) {
-  parcTreeRedBlack_Insert(list->timeOrderedTree, entry, entry);
-}
-
-ContentStoreEntry *listTimeOrdered_GetOldest(ListTimeOrdered *list) {
-  return parcTreeRedBlack_FirstKey(list->timeOrderedTree);
-}
-
-bool listTimeOrdered_Remove(ListTimeOrdered *list,
-                            ContentStoreEntry *storeEntry) {
-  bool result = false;
-
-  ContentStoreEntry *entry = (ContentStoreEntry *)parcTreeRedBlack_Remove(
-      list->timeOrderedTree, storeEntry);
-  if (entry != NULL) {
-    result = true;
-  }
-  return result;
-}
-
-size_t listTimeOrdered_Length(ListTimeOrdered *list) {
-  return (size_t)parcTreeRedBlack_Size(list->timeOrderedTree);
-}
diff --git a/hicn-light/src/hicn/content_store/listTimeOrdered.h b/hicn-light/src/hicn/content_store/listTimeOrdered.h
deleted file mode 100644
index 325e7c0d4..000000000
--- a/hicn-light/src/hicn/content_store/listTimeOrdered.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * 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 listTimeOrdered_h
-#define listTimeOrdered_h
-
-#include <parc/algol/parc_TreeRedBlack.h>
-#include <hicn/content_store/contentStoreEntry.h>
-#include <hicn/core/message.h>
-#include <stdio.h>
-
-struct list_timeordered;
-typedef struct list_timeordered ListTimeOrdered;
-
-/**
- * A signum function that takes two instances of ContentStoreEntrys and
- * returns a value based on their relative values.
- */
-typedef PARCTreeRedBlack_KeyCompare TimeOrderList_KeyCompare;
-
-/**
- * Create a new instance of `ListTimeOrdered` that will maintain the order of
- * its list items using the supplied `keyCompareFunction`.
- *
- * The newly created `ListTimeOrdered` must eventually be released by calling
- * {@link listTimeOrdered_Release}.
- *
- * @param keyCompareFunction the signum comparison function to use to sort
- * stored items.
- * @return a new instance of `TimeOrderList`.
- * @return NULL if the new instance couldn't be created.
- *
- */
-ListTimeOrdered *listTimeOrdered_Create(
-    TimeOrderList_KeyCompare *keyCompareFunction);
-
-/**
- * Release a previously acquired reference to the specified instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- */
-void listTimeOrdered_Release(ListTimeOrdered **listP);
-
-/**
- * Add a {@link ContentStoreEntry} instance to the specified list. Note that a
- * new refernece to the specified `storeEntry` is not acquired.
- *
- * @param list the list instance into which to add the specified storeEntry.
- * @param storeEntry the storeEntry instance to add.
- *
- */
-void listTimeOrdered_Add(ListTimeOrdered *list, ContentStoreEntry *storeEntry);
-
-/**
- * Remove a {@link ContentStoreEntry} instance from the specified list.
- *
- * @param list the list instance from which to remove the specified storeEntry.
- * @param storeEntry the storeEntry instance to remove.
- * @return true if the removal was succesful.
- * @return false if the removal was not succesful.
- *
- */
-bool listTimeOrdered_Remove(ListTimeOrdered *list,
-                            ContentStoreEntry *storeEntry);
-
-/**
- * Return the oldest {@link ContentStoreEntry} instance in this list. That is,
- * the one with the smallest time value.
- *
- * @param list the list instance from which to retrieve the oldest storeEntry.
- * @param the oldest `ContentStoreEntry` in the list
- * @param NULL if no `ContentStoreEntry` was available.
- *
- */
-ContentStoreEntry *listTimeOrdered_GetOldest(ListTimeOrdered *list);
-
-/**
- * Return the number of items currently stored in the list.
- *
- * @param list the `ListTimeOrdered` instance from which to retrieve the count.
- * @return the number of items in the list.
- *
- */
-size_t listTimeOrdered_Length(ListTimeOrdered *list);
-#endif /* defined(listTimeOrdered_h) */
diff --git a/hicn-light/src/hicn/content_store/lru.c b/hicn-light/src/hicn/content_store/lru.c
new file mode 100644
index 000000000..2f1fb9427
--- /dev/null
+++ b/hicn-light/src/hicn/content_store/lru.c
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _WIN32
+#include <sys/queue.h>
+#endif
+
+#include <hicn/util/log.h>
+
+#include <hicn/hicn-light/config.h>
+#include <stdio.h>
+
+#include <hicn/core/packet_cache.h>
+#include "lru.h"
+
+void cs_lru_initialize(cs_t *cs) {
+  /* We start with an empty double-linked list */
+  cs->lru.head = INVALID_ENTRY_ID;
+  cs->lru.tail = INVALID_ENTRY_ID;
+}
+
+void cs_lru_finalize(cs_t *cs) {
+  // Nothing to do
+}
+
+cs_entry_t *_cs_entry_at(pkt_cache_t *pkt_cache, off_t entry_id) {
+  pkt_cache_entry_t *entry = pkt_cache_entry_at(pkt_cache, entry_id);
+  assert(entry->entry_type == PKT_CACHE_CS_TYPE);
+  return &entry->u.cs_entry;
+}
+
+/**
+ * Remove a cs_entry_t from all tables and indices.
+ */
+static int cs_lru_remove_entry(pkt_cache_t *pkt_cache,
+                               pkt_cache_entry_t *entry) {
+  assert(pkt_cache);
+  assert(entry);
+
+  off_t entry_id = pkt_cache_get_entry_id(pkt_cache, entry);
+  cs_t *cs = pkt_cache_get_cs(pkt_cache);
+  cs_entry_t *cs_entry = &entry->u.cs_entry;
+
+  // If node to be deleted is head node
+  if (cs->lru.head == entry_id) cs->lru.head = cs_entry->lru.next;
+
+  // If node to be deleted is tail node
+  if (cs->lru.tail == entry_id) cs->lru.tail = cs_entry->lru.prev;
+
+  // If node to be deleted is not the last node
+  if (cs_entry->lru.next != INVALID_ENTRY_ID) {
+    cs_entry_t *next_cs_entry = _cs_entry_at(pkt_cache, cs_entry->lru.next);
+    assert(next_cs_entry);
+    next_cs_entry->lru.prev = cs_entry->lru.prev;
+  }
+
+  // If node to be deleted is not the first node
+  if (cs_entry->lru.prev != INVALID_ENTRY_ID) {
+    cs_entry_t *prev_entry = _cs_entry_at(pkt_cache, cs_entry->lru.prev);
+    assert(prev_entry);
+    prev_entry->lru.next = cs_entry->lru.next;
+  }
+
+  cs->stats.lru.countLruDeletions++;
+  return LRU_SUCCESS;
+}
+
+/**
+ * @brief LRU processing related to the insertion of a new entry in the content
+ * store (helper).
+ * @param[in] cs Content store.
+ * @param[in] entry_id Identifier of the entry in the content store entry pool.
+ * @param[in] is_update Boolean value to distinguish update from add operations
+ * since an update involves removing an entry and adding it again
+ *
+ * @return int Error code : 0 if succesful, a negative value otherwise.
+ *
+ * NOTE:
+ *  - We insert the new element at the head of the double-linked list.
+ */
+int _cs_lru_add_entry(pkt_cache_t *pkt_cache, off_t entry_id, bool is_update) {
+  assert(pkt_cache);
+
+  cs_t *cs = pkt_cache_get_cs(pkt_cache);
+  cs_entry_t *entry = _cs_entry_at(pkt_cache, entry_id);
+  assert(entry);
+
+  // Add at the front of the LRU doubly linked list
+  if (cs->lru.head != INVALID_ENTRY_ID) {
+    cs_entry_t *head_entry = _cs_entry_at(pkt_cache, cs->lru.head);
+    assert(head_entry->lru.prev == INVALID_ENTRY_ID);
+    head_entry->lru.prev = entry_id;
+
+    entry->lru.next = cs->lru.head;
+    entry->lru.prev = INVALID_ENTRY_ID;
+
+    cs->lru.head = entry_id;
+  } else { /* The list is empty */
+    assert(cs->lru.tail == INVALID_ENTRY_ID);
+
+    entry->lru.next = INVALID_ENTRY_ID;
+    entry->lru.prev = INVALID_ENTRY_ID;
+    cs->lru.head = cs->lru.tail = entry_id;
+  }
+  if (!is_update) cs->stats.lru.countAdds++;
+
+  // Handle LRU eviction
+  if (cs->num_entries > cs->max_size) {
+    DEBUG("LRU eviction");
+    cs->stats.lru.countLruEvictions++;
+
+    // Remove from LRU tail
+    pkt_cache_entry_t *tail = pkt_cache_entry_at(pkt_cache, cs->lru.tail);
+    cs_lru_remove_entry(pkt_cache, tail);
+    return LRU_EVICTION;
+  }
+
+  return LRU_SUCCESS;
+}
+
+/**
+ * @brief LRU processing related to the insertion of a new entry in the content
+ * store.
+ * @param[in] cs Content store.
+ * @param[in] entry_id Identifier of the entry in the content store entry pool.
+ *
+ * @return int Error code : 0 if succesful, a negative value otherwise.
+ *
+ * NOTE:
+ *  - We insert the new element at the head of the double-linked list.
+ */
+static int cs_lru_add_entry(pkt_cache_t *pkt_cache, off_t entry_id) {
+  return _cs_lru_add_entry(pkt_cache, entry_id, false);
+}
+
+/**
+ * Move a cs_entry_t to the LRU head.
+ */
+static void cs_lru_update_entry(pkt_cache_t *pkt_cache,
+                                pkt_cache_entry_t *entry) {
+  assert(pkt_cache);
+  assert(entry);
+
+  cs_t *cs = pkt_cache_get_cs(pkt_cache);
+  cs->stats.lru.countUpdates++;
+
+  // Remove from LRU
+  cs_lru_remove_entry(pkt_cache, entry);
+
+  // Attach at the LRU head
+  off_t entry_id = pkt_cache_get_entry_id(pkt_cache, entry);
+  _cs_lru_add_entry(pkt_cache, entry_id, true);
+}
+
+DECLARE_CS(lru);
diff --git a/hicn-light/src/hicn/content_store/lru.h b/hicn-light/src/hicn/content_store/lru.h
new file mode 100644
index 000000000..9e78ce327
--- /dev/null
+++ b/hicn-light/src/hicn/content_store/lru.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HICNLIGHT_CS_LRU_H
+#define HICNLIGHT_CS_LRU_H
+
+#define LRU_FAILURE 0
+#define LRU_SUCCESS 1
+#define LRU_EVICTION 2
+
+typedef struct {
+  off_t prev;
+  off_t next;
+} cs_entry_lru_state_t;
+
+typedef struct {
+  off_t head;
+  off_t tail;
+} cs_lru_state_t;
+
+/**
+ * @brief Count the number of:
+ * - CS matches
+ * - CS misses
+ * - entries added to CS/LRU (upon receiving a data packet)
+ * - entries updated in the LRU
+ *   (because an already-existing CS entry has been updated)
+ * - LRU evictions
+ *
+ * 'countExpiryEvictions' is not collected since an entry is never evicted
+ * because of expiration. An expired CS entry is only detected when
+ * a data packet with the same name is received, causing an update
+ * (NOT an actual eviction).
+ */
+typedef struct {
+  uint64_t countHits;
+  uint64_t countMisses;
+  uint64_t countAdds;
+  uint64_t countUpdates;
+  uint64_t countLruDeletions;
+  uint64_t countLruEvictions;
+} cs_lru_stats_t;
+
+#endif /* HICNLIGHT_CS_LRU_H */
diff --git a/hicn-light/src/hicn/core/CMakeLists.txt b/hicn-light/src/hicn/core/CMakeLists.txt
index 1b13be91f..57ffb780f 100644
--- a/hicn-light/src/hicn/core/CMakeLists.txt
+++ b/hicn-light/src/hicn/core/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -12,49 +12,63 @@
 # limitations under the License.
 
 list(APPEND HEADER_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/connectionManager.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/connectionState.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/ticks.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/connectionList.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/connectionTable.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/address.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/address_pair.h
   ${CMAKE_CURRENT_SOURCE_DIR}/connection.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/connection_vft.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/connection_table.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/content_store.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/fib_entry.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/fib.h
   ${CMAKE_CURRENT_SOURCE_DIR}/forwarder.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/logger.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/dispatcher.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/message.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/messagePacketType.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/numberSet.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/streamBuffer.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/system.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/listener.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/listener_table.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/listener_vft.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/msgbuf.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/msgbuf_pool.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/packet_cache.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/pit.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/policy_stats.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategy.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategy_vft.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/subscription.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/ticks.h
+# ${CMAKE_CURRENT_SOURCE_DIR}/system.h
   ${CMAKE_CURRENT_SOURCE_DIR}/mapme.h
   ${CMAKE_CURRENT_SOURCE_DIR}/wldr.h
   ${CMAKE_CURRENT_SOURCE_DIR}/messageHandler.h
   ${CMAKE_CURRENT_SOURCE_DIR}/nameBitvector.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/nexthops.h
   ${CMAKE_CURRENT_SOURCE_DIR}/name.h
 )
 
 list(APPEND SOURCE_FILES
+  ${CMAKE_CURRENT_SOURCE_DIR}/address.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/address_pair.c
   ${CMAKE_CURRENT_SOURCE_DIR}/connection.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/connectionList.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/connectionManager.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/connectionTable.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/dispatcher.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/connection_table.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/connection_vft.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/content_store.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/fib.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/fib_entry.c
   ${CMAKE_CURRENT_SOURCE_DIR}/forwarder.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/logger.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/message.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/numberSet.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/streamBuffer.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/listener.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/listener_table.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/listener_vft.c
   ${CMAKE_CURRENT_SOURCE_DIR}/mapme.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/wldr.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/msgbuf.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/msgbuf_pool.c
   ${CMAKE_CURRENT_SOURCE_DIR}/nameBitvector.c
   ${CMAKE_CURRENT_SOURCE_DIR}/name.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/nexthops.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/packet_cache.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/pit.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/policy_stats.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategy.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategy_vft.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/subscription.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/wldr.c
 )
 
 set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
 set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
-
-set(TO_INSTALL_HEADER_FILES
-  ${TO_INSTALL_HEADER_FILES}
-  ${HEADER_FILES}
-  PARENT_SCOPE
-)
diff --git a/hicn-light/src/hicn/core/address.c b/hicn-light/src/hicn/core/address.c
new file mode 100644
index 000000000..a4b41c8b5
--- /dev/null
+++ b/hicn-light/src/hicn/core/address.c
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file address.c
+ * \brief Implementation of Address
+ */
+
+#include <hicn/core/address.h>
+#include <hicn/util/sstrncpy.h>
+
+int address_from_ip_port(address_t *address, int family, ip_address_t *addr,
+                         uint16_t port) {
+  switch (family) {
+    case AF_INET:
+      *address = ADDRESS4(ntohl(addr->v4.as_inaddr.s_addr), ntohs(port));
+      break;
+    case AF_INET6:
+      *address = ADDRESS6(addr->v6.as_in6addr, ntohs(port));
+      break;
+    default:
+      return -1;
+  }
+  return 0;
+}
+
+const char *_address_family_str[] = {
+    [AF_INET] = "AF_INET",
+    [AF_INET6] = "AF_INET6",
+};
+
+int address_to_string(const address_t *address, char *addr_str, int *port) {
+  const int SUCCESS = 0;
+  char port_str[NI_MAXSERV];
+  struct sockaddr_storage addr = address->as_ss;
+  socklen_t addr_len = sizeof(addr);
+
+  int result =
+      getnameinfo((struct sockaddr *)&addr, addr_len, addr_str, NI_MAXHOST,
+                  port_str, sizeof(port_str), NI_NUMERICHOST | NI_NUMERICSERV);
+
+  if (result != SUCCESS) {
+    strcpy_s(addr_str, NI_MAXHOST, "N/A");
+    if (port != NULL) *port = -1;
+    return result;
+  }
+
+  if (port != NULL) *port = atoi(port_str);
+  return SUCCESS;
+}
+
+address_t _ADDRESS4_LOCALHOST(uint16_t port) {
+  return ADDRESS4_LOCALHOST(port);
+}
diff --git a/hicn-light/src/hicn/core/address.h b/hicn-light/src/hicn/core/address.h
new file mode 100644
index 000000000..7958bd063
--- /dev/null
+++ b/hicn-light/src/hicn/core/address.h
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file address.h
+ * \brief Address
+ */
+
+#ifndef HICNLIGHT_ADDRESS_H
+#define HICNLIGHT_ADDRESS_H
+
+#include <netinet/in.h>
+
+#include <string.h>  // memcmp
+#include <hicn/util/ip_address.h>
+#include <netinet/in.h>
+
+typedef union {
+  struct sockaddr_in as_sin;
+  struct sockaddr_in6 as_sin6;
+  struct sockaddr as_sa;
+  struct sockaddr_storage as_ss;
+} address_t;
+
+#define address_equals(a, b) (memcmp(a, b, sizeof(address_t)) == 0)
+
+#define address_family(address) ((address)->as_ss.ss_family)
+
+#define address4(address) ((struct sockaddr_in *)(address))
+#define address6(address) ((struct sockaddr_in6 *)(address))
+#define address_sa(address) ((struct sockaddr *)(address))
+
+#define address4_ip(address) (address4(address)->sin_addr)
+#define address6_ip(address) (address6(address)->sin6_addr)
+#define address6_scope_id(address) (address4_ptr(address)->sin6_scope_id)
+
+#define address_socklen(address)                                        \
+  (((address)->as_ss.ss_family == AF_INET) ? sizeof(struct sockaddr_in) \
+                                           : sizeof(struct sockaddr_in6))
+
+#define address4_is_local(address) \
+  ((htonl((address4_ip(address)).s_addr) & 0xFF000000) == 0x7F000000)
+
+static inline bool _address6_is_local(struct sockaddr_in6 *sin6) {
+  return IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr);
+}
+
+#define address6_is_local(address) (_address6_is_local(address6(address)))
+
+#define address_is_local(address)                                      \
+  ((address)->as_ss.ss_family == AF_INET) ? address4_is_local(address) \
+                                          : address6_is_local(address)
+
+int address_from_ip_port(address_t *address, int family, ip_address_t *addr,
+                         uint16_t port);
+
+static inline address_t ADDRESS4(in_addr_t in_addr, int port) {
+  address_t address = {
+      .as_sin =
+          {
+              .sin_family = AF_INET,
+              .sin_port = htons(port),
+              .sin_addr = {.s_addr = htonl(in_addr)},
+          },
+  };
+
+  return address;
+}
+
+#define ADDRESS4_LOCALHOST(port) ADDRESS4(INADDR_LOOPBACK, (port))
+
+/**
+ * @brief Helper function to avoid macro expansion in c++ tests. Wrapper around
+ * 'ADDRESS4_LOCALHOST()'.
+ *
+ * @param port
+ * @return address_t
+ */
+address_t _ADDRESS4_LOCALHOST(uint16_t port);
+
+#define ADDRESS4_ANY(port) ADDRESS4(INADDR_ANY, (port))
+
+static inline address_t ADDRESS6(struct in6_addr in_addr, int port) {
+  address_t address = {
+      .as_sin6 =
+          {
+              .sin6_family = AF_INET6,
+              .sin6_port = htons(port),
+              .sin6_addr = in_addr,
+          },
+  };
+
+  return address;
+}
+
+#define ADDRESS6_LOCALHOST(port) ADDRESS6(in6addr_loopback, (port))
+#define ADDRESS6_ANY(port) ADDRESS6((struct in6_addr)IN6ADDR_ANY_INIT, port)
+
+#define ADDRESS_ANY(family, port) \
+  ((family == AF_INET) ? ADDRESS4_ANY(port) : ADDRESS6_ANY(port))
+
+extern const char *_address_family_str[];
+
+#define address_family_str(address) \
+  (_address_family_str[address_family(address)])
+
+#define address4_empty(address) (address4_ip(address).s_addr == 0)
+#define address6_empty(address)                       \
+  (memcmp(address6_ip(address).s6_addr, &in6addr_any, \
+          sizeof(struct in6_addr)) == 0)
+#define address_empty(address)                                  \
+  (address_family(address) == AF_INET ? address4_empty(address) \
+                                      : address6_empty(address))
+
+/**
+ * @brief Return the string representation and the port of the IP address
+ * provided.
+ *
+ * @param[in] address Address to obtain the string representation from.
+ * @param[in, out] buffer String to store the string representation of the
+ * address. It contains "N/A" in case of failure (see return value).
+ * @param[in, out] port Integer to store the the port. It contains -1 in case of
+ * failure (see return value). If NULL, it will not be used to store the port.
+ * @return int 0 if success, failure otherwise.
+ */
+
+int address_to_string(const address_t *address, char *buffer, int *port);
+
+#endif /* HICNLIGHT_ADDRESS_H */
diff --git a/hicn-light/src/hicn/core/address_pair.c b/hicn-light/src/hicn/core/address_pair.c
new file mode 100644
index 000000000..facbb8dc4
--- /dev/null
+++ b/hicn-light/src/hicn/core/address_pair.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file address_pair.c
+ * \brief Implementation of Address pair
+ */
+
+#include "address_pair.h"
+
+address_pair_t address_pair_factory(address_t local, address_t remote) {
+  address_pair_t pair;
+  memset(&pair, 0, sizeof(address_pair_t));
+
+  pair.local = local;
+  pair.remote = remote;
+  return pair;
+}
+
+int address_pair_from_ip_port(address_pair_t* pair, int family,
+                              ip_address_t* local_addr, uint16_t local_port,
+                              ip_address_t* remote_addr, uint16_t remote_port) {
+  memset(pair, 0, sizeof(*pair));
+  if (address_from_ip_port(&pair->local, family, local_addr, local_port) < 0)
+    return -1;
+  if (address_from_ip_port(&pair->remote, family, remote_addr, remote_port) < 0)
+    return -1;
+  return 0;
+}
diff --git a/hicn-light/src/hicn/core/address_pair.h b/hicn-light/src/hicn/core/address_pair.h
new file mode 100644
index 000000000..72b92d6b5
--- /dev/null
+++ b/hicn-light/src/hicn/core/address_pair.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file address_pair.h
+ * \brief Address pair
+ */
+
+#ifndef HICNLIGHT_ADDRESS_PAIR_H
+#define HICNLIGHT_ADDRESS_PAIR_H
+
+#include <hicn/util/ip_address.h>
+
+#include "address.h"
+
+typedef struct {
+  address_t local;
+  address_t remote;
+} address_pair_t;
+
+/**
+ * @brief Create an address pair starting from local and remote addresses.
+ *
+ * @param local The local address to use in the pair
+ * @param remote The remote address to use in the pair
+ * @return address_pair_t The address pair created
+ */
+address_pair_t address_pair_factory(address_t local, address_t remote);
+
+int address_pair_from_ip_port(address_pair_t* pair, int family,
+                              ip_address_t* local_addr, uint16_t local_port,
+                              ip_address_t* remote_addr, uint16_t remote_port);
+
+#define address_pair_get_local(pair) (&(pair)->local)
+#define address_pair_get_remote(pair) (&(pair)->remote)
+
+#define address_pair_get_local_family(pair) \
+  (address_family(address_pair_get_local(pair)))
+#define address_pair_get_remote_family(pair) \
+  (address_family(address_pair_get_remote(pair)))
+#define address_pair_get_family(pair) address_pair_get_local_family(pair)
+
+#define address_pair_is_valid(pair) \
+  (address_pair_get_local_family(pair) == address_pair_get_remote_family(pair))
+
+#endif /* HICNLIGHT_ADDRESS_PAIR_H */
diff --git a/hicn-light/src/hicn/core/connection.c b/hicn-light/src/hicn/core/connection.c
index c2ac71a5f..c8cc1d0b9 100644
--- a/hicn-light/src/hicn/core/connection.c
+++ b/hicn-light/src/hicn/core/connection.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,347 +13,294 @@
  * limitations under the License.
  */
 
-#include <limits.h>
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
+/**
+ * @file connection.c
+ * @brief Implementation of hICN connections
+ */
 
-#include <hicn/core/connection.h>
-#include <hicn/core/connectionState.h>
-#include <hicn/core/messageHandler.h>
-#include <hicn/core/ticks.h>
-#include <hicn/core/wldr.h>
-#include <hicn/io/addressPair.h>
-#include <hicn/io/ioOperations.h>
+#include <assert.h>
 
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#ifdef WITH_POLICY
-#include <hicn/policy.h>
-#endif /* WITH_POLICY */
+#include <hicn/core/forwarder.h>
+#include <hicn/core/listener.h>
+#include <hicn/util/log.h>
+#include <hicn/core/wldr.h>
 
-struct connection {
+#include "connection.h"
+#include "connection_vft.h"
+
+#define _conn_var(x) _connection_##x
+
+// This is called by configuration
+connection_t *connection_create(face_type_t type, const char *name,
+                                const address_pair_t *pair,
+                                forwarder_t *forwarder) {
+  assert(face_type_is_valid(type));
+  assert(pair);
+  assert(forwarder);
+
+  face_type_t listener_type;
+  switch (type) {
+    case FACE_TYPE_UDP:
+      listener_type = FACE_TYPE_UDP_LISTENER;
+      break;
+    case FACE_TYPE_TCP:
+      listener_type = FACE_TYPE_TCP_LISTENER;
+      break;
+    default:
+      return NULL;
+  }
 
-  const AddressPair *addressPair;
-  IoOperations *ops;
+  listener_table_t *ltable = forwarder_get_listener_table(forwarder);
+  listener_key_t key = listener_key_factory(pair->local, listener_type);
 
-  unsigned refCount;
+  listener_t *listener = listener_table_get_by_key(ltable, &key);
+  if (!listener) {
+    WITH_ERROR({
+      char addr_str[NI_MAXHOST];
+      int port;
+      address_to_string(&pair->local, addr_str, &port);
+      ERROR("Could not find listener to match address %s:%d", addr_str, port);
+    })
 
-  unsigned counter;
+    return NULL;
+  }
 
-  bool wldrAutoStart;  // if true, wldr can be set automatically
-                       // by default this value is set to true.
-                       // if wldr is activated using a command (config
-                       // file/hicnLightControl) this value is set to false so
-                       // that a base station can not disable wldr at the client
-  Wldr *wldr;
+  connection_table_t *table =
+      forwarder_get_connection_table(listener->forwarder);
+  unsigned connection_id = listener_create_connection(listener, name, pair);
+  if (!connection_id_is_valid(connection_id)) return NULL;
+  return connection_table_at(table, connection_id);
+}
 
+/**
+ * @brief Initializes a connection
+ *
+ * @param [out] connection - Allocated connection buffer (eg. from pool) to be
+ *      initialized.
+ * @param [in] forwarder - forwarder_t to which the connection is associated.
+ * This parameter needs to be non-NULL for connections receiving packets, such
+ *      as TCP connections which are very close to UDP listeners, and unlike
+ *      bound UDP connections).
+ * @param [in] fd - A fd specific to the connection, or 0 if the connection
+ *      should inherit the fd of the listener.
+ * @return 0 if no error, -1 otherwise
+ */
+int connection_initialize(connection_t *connection, face_type_t type,
+                          const char *name, const char *interface_name, int fd,
+                          const address_pair_t *pair, bool local,
+                          unsigned connection_id, listener_t *listener) {
+  int rc;
+
+  assert(connection);
+  /* Interface name can be NULL eg always for TCP connnections */
+  assert(pair);
+  // assert(address_pair_is_valid(pair)); TODO: local addr in the pair is not
+  // initialized for now
+
+  if (fd == 0) WARN("Connection is not connected");
+
+  *connection = (connection_t){
+      .id = connection_id,
+      .name = strdup(name),
+      .type = type,
+      .interface_name = strdup(interface_name),
+      .pair = *pair,
+      .fd = ((fd != 0) ? fd : listener_get_fd(listener)),
+      .connected = (fd != 0),
+      //        .up = true,
+      .local = local,
+      // XXX UDP should start UP, TCP DOWN until remove side answer ?
+      .state = FACE_STATE_UNDEFINED,
+      .admin_state = FACE_STATE_UP,
 #ifdef WITH_POLICY
-  policy_tags_t tags;
+      .priority = 0,
 #endif /* WITH_POLICY */
 
-};
+      .listener = listener,
+      .closed = false,
 
-Connection *connection_Create(IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter ops must be non-null");
-  Connection *conn = parcMemory_AllocateAndClear(sizeof(Connection));
-  parcAssertNotNull(conn, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Connection));
-  conn->addressPair = ioOperations_GetAddressPair(ops);
-  conn->ops = ops;
-  conn->refCount = 1;
-  conn->wldr = NULL;
+      /* WLDR */
+      .wldr = NULL,
+      .wldr_autostart = true,
+  };
 
-  conn->wldrAutoStart = true;
-  conn->counter = 0;
+  connection->data =
+      malloc(connection_vft[get_protocol(connection->type)]->data_size);
+  if (!connection->data) goto ERR_DATA;
 
-  /* By default, a connection will aim at the UP state */
-  connection_SetAdminState(conn, CONNECTION_STATE_UP);
+  assert(connection_has_valid_id(connection));
 
-#ifdef WITH_POLICY
-  conn->tags = POLICY_TAGS_EMPTY;
-#endif /* WITH_POLICY */
-
-  return conn;
-}
-
-Connection *connection_Acquire(Connection *connection) {
-  parcAssertNotNull(connection, "Parameter conn must be non-null");
-  connection->refCount++;
-  return connection;
-}
-
-void connection_Release(Connection **connectionPtr) {
-  parcAssertNotNull(connectionPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*connectionPtr,
-                    "Parameter must dereference to non-null pointer");
-  Connection *conn = *connectionPtr;
-
-  parcAssertTrue(
-      conn->refCount > 0,
-      "Invalid state, connection reference count should be positive, got 0.");
-  conn->refCount--;
-  if (conn->refCount == 0) {
-    // don't destroy addressPair, its part of ops.
-    ioOperations_Release(&conn->ops);
-    if (conn->wldr != NULL) {
-      wldr_Destroy(&(conn->wldr));
-    }
-    parcMemory_Deallocate((void **)&conn);
+  rc = connection_vft[get_protocol(connection->type)]->initialize(connection);
+  if (rc < 0) {
+    goto ERR_VFT;
   }
-  *connectionPtr = NULL;
-}
-
-bool connection_Send(const Connection *conn, Message *message) {
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
 
-  if (ioOperations_IsUp(conn->ops)) {
-    if (message_GetType(message) == MessagePacketType_ContentObject) {
-      uint8_t connectionId = (uint8_t)connection_GetConnectionId(conn);
-      message_UpdatePathLabel(message, connectionId);
+  if (connection->connected) {
+    /*
+     * The file descriptor is created by the listener. We assume for now that
+     * all connections get their own fd, and we have to register it.
+     *
+     * TODO the connection has no more read callback, so we call the one from
+     * the listener.
+     */
+    loop_fd_event_create(&connection->event_data, MAIN_LOOP, fd, listener,
+                         (fd_callback_t)listener_read_callback, NULL);
+
+    if (!connection->event_data) {
+      goto ERR_REGISTER_FD;
     }
-    if (conn->wldr != NULL) {
-      wldr_SetLabel(conn->wldr, message);
-    } else {
-      message_ResetWldrLabel(message);
+
+    if (loop_fd_event_register(connection->event_data) < 0) {
+      goto ERR_REGISTER_FD;
     }
-    return ioOperations_Send(conn->ops, NULL, message);
   }
-  return false;
-}
-
-bool connection_SendIOVBuffer(const Connection *conn, struct iovec *msg,
-    size_t size) {
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  parcAssertNotNull(msg, "Parameter message must be non-null");
-
-  return ioOperations_SendIOVBuffer(conn->ops, msg, size);
-}
-
-bool connection_SendBuffer(const Connection *conn, u8 * buffer, size_t length)
-{
-  struct iovec iov[1];
-  iov[0].iov_base = buffer;
-  iov[0].iov_len = length;
-  return connection_SendIOVBuffer(conn, iov, 1);
-}
 
-void connection_Probe(Connection *conn, uint8_t * probe) {
-  ioOperations_SendProbe(conn->ops, probe);
-}
-
-void connection_HandleProbe(Connection *conn, uint8_t *probe){
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  parcAssertNotNull(probe, "Parameter pkt must be non-null");
-
-  if(messageHandler_IsInterest(probe)){
-    messageHandler_CreateProbeReply(probe, HF_INET6_TCP);
-    ioOperations_SendProbe(conn->ops, probe);
+  return 0;
+
+ERR_REGISTER_FD:
+#ifndef _WIN32
+  close(fd);
+#else
+  closesocket(fd);
+#endif
+ERR_VFT:
+  free(connection->data);
+ERR_DATA:
+  free(connection->interface_name);
+  free(connection->name);
+  return -1;
+}
+
+int connection_finalize(connection_t *connection) {
+  assert(connection);
+  assert(connection_has_valid_type(connection));
+
+  if (connection->connected) {
+    loop_event_unregister(connection->event_data);
+    loop_event_free(connection->event_data);
   }
-}
-
-IoOperations *connection_GetIoOperations(const Connection *conn) {
-  return conn->ops;
-}
-
-unsigned connection_GetConnectionId(const Connection *conn) {
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  return ioOperations_GetConnectionId(conn->ops);
-}
-
-const AddressPair *connection_GetAddressPair(const Connection *conn) {
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  return ioOperations_GetAddressPair(conn->ops);
-}
-
-bool connection_IsUp(const Connection *conn) {
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  if (!conn->ops) return false;
-  return ioOperations_IsUp(conn->ops);
-}
 
-bool connection_IsLocal(const Connection *conn) {
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  return ioOperations_IsLocal(conn->ops);
-}
+  if (connection->fd != 0) {  // Only if connected socket
+#ifndef _WIN32
+    close(connection->fd);
+#else
+    closesocket(connection->fd);
+#endif
+  }
 
-const void *connection_Class(const Connection *conn) {
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  return ioOperations_Class(conn->ops);
-}
+  if (connection->wldr) wldr_free(connection->wldr);
 
-bool connection_ReSend(const Connection *conn, Message *message,
-                       bool notification) {
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
-  bool res = false;
-
-  if (connection_IsUp(conn)) {
-    // here the wldr header is alreay set: this message is a retransmission or a
-    // notification
-
-    // we need to recompiute the path lable since we always store a pointer to
-    // the same message if this message will be sent again to someonelse, the
-    // new path label must be computed starting from the orignal labelorignal
-    // label. Notice that we heve the same problem in case of PIT aggregation.
-    // That case is handled insied the MessageProcessor. This is specific to
-    // WLDR retransmittions. This is done only for data packets
-
-    if (message_GetType(message) == MessagePacketType_ContentObject) {
-      uint8_t connectionId = (uint8_t)connection_GetConnectionId(conn);
-      uint32_t old_path_label = message_GetPathLabel(message);
-      message_UpdatePathLabel(message, connectionId);
-
-      res = ioOperations_Send(conn->ops, NULL, message);
-
-      message_SetPathLabel(message, old_path_label);
-    } else {
-      res = ioOperations_Send(conn->ops, NULL, message);
-    }
-  }
+  connection_vft[get_protocol(connection->type)]->finalize(connection);
 
-  if (notification) {
-    // the notification is never destroyed
-    message_Release(&message);
-  }
+  if (connection->data) free(connection->data);
+  connection->data = NULL;
+  if (connection->interface_name) free(connection->interface_name);
+  connection->interface_name = NULL;
+  if (connection->name) free(connection->name);
+  connection->name = NULL;
 
-  return res;
+  return 0;
 }
 
-void connection_AllowWldrAutoStart(Connection *conn, bool allow) {
-  conn->wldrAutoStart = allow;
-}
+int connection_send_packet(const connection_t *connection,
+                           const uint8_t *packet, size_t size) {
+  assert(connection);
+  assert(face_type_is_valid(connection->type));
+  assert(packet);
 
-void connection_EnableWldr(Connection *conn) {
-  if (!connection_IsLocal(conn)) {
-    if (conn->wldr == NULL) {
-      printf("----------------- enable wldr\n");
-      conn->wldr = wldr_Init();
-    }
-  }
+  return connection_vft[get_protocol(connection->type)]->send_packet(
+      connection, packet, size);
 }
 
-void connection_DisableWldr(Connection *conn) {
-  if (!connection_IsLocal(conn)) {
-    if (conn->wldr != NULL) {
-      printf("----------------- disable wldr\n");
-      wldr_Destroy(&(conn->wldr));
-      conn->wldr = NULL;
-    }
-  }
+bool _connection_send(const connection_t *connection, msgbuf_t *msgbuf,
+                      bool queue) {
+  return connection_vft[get_protocol(connection->type)]->send(connection,
+                                                              msgbuf, queue);
 }
 
-bool connection_HasWldr(const Connection *conn) {
-  if (conn->wldr == NULL) {
-    return false;
-  } else {
-    return true;
-  }
+bool connection_flush(const connection_t *connection) {
+  return connection_vft[get_protocol(connection->type)]->flush(connection);
 }
 
-bool connection_WldrAutoStartAllowed(const Connection *conn) {
-  return conn->wldrAutoStart;
-}
+bool connection_send(const connection_t *connection, off_t msgbuf_id,
+                     bool queue) {
+  assert(connection);
+  assert(msgbuf_id_is_valid(msgbuf_id));
 
-void connection_DetectLosses(Connection *conn, Message *message) {
-  if (conn->wldr != NULL) wldr_DetectLosses(conn->wldr, conn, message);
-}
+  // if (!connection_is_up(connection))
+  //     return false;
 
-void connection_HandleWldrNotification(Connection *conn, Message *message) {
-  if (conn->wldr != NULL)
-    wldr_HandleWldrNotification(conn->wldr, conn, message);
-}
+  const listener_t *listener = connection_get_listener(connection);
+  const forwarder_t *forwarder = listener_get_forwarder(listener);
+  const msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(forwarder);
+  msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id);
 
-connection_state_t connection_GetState(const Connection *conn)
-{
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  if (!conn->ops)
-    return CONNECTION_STATE_UNDEFINED;
-  return ioOperations_GetState(conn->ops);
-}
+  if (connection->wldr)
+    wldr_set_label(connection->wldr, msgbuf);
+  else
+    msgbuf_reset_wldr_label(msgbuf);
 
-void connection_SetState(Connection *conn, connection_state_t state)
-{
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  if (!conn->ops)
-    return;
-  ioOperations_SetState(conn->ops, state);
+  return _connection_send(connection, msgbuf, queue);
 }
 
-connection_state_t connection_GetAdminState(const Connection *conn)
-{
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  if (!conn->ops)
-    return CONNECTION_STATE_UNDEFINED;
-  return ioOperations_GetAdminState(conn->ops);
-}
+/*
+ * here the wldr header is alreay set: this message is a retransmission or a
+ * notification
+ *
+ * we need to recompute the path label since we always store a pointer to
+ * the same message if this message will be sent again to someone else, the
+ * new path label must be computed starting from the orignal label. Note
+ * that we heve the same problem in case of PIT aggregation. That case is
+ * handled inside the MessageProcessor. This is specific to WLDR
+ * retransmittions. This is done only for data packets
+ */
+bool connection_resend(const connection_t *connection, msgbuf_t *msgbuf,
+                       bool notification) {
+  assert(connection);
+  assert(msgbuf);
 
-void connection_SetAdminState(Connection *conn, connection_state_t admin_state)
-{
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  if (!conn->ops)
-    return;
-  if ((admin_state != CONNECTION_STATE_UP) && (admin_state != CONNECTION_STATE_DOWN))
-    return;
-  ioOperations_SetAdminState(conn->ops, admin_state);
-}
+  bool ret = false;
 
-#ifdef WITH_POLICY
-uint32_t connection_GetPriority(const Connection *conn)
-{
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  if (!conn->ops)
-    return 0;
-  return ioOperations_GetPriority(conn->ops);
-}
+  if (!connection_is_up(connection)) return ret;
 
-void connection_SetPriority(Connection *conn, uint32_t priority)
-{
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  if (!conn->ops)
-    return;
-  ioOperations_SetPriority(conn->ops, priority);
-}
-#endif /* WITH_POLICY */
+  ret = _connection_send(connection, msgbuf, false); /* no queueing */
 
-const char * connection_GetInterfaceName(const Connection * conn)
-{
-  parcAssertNotNull(conn, "Parameter conn must be non-null");
-  if (!conn->ops)
-    return NULL;
-  return ioOperations_GetInterfaceName(conn->ops);
+  return ret;
 }
 
-#ifdef WITH_POLICY
+/* WLDR */
 
-void connection_AddTag(Connection *conn, policy_tag_t tag)
-{
-    policy_tags_add(&conn->tags, tag);
+void connection_wldr_allow_autostart(connection_t *connection, bool value) {
+  connection->wldr_autostart = value;
 }
 
-void connection_RemoveTag(Connection *conn, policy_tag_t tag)
-{
-    policy_tags_remove(&conn->tags, tag);
+bool connection_wldr_autostart_is_allowed(const connection_t *connection) {
+  return connection->wldr_autostart;
 }
 
-policy_tags_t connection_GetTags(const Connection *conn)
-{
-    return conn->tags;
+void connection_wldr_enable(connection_t *connection, bool value) {
+  if (connection_is_local(connection)) return;
+  if (value) {
+    if (connection->wldr) return;
+    connection->wldr = wldr_create();
+  } else {
+    if (!connection->wldr) return;
+    wldr_free(connection->wldr);
+  }
 }
 
-void connection_SetTags(Connection *conn, policy_tags_t tags)
-{
-    conn->tags = tags;
+bool connection_has_wldr(const connection_t *connection) {
+  return !!connection->wldr;
 }
 
-void connection_ClearTags(Connection *conn)
-{
-    conn->tags = POLICY_TAGS_EMPTY;
+void connection_wldr_detect_losses(const connection_t *connection,
+                                   const msgbuf_t *msgbuf) {
+  if (!connection->wldr) return;
+  wldr_detect_losses(connection->wldr, connection, msgbuf);
 }
 
-int connection_HasTag(const Connection *conn, policy_tag_t tag)
-{
-    return policy_tags_has(conn->tags, tag);
+void connection_wldr_handle_notification(const connection_t *connection,
+                                         const msgbuf_t *msgbuf) {
+  if (!connection->wldr) return;
+  wldr_handle_notification(connection->wldr, connection, msgbuf);
 }
-
-#endif /* WITH_POLICY */
diff --git a/hicn-light/src/hicn/core/connection.h b/hicn-light/src/hicn/core/connection.h
index b6513ea1a..05dc1d6e2 100644
--- a/hicn-light/src/hicn/core/connection.h
+++ b/hicn-light/src/hicn/core/connection.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -15,19 +15,23 @@
 
 /**
  * @file connection.h
- * @brief Wrapper for different types of connections
- *
- * A connection wraps a specific set of {@link IoOperations}.  Those operations
- * allow for input and output.  Connections get stored in the Connection Table.
- *
+ * @brief hICN connections
  */
 
-#ifndef connection_h
-#define connection_h
-#include <hicn/hicn-light/config.h>
-#include <hicn/core/connectionState.h>
-#include <hicn/io/ioOperations.h>
-#include <hicn/utils/address.h>
+#ifndef HICNLIGHT_CONNECTION_H
+#define HICNLIGHT_CONNECTION_H
+
+#include <hicn/face.h>
+
+#include "address_pair.h"
+#include "listener.h"
+#include "msgbuf.h"
+
+#ifdef WITH_POLICY
+#include <hicn/policy.h>
+#endif /* WITH_POLICY */
+
+#define CONNECTION_ID_UNDEFINED ~0
 
 #ifdef WITH_MAPME
 typedef enum {
@@ -42,157 +46,193 @@ typedef enum {
 
 #endif /* WITH_MAPME */
 
+struct wldr_s;
+
+typedef struct {
+  unsigned id;
+  char* name;
+  char* interface_name;
+  face_type_t type;
+  address_pair_t pair;
+  //    bool up;
+  bool local;
+  face_state_t state;
+  face_state_t admin_state;
 #ifdef WITH_POLICY
-#include <hicn/policy.h>
+  policy_tags_t tags;
+  uint32_t priority;
 #endif /* WITH_POLICY */
 
-struct connection;
-typedef struct connection Connection;
+  int fd;
+  bool connected;  // true if the connection is connected and has its own fd
+  event_t* event_data;
+
+  void* data;
+
+  listener_t* listener;
+  // struct forwarder_s * forwarder; // recv only
+  bool closed;
+
+  /* WLDR */
+
+  bool wldr_autostart;
+  /*
+   * if true, wldr can be set automatically by default this value is set to
+   * true. if wldr is activated using a command (config file/hicnLightControl)
+   * this value is set to false so that a base station can not disable wldr at
+   * the client.
+   */
+  struct wldr_s* wldr;
+
+} connection_t;
+
+#if 1
+#define connection_get_id(C) ((C)->id)
+#define connection_id_is_valid(ID) (ID != CONNECTION_ID_UNDEFINED)
+#define connection_get_name(C) ((C)->name)
+#define connection_get_type(C) ((C)->type)
+#define connection_has_valid_id(C) \
+  (connection_id_is_valid(connection_get_id(C)))
+#define connection_has_valid_type(C) \
+  (face_type_is_valid(connection_get_type(C)))
+#define connection_get_pair(C) (&(C)->pair)
+#define connection_get_local(C) (address_pair_get_local(connection_get_pair(C)))
+#define connection_get_remote(C) \
+  (address_pair_get_remote(connection_get_pair(C)))
+#define connection_get_local(C) (address_pair_get_local(connection_get_pair(C)))
+#define connection_get_remote(C) \
+  (address_pair_get_remote(connection_get_pair(C)))
+#define connection_is_up(C) ((C)->state == FACE_STATE_UP)
+#define connection_is_closed(C) ((C)->closed == true)
+#define connection_is_local(C) ((C)->local)
+#define connection_get_state(C) ((C)->state)
+#define connection_set_state(C, STATE) (C)->state = STATE
+#define connection_get_admin_state(C) ((C)->admin_state)
+#define connection_set_admin_state(C, STATE) (C)->admin_state = STATE
+#define connection_get_interface_name(C) ((C)->interface_name)
 
-/**
- * Creates a connection object.
- */
-Connection *connection_Create(IoOperations *ops);
+#ifdef WITH_POLICY
+#define connection_get_priority(C) ((C)->priority)
+#define connection_set_priority(C, PRIORITY) (C)->priority = PRIORITY
+#define connection_get_tags(C) ((C)->tags)
+#define connection_set_tags(C, TAGS) (C)->tags = TAGS
+#define connection_has_tag(C, TAG) policy_tags_has(connection_get_tags(C), TAG)
+#define connection_add_tag(C, TAG) policy_tags_add(connection_get_tags(X), TAG)
+#define connection_remove_tag(C, TAG)           \
+  do {                                          \
+    policy_tags_t _conn_var(tags);              \
+    _conn_var(tags) = connection_get_tags(C);   \
+    policy_tags_remove(_conn_var(tags), (TAG)); \
+    connection_set_tags((C), _conn_var(tags));  \
+  } while (0)
+#define connection_clear_tags(C) connection_set_tags(C, POLICY_TAGS_EMPTY)
 
-/**
- * @function connection_Release
- * @abstract Releases a reference count, destroying on last release
- * @discussion
- *   Only frees the memory on the final reference count.  The pointer will
- *   always be NULL'd.
- */
-void connection_Release(Connection **connectionPtr);
+#endif /* WITH_POLICY */
 
-/**
- * @function connection_Acquire
- * @abstract A reference counted copy.
- * @discussion
- *   A shallow copy, they share the same memory.
- */
-Connection *connection_Acquire(Connection *connection);
+#else
 
-/**
- * @function connection_Send
- * @abstract Sends the message on the connection
- * @return true if message sent, false if connection not up
- */
-bool connection_Send(const Connection *conn, Message *message);
+/* Accessors */
+static inline unsigned connection_get_id(const connection_t* connection);
 
-/**
- * @function connection_SendIOVBuffer
- * @abstract Sends an IOV buffer
- */
-bool connection_SendIOVBuffer(const Connection *conn, struct iovec *msg,
-    size_t size);
+#define connection_id_is_valid(id) (id != CONNECTION_ID_UNDEFINED)
+#define connection_has_valid_id(C) (connection_id_is_valid(connection_get_id(C))
 
-/**
- * @function connection_SendBuffer
- * @abstract Sends a buffer
- */
-bool connection_SendBuffer(const Connection *conn, u8 * buffer, size_t length);
+static inline char* connection_get_name(const connection_t* connection);
 
-/**
- * Return the `IoOperations` instance associated with the specified `Connection`
- * instance.
- * @param [in] connection The allocated connection
- * @return a pointer to the IoOperations instance associated by th specified
- * connection.
- */
-IoOperations *connection_GetIoOperations(const Connection *conn);
+static inline face_type_t connection_get_type(const connection_t* connection);
 
-/**
- * Returns the unique identifier of the connection
- * Calls the underlying IoOperations to fetch the connection id
- * @param [in] connection The allocated connection
- * @return unsigned The unique connection id
- */
-unsigned connection_GetConnectionId(const Connection *conn);
+static inline address_pair_t* connection_get_pair(
+    const connection_t* connection);
 
-/**
- * Returns the (remote, local) address pair that describes the connection
- * @param [in] connection The allocated connection
- * @return non-null The connection's remote and local address
- * @return null Should never return NULL
- */
-const AddressPair *connection_GetAddressPair(const Connection *conn);
+#define connection_get_local(C) (address_pair_get_local(connection_get_pair(C)))
+#define connection_get_remote(C) (address_pair_remote(connection_get_pair(C)))
 
-/**
- * Checks if the connection is in the "up" state
- * @param [in] connection The allocated connection
- * @return true The connection is in the "up" state
- * @return false The connection is not in the "up" state
- */
-bool connection_IsUp(const Connection *conn);
+static inline bool connection_is_up(const connection_t* connection);
 
-/**
- * Checks if the connection is to a Local/Loopback address
- *
- * A local connection is PF_LOCAL (PF_UNIX) and a loopback connection is
- * 127.0.0.0/8 or ::1 for IPv6.
- *
- * @param [in] connection The allocated connection
- *
- * @retval true The connection is local or loopback
- * @retval false The connection is not local or loopback
- */
-bool connection_IsLocal(const Connection *conn);
+static inline bool connection_is_local(const connection_t* connection);
 
-/**
- * Returns an opaque pointer representing the class of the Io Operations
- *
- * Returns an opaque pointer that an implementation can use to detect if
- * the connection is based on that class.
- *
- * @param [in] conn The Connection to analyze
- *
- * @return non-null An opaque pointer for each concrete implementation
- */
-const void *connection_Class(const Connection *conn);
+static inline face_state_t connection_get_state(const connection_t* connection);
 
-bool connection_ReSend(const Connection *conn, Message *message,
-                       bool notification);
+static inline void connection_set_state(connection_t* connection,
+                                        face_state_t state);
 
-void connection_Probe(Connection *conn, uint8_t *probe);
+static inline face_state_t connection_get_admin_state(
+    const connection_t* connection);
 
-void connection_HandleProbe(Connection *conn, uint8_t *message);
+static inline void connection_set_admin_state(connection_t* connection,
+                                              face_state_t state);
 
-void connection_AllowWldrAutoStart(Connection *conn, bool allow);
+static inline const char* connection_get_interface_name(
+    const connection_t* connection);
 
-void connection_EnableWldr(Connection *conn);
+#ifdef WITH_POLICY
 
-void connection_DisableWldr(Connection *conn);
+static inline uint32_t connection_get_priority(const connection_t* connection);
 
-bool connection_HasWldr(const Connection *conn);
+static inline void connection_set_priority(connection_t* connection,
+                                           uint32_t priority);
 
-bool connection_WldrAutoStartAllowed(const Connection *conn);
+static inline policy_tags_t connection_get_tags(const connection_t* connection);
 
-void connection_DetectLosses(Connection *conn, Message *message);
+static inline void connection_set_tags(connection_t* connection,
+                                       policy_tags_t tags);
 
-void connection_HandleWldrNotification(Connection *conn, Message *message);
+#define connection_has_tag(C, TAG) policy_tags_has(connection_get_tags(C), TAG)
 
-connection_state_t connection_GetState(const Connection *conn);
+#define connection_add_tag(C, TAG) policy_tags_add(connection_get_tags(X), TAG)
 
-void connection_SetState(Connection *conn, connection_state_t state);
+#define connection_remove_tag(C, TAG)           \
+  do {                                          \
+    policy_tags_t _conn_var(tags);              \
+    _conn_var(tags) = connection_get_tags(C);   \
+    policy_tags_remove(_conn_var(tags), (TAG)); \
+    connection_set_tags((C), _conn_var(tags));  \
+  } while (0)
 
-connection_state_t connection_GetAdminState(const Connection *conn);
+#define connection_clear_tags(C) connection_set_tags(C, POLICY_TAGS_EMPTY)
 
-void connection_SetAdminState(Connection *conn, connection_state_t admin_state);
+#endif /* WITH_POLICY */
 
-#ifdef WITH_POLICY
-uint32_t connection_GetPriority(const Connection *conn);
+#endif
 
-void connection_SetPriority(Connection *conn, uint32_t priority);
-#endif /* WITH_POLICY */
+connection_t* connection_create(face_type_t type, const char* name,
+                                const address_pair_t* pair,
+                                struct forwarder_s* forwarder);
 
-const char * connection_GetInterfaceName(const Connection * conn);
+int connection_initialize(connection_t* connection, face_type_t type,
+                          const char* name, const char* interface_name, int fd,
+                          const address_pair_t* pair, bool local,
+                          unsigned connection_id, listener_t* listener);
 
-#ifdef WITH_POLICY
-void connection_AddTag(Connection *conn, policy_tag_t tag);
-void connection_RemoveTag(Connection *conn, policy_tag_t tag);
-policy_tags_t connection_GetTags(const Connection *conn);
-void connection_SetTags(Connection *conn, policy_tags_t tags);
-void connection_ClearTags(Connection *conn);
-int connection_HasTag(const Connection *conn, policy_tag_t tag);
-#endif /* WITH_POLICY */
+int connection_finalize(connection_t* connection);
+
+int connection_send_packet(const connection_t* connection,
+                           const uint8_t* packet, size_t size);
+
+bool connection_flush(const connection_t* connection);
+
+bool connection_send(const connection_t* connection, off_t msgbuf_id,
+                     bool queue);
+
+size_t connection_process_buffer(connection_t* connection,
+                                 const uint8_t* buffer, size_t size);
+
+/* WLDR */
+
+void connection_wldr_allow_autostart(connection_t* connection, bool value);
+
+bool connection_wldr_autostart_is_allowed(const connection_t* connection);
+
+void connection_wldr_enable(connection_t* connection, bool value);
+
+bool connection_has_wldr(const connection_t* connection);
+
+void connection_wldr_detect_losses(const connection_t* connection,
+                                   const msgbuf_t* msgbuf);
+
+void connection_wldr_handle_notification(const connection_t* connection,
+                                         const msgbuf_t* msgbuf);
+
+#define connection_get_listener(connection) (connection->listener)
 
-#endif  // connection_h
+#endif /* HICNLIGHT_CONNECTION_H */
diff --git a/hicn-light/src/hicn/core/connectionList.c b/hicn-light/src/hicn/core/connectionList.c
deleted file mode 100644
index d51a9aad5..000000000
--- a/hicn-light/src/hicn/core/connectionList.c
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_ArrayList.h>
-#include <parc/algol/parc_Memory.h>
-
-#include <parc/assert/parc_Assert.h>
-#include <hicn/core/connectionList.h>
-
-struct connection_list {
-  PARCArrayList *listOfConnections;
-};
-
-static void connectionList_ArrayDestroyer(void **voidPtr) {
-  Connection **entryPtr = (Connection **)voidPtr;
-  connection_Release(entryPtr);
-}
-
-ConnectionList *connectionList_Create() {
-  ConnectionList *list = parcMemory_AllocateAndClear(sizeof(ConnectionList));
-  parcAssertNotNull(list, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(ConnectionList));
-  list->listOfConnections = parcArrayList_Create(connectionList_ArrayDestroyer);
-  return list;
-}
-
-void connectionList_Destroy(ConnectionList **listPtr) {
-  parcAssertNotNull(listPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*listPtr, "Parameter must dereference to non-null pointer");
-  ConnectionList *list = *listPtr;
-  parcArrayList_Destroy(&list->listOfConnections);
-  parcMemory_Deallocate((void **)&list);
-  *listPtr = NULL;
-}
-
-void connectionList_Append(ConnectionList *list, Connection *entry) {
-  parcAssertNotNull(list, "Parameter list must be non-null");
-  parcAssertNotNull(entry, "Parameter entry must be non-null");
-
-  parcArrayList_Add(list->listOfConnections, connection_Acquire(entry));
-}
-
-size_t connectionList_Length(const ConnectionList *list) {
-  parcAssertNotNull(list, "Parameter list must be non-null");
-  return parcArrayList_Size(list->listOfConnections);
-}
-
-Connection *connectionList_Get(ConnectionList *list, size_t index) {
-  parcAssertNotNull(list, "Parameter list must be non-null");
-  Connection *original =
-      (Connection *)parcArrayList_Get(list->listOfConnections, index);
-  return original;
-}
diff --git a/hicn-light/src/hicn/core/connectionList.h b/hicn-light/src/hicn/core/connectionList.h
deleted file mode 100644
index fbba9f6d8..000000000
--- a/hicn-light/src/hicn/core/connectionList.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * 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 connectionList.h
- * @brief A typesafe list of Connection objects
- *
- * <#Detailed Description#>
- *
- */
-
-#ifndef connectionList_h
-#define connectionList_h
-
-struct connection_list;
-typedef struct connection_list ConnectionList;
-
-#include <hicn/core/connection.h>
-
-/**
- * Creates a lis of Connection
- *
- * @return non-null An allocated list
- * @return null An error
- */
-ConnectionList *connectionList_Create(void);
-
-/**
- * Destroys the list and all objects inside it
- */
-void connectionList_Destroy(ConnectionList **listPtr);
-
-/**
- * @function connectionList_Append
- * @abstract Adds a connection entry to the list.
- * @discussion
- *   Acquires a reference to the passed entry and stores it in the list.
- */
-void connectionList_Append(ConnectionList *list, Connection *entry);
-
-/**
- * Returns the number of items on the list
- * @param [in] list The allocated list to check
- * @return number The number of items on the list
- */
-size_t connectionList_Length(const ConnectionList *list);
-
-/**
- * @function connectionList_Get
- * @abstract Returns the connection entry.
- * @discussion
- *   Caller must not destroy the returned value.  If you will store the
- *   entry in your own data structure, you should acquire your own reference.
- *   Will assert if you go beyond the end of the list.
- *
- */
-Connection *connectionList_Get(ConnectionList *list, size_t index);
-#endif  // connectionList_h
diff --git a/hicn-light/src/hicn/core/connectionManager.c b/hicn-light/src/hicn/core/connectionManager.c
deleted file mode 100644
index 709f0902a..000000000
--- a/hicn-light/src/hicn/core/connectionManager.c
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * The Connection Manager sets itself up as a listener to the Messenger so it
- * can take action based on system events.
- *
- * The Connection Manager queues and then processes in a later time slice the
- * messages.
- *
- */
-
-#include <hicn/hicn-light/config.h>
-#include <hicn/core/connectionManager.h>
-#include <hicn/core/forwarder.h>
-#include <hicn/messenger/messenger.h>
-#include <hicn/messenger/messengerRecipient.h>
-#include <hicn/messenger/missiveDeque.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_Memory.h>
-
-#include <parc/assert/parc_Assert.h>
-
-struct connection_manager {
-  Forwarder *forwarder;
-  Logger *logger;
-
-  MessengerRecipient *messengerRecipient;
-
-  // we queue missives as they come in to process in our own
-  // event timeslice
-  MissiveDeque *missiveQueue;
-
-  // for deferred queue processing
-  PARCEventTimer *timerEvent;
-};
-
-/**
- * Receives missives from the messenger, queues them, and schedules our
- * execution
- *
- * We defer processing of missives to a later time slice
- */
-static void connectionManager_MessengerCallback(MessengerRecipient *recipient,
-                                                Missive *missive);
-
-/**
- * Event callback
- *
- * This is our main run loop to process our queue of messages.  It is scheduled
- * in {@link connectionManager_MessengerCallback} when the queue becomes
- * non-empty.
- *
- * When we are called here, we have exclusive use of the system, so we will not
- * create any message loops
- *
- * @param [in] fd unused, required for compliance with function prototype
- * @param [in] which_event unused, required for compliance with function
- * prototype
- * @param [in] connManagerVoidPtr A void* to ConnectionManager
- *
- */
-static void connectionManager_ProcessQueue(int fd, PARCEventType which_event,
-                                           void *connManagerVoidPtr);
-
-static void connectionManager_ProcessClosedMissive(
-    ConnectionManager *connManager, const Missive *missive);
-
-// ========================================================
-// Public API
-
-ConnectionManager *connectionManager_Create(Forwarder *forwarder) {
-  ConnectionManager *connManager =
-      parcMemory_AllocateAndClear(sizeof(ConnectionManager));
-  parcAssertNotNull(connManager,
-                    "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(ConnectionManager));
-  connManager->forwarder = forwarder;
-  connManager->missiveQueue = missiveDeque_Create();
-  connManager->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-
-  Messenger *messenger = forwarder_GetMessenger(connManager->forwarder);
-
-  // creates the timer, but does not start it
-  PARCEventScheduler *base =
-      dispatcher_GetEventScheduler(forwarder_GetDispatcher(forwarder));
-  connManager->timerEvent = parcEventTimer_Create(
-      base, 0, connectionManager_ProcessQueue, connManager);
-
-  connManager->messengerRecipient = messengerRecipient_Create(
-      connManager, connectionManager_MessengerCallback);
-  messenger_Register(messenger, connManager->messengerRecipient);
-  return connManager;
-}
-
-void connectionManager_Destroy(ConnectionManager **managerPtr) {
-  parcAssertNotNull(managerPtr, "Double pointer must be non-null");
-  parcAssertNotNull(*managerPtr, "Double pointer must dereference to non-null");
-
-  ConnectionManager *connManager = *managerPtr;
-
-  Messenger *messenger = forwarder_GetMessenger(connManager->forwarder);
-  parcEventTimer_Destroy(&(connManager->timerEvent));
-  messenger_Unregister(messenger, connManager->messengerRecipient);
-  messengerRecipient_Destroy(&connManager->messengerRecipient);
-  missiveDeque_Release(&connManager->missiveQueue);
-  logger_Release(&connManager->logger);
-
-  parcMemory_Deallocate((void **)&connManager);
-  *managerPtr = NULL;
-}
-
-// ========================================================
-// Internal Functions
-
-static void connectionManager_MessengerCallback(MessengerRecipient *recipient,
-                                                Missive *missive) {
-  ConnectionManager *connManager =
-      messengerRecipient_GetRecipientContext(recipient);
-
-  // we do not release our reference count, we store it until later
-  // We are called with our own reference, so we do not need to acquire the
-  // missive here.
-  missiveDeque_Append(connManager->missiveQueue, missive);
-
-  if (missiveDeque_Size(connManager->missiveQueue) == 1) {
-    // When it becomes non-empty, schedule {@link
-    // connectionManager_ProcessQueue}
-    struct timeval immediateTimeout = {0, 0};
-    parcEventTimer_Start(connManager->timerEvent, &immediateTimeout);
-  }
-}
-
-static void connectionManager_ProcessQueue(int fd, PARCEventType which_event,
-                                           void *connManagerVoidPtr) {
-  ConnectionManager *connManager = (ConnectionManager *)connManagerVoidPtr;
-
-  Missive *missive;
-  while ((missive = missiveDeque_RemoveFirst(connManager->missiveQueue)) !=
-         NULL) {
-    switch (missive_GetType(missive)) {
-      case MissiveType_ConnectionCreate:
-        // hook to signal that a new connection was created
-        break;
-      case MissiveType_ConnectionUp:
-        // hook to signal that a new connection is up
-        break;
-      case MissiveType_ConnectionDown:
-        // hook to signal that a connection is down
-        break;
-      case MissiveType_ConnectionClosed:
-        connectionManager_ProcessClosedMissive(connManager, missive);
-        break;
-      case MissiveType_ConnectionDestroyed:
-        // hook to signal that a connection was destroyed
-        break;
-      default:
-        parcTrapUnexpectedState("Missive %p of unknown type: %d",
-                                (void *)missive, missive_GetType(missive));
-    }
-    missive_Release(&missive);
-  }
-}
-
-static void connectionManager_ProcessClosedMissive(
-    ConnectionManager *connManager, const Missive *missive) {
-  logger_Log(connManager->logger, LoggerFacility_Core, PARCLogLevel_Debug,
-             __func__, "Processing CLOSED message for connid %u",
-             missive_GetConnectionId(missive));
-
-  ConnectionTable *table = forwarder_GetConnectionTable(connManager->forwarder);
-  const Connection *conn =
-      connectionTable_FindById(table, missive_GetConnectionId(missive));
-
-  if (conn) {
-    // this will destroy the connection if its the last reference count
-    connectionTable_Remove(table, conn);
-
-    // remove from FIB
-    forwarder_RemoveConnectionIdFromRoutes(connManager->forwarder,
-                                           missive_GetConnectionId(missive));
-  }
-}
diff --git a/hicn-light/src/hicn/core/connectionManager.h b/hicn-light/src/hicn/core/connectionManager.h
deleted file mode 100644
index 34fee8717..000000000
--- a/hicn-light/src/hicn/core/connectionManager.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * 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 connectionManager.h
- * @brief The connection manager handles connection events, such as going down
- *
- * The connection manager listens to the event notification system.  Based on
- * those events, the connection manager will take specific actions.  This is
- * expected to be a singleton instantiated by the forwarder.
- *
- */
-
-#ifndef connectionManager_h
-#define connectionManager_h
-
-#include <hicn/core/forwarder.h>
-
-struct connection_manager;
-typedef struct connection_manager ConnectionManager;
-
-ConnectionManager *connectionManager_Create(Forwarder *forwarder);
-
-void connectionManager_Destroy(ConnectionManager **managerPtr);
-#endif  // connectionManager_h
diff --git a/hicn-light/src/hicn/core/connectionTable.c b/hicn-light/src/hicn/core/connectionTable.c
deleted file mode 100644
index f8589c12b..000000000
--- a/hicn-light/src/hicn/core/connectionTable.c
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * @header ConnectionTable
- * @abstract Records all the current connections and references to them
- * @discussion
- *
- */
-
-#ifndef _WIN32
-#include <unistd.h>
-#endif
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_ArrayList.h>
-#include <parc/algol/parc_Hash.h>
-#include <parc/algol/parc_HashCodeTable.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_TreeRedBlack.h>
-#include <hicn/core/connectionTable.h>
-#include <hicn/io/addressPair.h>
-
-struct connection_table {
-  // The main storage table that has a Destroy method.
-  // The key is an unsigned int pointer.  We use an unsigned int pointer
-  // because we want to be able to lookup by the id alone, and not have to
-  // have the IoOperations everywhere.
-  PARCHashCodeTable *storageTableById;
-
-  // The key is a AddressPair
-  // It does not have a destroy method for the data or key,
-  // as they are derived from the storage table.
-  PARCHashCodeTable *indexByAddressPair;
-
-  // An iterable stucture organized by connection id.  The keys and
-  // values are the same pointers as in storageTableById, so there
-  // are no destructors in the tree.
-  // The only reason to keep this tree is so we have an iterable list
-  // of connections, which the hash table does not give us.
-  PARCTreeRedBlack *listById;
-};
-
-static bool connectionTable_ConnectionIdEquals(const void *keyA,
-                                               const void *keyB) {
-  unsigned idA = *((unsigned *)keyA);
-  unsigned idB = *((unsigned *)keyB);
-  return (idA == idB);
-}
-
-static int connectionTable_ConnectionIdCompare(const void *keyA,
-                                               const void *keyB) {
-  unsigned idA = *((unsigned *)keyA);
-  unsigned idB = *((unsigned *)keyB);
-  if (idA < idB) {
-    return -1;
-  }
-  if (idA > idB) {
-    return +1;
-  }
-  return 0;
-}
-
-static bool connectionTable_AddressPairEquals(const void *keyA,
-                                              const void *keyB) {
-  const AddressPair *pairA = (const AddressPair *)keyA;
-  const AddressPair *pairB = (const AddressPair *)keyB;
-
-  return addressPair_Equals(pairA, pairB);
-}
-
-static HashCodeType connectionTable_ConnectionIdHashCode(const void *keyA) {
-  unsigned idA = *((unsigned *)keyA);
-  return parcHash32_Int32(idA);
-}
-
-static HashCodeType connectionTable_AddressPairHashCode(const void *keyA) {
-  const AddressPair *pairA = (const AddressPair *)keyA;
-  return addressPair_HashCode(pairA);
-}
-
-static void connectionTable_ConnectionIdDestroyer(void **dataPtr) {
-  unsigned *idA = (unsigned *)*dataPtr;
-  parcMemory_Deallocate((void **)&idA);
-  *dataPtr = NULL;
-}
-
-static void connectionTable_ConnectionDestroyer(void **dataPtr) {
-  connection_Release((Connection **)dataPtr);
-}
-
-ConnectionTable *connectionTable_Create() {
-  size_t initialSize = 16384;
-
-  ConnectionTable *conntable =
-      parcMemory_AllocateAndClear(sizeof(ConnectionTable));
-  parcAssertNotNull(conntable, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(ConnectionTable));
-
-  conntable->storageTableById = parcHashCodeTable_Create_Size(
-      connectionTable_ConnectionIdEquals, connectionTable_ConnectionIdHashCode,
-      connectionTable_ConnectionIdDestroyer,
-      connectionTable_ConnectionDestroyer, initialSize);
-
-  // no key or data destroyer, this is an index into storageByid.
-  conntable->indexByAddressPair = parcHashCodeTable_Create_Size(
-      connectionTable_AddressPairEquals, connectionTable_AddressPairHashCode,
-      NULL, NULL, initialSize);
-
-  conntable->listById =
-      parcTreeRedBlack_Create(connectionTable_ConnectionIdCompare,
-                              NULL,   // key free
-                              NULL,   // key copy
-                              NULL,   // value equals
-                              NULL,   // value free
-                              NULL);  // value copy
-
-  return conntable;
-}
-
-void connectionTable_Destroy(ConnectionTable **conntablePtr) {
-  parcAssertNotNull(conntablePtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*conntablePtr,
-                    "Parameter must dereference to non-null pointer");
-
-  ConnectionTable *conntable = *conntablePtr;
-
-  parcTreeRedBlack_Destroy(&conntable->listById);
-  parcHashCodeTable_Destroy(&conntable->indexByAddressPair);
-  parcHashCodeTable_Destroy(&conntable->storageTableById);
-  parcMemory_Deallocate((void **)&conntable);
-  *conntablePtr = NULL;
-}
-
-/**
- * @function connectionTable_Add
- * @abstract Add a connection, takes ownership of memory
- */
-void connectionTable_Add(ConnectionTable *table, Connection *connection) {
-  parcAssertNotNull(table, "Parameter table must be non-null");
-  parcAssertNotNull(connection, "Parameter connection must be non-null");
-
-  unsigned *connectionIdKey = parcMemory_Allocate(sizeof(unsigned));
-  parcAssertNotNull(connectionIdKey, "parcMemory_Allocate(%zu) returned NULL",
-                    sizeof(unsigned));
-  *connectionIdKey = connection_GetConnectionId(connection);
-
-  if (parcHashCodeTable_Add(table->storageTableById, connectionIdKey,
-                            connection)) {
-    parcHashCodeTable_Add(table->indexByAddressPair,
-                          (void *)connection_GetAddressPair(connection),
-                          connection);
-    parcTreeRedBlack_Insert(table->listById, connectionIdKey, connection);
-  } else {
-    parcTrapUnexpectedState(
-        "Could not add connection id %u -- is it a duplicate?",
-        *connectionIdKey);
-  }
-}
-
-/**
- * @function connectionTable_Remove
- * @abstract Removes the connection, calling Destroy on our copy
- */
-void connectionTable_Remove(ConnectionTable *table,
-                            const Connection *connection) {
-  parcAssertNotNull(table, "Parameter table must be non-null");
-  parcAssertNotNull(connection, "Parameter connection must be non-null");
-
-  unsigned connid = connection_GetConnectionId(connection);
-
-  parcTreeRedBlack_Remove(table->listById, &connid);
-  parcHashCodeTable_Del(table->indexByAddressPair,
-                        connection_GetAddressPair(connection));
-  parcHashCodeTable_Del(table->storageTableById, &connid);
-}
-
-void connectionTable_RemoveById(ConnectionTable *table, unsigned id) {
-  parcAssertNotNull(table, "Parameter table must be non-null");
-  const Connection *connection = connectionTable_FindById(table, id);
-  if (connection) {
-    connectionTable_Remove(table, connection);
-  }
-}
-
-const Connection *connectionTable_FindByAddressPair(ConnectionTable *table,
-                                                    const AddressPair *pair) {
-  parcAssertNotNull(table, "Parameter table must be non-null");
-  return (Connection *)parcHashCodeTable_Get(table->indexByAddressPair, pair);
-}
-
-const Connection *connectionTable_FindById(const ConnectionTable *table,
-                                           unsigned id) {
-  parcAssertNotNull(table, "Parameter table must be non-null");
-  return (Connection *)parcHashCodeTable_Get(table->storageTableById, &id);
-}
-
-ConnectionList *connectionTable_GetEntries(const ConnectionTable *table) {
-  parcAssertNotNull(table, "Parameter table must be non-null");
-  ConnectionList *list = connectionList_Create();
-
-  PARCArrayList *values = parcTreeRedBlack_Values(table->listById);
-  for (size_t i = 0; i < parcArrayList_Size(values); i++) {
-    Connection *original = parcArrayList_Get(values, i);
-    connectionList_Append(list, original);
-  }
-  parcArrayList_Destroy(&values);
-  return list;
-}
diff --git a/hicn-light/src/hicn/core/connectionTable.h b/hicn-light/src/hicn/core/connectionTable.h
deleted file mode 100644
index 548ef8e6e..000000000
--- a/hicn-light/src/hicn/core/connectionTable.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * 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 connectionTable_h
-#define connectionTable_h
-
-#include <hicn/core/connection.h>
-#include <hicn/core/connectionList.h>
-#include <hicn/io/addressPair.h>
-#include <hicn/io/ioOperations.h>
-
-struct connection_table;
-typedef struct connection_table ConnectionTable;
-
-/**
- * Creates an empty connection table
- */
-ConnectionTable *connectionTable_Create(void);
-
-/**
- * Destroys the connection table
- * This will release the reference to all connections stored in the connection
- * table.
- * @param [in,out] conntablePtr Pointer to the allocated connection table, will
- * be NULL'd
- */
-void connectionTable_Destroy(ConnectionTable **conntablePtr);
-
-/**
- * @function connectionTable_Add
- * @abstract Add a connection, takes ownership of memory
- */
-void connectionTable_Add(ConnectionTable *table, Connection *connection);
-
-/**
- * @function connectionTable_Remove
- * @abstract Removes the connection, calling Destroy on our copy
- */
-void connectionTable_Remove(ConnectionTable *table,
-                            const Connection *connection);
-
-/**
- * Removes a connection from the connection table
- *
- * Looks up a connection by its connection ID and removes it from the connection
- * table. Removing the connection will call connection_Release() on the
- * connection object.
- *
- * @param [in] table The allocated connection table
- * @param [in] id The connection ID
- */
-void connectionTable_RemoveById(ConnectionTable *table, unsigned id);
-
-/**
- * Lookup a connection by the (local, remote) addres pair
- *
- * @param [in] table The allocated connection table
- * @param [in] pair The address pair to match, based on the inner values of the
- * local and remote addresses
- *
- * @retval non-null The matched conneciton
- * @retval null No match found or error
- */
-const Connection *connectionTable_FindByAddressPair(ConnectionTable *table,
-                                                    const AddressPair *pair);
-
-/**
- * @function connectionTable_FindById
- * @abstract Find a connection by its numeric id.
- * @return NULL if not found
- */
-const Connection *connectionTable_FindById(const ConnectionTable *table, unsigned id);
-
-/**
- * @function connectionTable_GetEntries
- * @abstract Returns a list of connections.  They are reference counted copies
- * from the table.
- * @discussion
- *   An allocated list of connections in the table.  Each list entry is a
- * reference counted copy of the connection in the table, thus they are "live"
- * objects.
- */
-ConnectionList *connectionTable_GetEntries(const ConnectionTable *table);
-#endif  // connectionTable_h
diff --git a/hicn-light/src/hicn/core/connection_table.c b/hicn-light/src/hicn/core/connection_table.c
new file mode 100644
index 000000000..09236ae8e
--- /dev/null
+++ b/hicn-light/src/hicn/core/connection_table.c
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file connection_table.c
+ * \brief Implementation of hICN connection table
+ */
+
+#include <hicn/util/log.h>
+
+#include "connection.h"
+#include "connection_table.h"
+
+/* This is only used as a hint for first allocation, as the table is resizeable
+ */
+#define DEFAULT_CONNECTION_TABLE_SIZE 64
+
+connection_table_t *_connection_table_create(size_t init_size,
+                                             size_t max_size) {
+  if (init_size == 0) init_size = DEFAULT_CONNECTION_TABLE_SIZE;
+
+  connection_table_t *table = malloc(sizeof(connection_table_t));
+  if (!table) return NULL;
+
+  table->max_size = max_size;
+
+  /* Initialize indices */
+  table->id_by_pair = kh_init_ct_pair();
+  table->id_by_name = kh_init_ct_name();
+
+  /*
+   * We start by allocating a reasonably-sized pool, as this will eventually
+   * be resized if needed.
+   */
+  pool_init(table->connections, init_size, 0);
+
+  return table;
+}
+
+void connection_table_free(connection_table_t *table) {
+  const char *k_name;
+  const address_pair_t *k_pair;
+  unsigned v_conn_id;
+
+  connection_t *connection;
+  const char *name;
+  kh_foreach(table->id_by_name, k_name, v_conn_id, {
+    connection = connection_table_get_by_id(table, v_conn_id);
+    name = connection_get_name(connection);
+    INFO("Removing connection %s [%d]", name, connection->fd);
+    connection_finalize(connection);
+  });
+
+  (void)v_conn_id;
+  kh_foreach(table->id_by_name, k_name, v_conn_id, { free((char *)k_name); });
+  kh_foreach(table->id_by_pair, k_pair, v_conn_id,
+             { free((address_pair_t *)k_pair); });
+
+  kh_destroy_ct_pair(table->id_by_pair);
+  kh_destroy_ct_name(table->id_by_name);
+  pool_free(table->connections);
+  free(table);
+}
+
+connection_t *connection_table_get_by_pair(const connection_table_t *table,
+                                           const address_pair_t *pair) {
+  khiter_t k = kh_get_ct_pair(table->id_by_pair, pair);
+  if (k == kh_end(table->id_by_pair)) return NULL;
+  return table->connections + kh_val(table->id_by_pair, k);
+}
+
+off_t connection_table_get_id_by_name(const connection_table_t *table,
+                                      const char *name) {
+  khiter_t k = kh_get_ct_name(table->id_by_name, name);
+  if (k == kh_end(table->id_by_name)) return CONNECTION_ID_UNDEFINED;
+  return kh_val(table->id_by_name, k);
+}
+
+connection_t *connection_table_get_by_name(const connection_table_t *table,
+                                           const char *name) {
+  unsigned conn_id = connection_table_get_id_by_name(table, name);
+  if (!connection_id_is_valid(conn_id)) return NULL;
+  return connection_table_at(table, conn_id);
+}
+
+void connection_table_remove_by_id(connection_table_t *table, off_t id) {
+  connection_t *connection = connection_table_at(table, id);
+  INFO("Removing connection %d (%s)", id, connection_get_name(connection));
+
+  connection_table_deallocate(table, connection);
+}
+
+void connection_table_print_by_pair(const connection_table_t *table) {
+  const address_pair_t *k;
+  unsigned v;
+
+  char local_addr_str[NI_MAXHOST], remote_addr_str[NI_MAXHOST];
+  int local_port, remote_port;
+  connection_t *connection;
+  const char *name;
+
+  INFO("*** Connection table ***");
+  kh_foreach(table->id_by_pair, k, v, {
+    address_to_string(&(k->local), local_addr_str, &local_port);
+    address_to_string(&(k->remote), remote_addr_str, &remote_port);
+    connection = connection_table_get_by_id(table, v);
+    name = connection_get_name(connection);
+    INFO("(%s:%d - %s:%d)\t\t\t(%u, %s)", local_addr_str, local_port,
+         remote_addr_str, remote_port, v, name);
+  })
+}
+
+void connection_table_print_by_name(const connection_table_t *table) {
+  const char *k;
+  unsigned v;
+
+  connection_t *connection;
+  const char *name;
+
+  INFO("*** Connection table ***");
+  kh_foreach(table->id_by_name, k, v, {
+    connection = connection_table_get_by_id(table, v);
+    name = connection_get_name(connection);
+    INFO("(%s)\t\t\t(%u, %s)", k, v, name);
+  })
+}
+
+connection_t *_connection_table_get_by_id(connection_table_t *table, off_t id) {
+  return connection_table_get_by_id(table, id);
+}
+
+#define RANDBYTE() (u8)(rand() & 0xFF)
+
+char *connection_table_get_random_name(const connection_table_t *table) {
+  char *connection_name = malloc(SYMBOLIC_NAME_LEN * sizeof(char));
+  u8 rand_num;
+
+  /* Generate a random connection name */
+  while (1) {
+    rand_num = RANDBYTE();
+    int rc = snprintf(connection_name, SYMBOLIC_NAME_LEN, "conn%u", rand_num);
+    _ASSERT(rc < SYMBOLIC_NAME_LEN);
+
+    // Return if connection name does not already exist
+    khiter_t k = kh_get_ct_name(table->id_by_name, connection_name);
+    if (k == kh_end(table->id_by_name)) break;
+  }
+
+  return connection_name;
+}
\ No newline at end of file
diff --git a/hicn-light/src/hicn/core/connection_table.h b/hicn-light/src/hicn/core/connection_table.h
new file mode 100644
index 000000000..4c03aa642
--- /dev/null
+++ b/hicn-light/src/hicn/core/connection_table.h
@@ -0,0 +1,297 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file connection_table.h
+ * \brief hICN connection_table
+ *
+ * The connection table is composed of :
+ *  - a pool of connections allowing access through their id in constant time;
+ *  - a set of indices in the form of hash table for efficient index lookups:
+ *     . by name
+ *     . by address pair
+ *
+ * For efficient index retrieval, the header will be prepended and the
+ * resulting pointer will directly point to the connection pool.
+ */
+
+#ifndef HICNLIGHT_CONNECTION_TABLE_H
+#define HICNLIGHT_CONNECTION_TABLE_H
+
+#include "address_pair.h"
+#include "connection.h"
+#include "../base/hash.h"
+#include "../base/khash.h"
+#include "../base/pool.h"
+
+#define _ct_var(x) _ct_var_##x
+
+/* Hash functions for indices. */
+#define address_pair_hash(pair) (hash_struct(pair))
+#define address_pair_hash_eq(a, b) \
+  (address_pair_hash(b) == address_pair_hash(a))
+
+/* Hash table types for indices. */
+KHASH_INIT(ct_pair, const address_pair_t *, unsigned, 1, address_pair_hash,
+           address_pair_hash_eq);
+KHASH_MAP_INIT_STR(ct_name, unsigned);
+
+typedef struct {
+  size_t max_size;
+
+  kh_ct_pair_t *id_by_pair;
+  kh_ct_name_t *id_by_name;
+
+  connection_t *connections;  // pool
+} connection_table_t;
+
+/**
+ * @brief Allocate a connection from the connection table.
+ *
+ * @param[in] table The connection table from which to allocate a connection.
+ * @param[out] connection The pointer that will hold the allocated connection.
+ * @param[in] pair The address pair associated to the connection (to update
+ * index).
+ * @param[in] name The name associated to the connection (to update index).
+ *
+ * NOTE:
+ *  - This function updates all indices from the connection table if the
+ *  allocation is successful.
+ *  - You should always check that the returned connection is not NULL, which
+ *  would signal that the pool is exhausted and could not be extended.
+ */
+static inline connection_t *connection_table_allocate(
+    const connection_table_t *table, const address_pair_t *pair,
+    const char *name) {
+  connection_t *conn;
+  pool_get(table->connections, conn);
+
+  if (conn) {
+    off_t id = conn - table->connections;
+    int res;
+    khiter_t k;
+
+    // Add in name hash table
+    k = kh_put_ct_name(table->id_by_name, strdup(name), &res);
+    kh_value(table->id_by_name, k) = id;
+
+    // Add in pair hash table
+    address_pair_t *pair_copy =
+        (address_pair_t *)malloc(sizeof(address_pair_t));
+    memcpy(pair_copy, pair, sizeof(address_pair_t));
+
+    k = kh_put_ct_pair(table->id_by_pair, pair_copy, &res);
+    assert(res != -1);
+    kh_value(table->id_by_pair, k) = id;
+  }
+
+  return conn;
+}
+
+/**
+ * @brief Deallocate a connection and return it to the connection table pool.
+ *
+ * @param[in] table The connection table to which the connection is returned.
+ * @param[in] conn The connection that is returned to the pool.
+ *
+ * NOTE:
+ *  - Upon returning a connection to the pool, all indices pointing to that
+ *  connection are also cleared.
+ */
+static inline void connection_table_deallocate(const connection_table_t *table,
+                                               const connection_t *conn) {
+  const char *name = connection_get_name(conn);
+  const address_pair_t *pair = connection_get_pair(conn);
+  khiter_t k;
+
+  // Remove from name hash table
+  k = kh_get_ct_name(table->id_by_name, name);
+  assert(k != kh_end(table->id_by_name));
+  free((char *)kh_key(table->id_by_name, k));
+  kh_del_ct_name(table->id_by_name, k);
+
+  // Remove from pair hash table
+  k = kh_get_ct_pair(table->id_by_pair, pair);
+  assert(k != kh_end(table->id_by_pair));
+  free((address_pair_t *)kh_key(table->id_by_pair, k));
+  kh_del_ct_pair(table->id_by_pair, k);
+
+  pool_put(table->connections, conn);
+}
+
+/**
+ * @brief Returns the length of the connection table, the number of active
+ * connections.
+ *
+ * @param[in] table The connection table for which we retrieve the length.
+ *
+ * @return size_t The length of the connection table.
+ *
+ * NOTE:
+ *  - The length of the connection table, that is the number of currently active
+ *  connections.
+ */
+#define connection_table_len(table) (pool_len(table->connections))
+
+/**
+ * @brief Validate an index in the connection table.
+ *
+ * @param[in] table The connection table in which to validate an index.
+ * @param[in] id The index of the connection to validate.
+ *
+ * @return bool A flag indicating whether the connection index is valid or not.
+ */
+#define connection_table_validate_id(table, id) \
+  pool_validate_id((table)->connections, (id))
+
+/**
+ * @brief Return the connection corresponding to the specified index in the
+ * connection table.
+ *
+ * @param[in] table The connection table for which to retrieve the connection.
+ * @param[in] id The index for which to retrieve the connection.
+ *
+ * @return connection_t * The connection correponding to the specified index in
+ * the connection table.
+ *
+ * @see connection_table_get_by_id
+ *
+ * NOTE:
+ *  - In this function, the index is not validated.
+ */
+#define connection_table_at(table, id) ((table)->connections + id)
+
+/**
+ * @brief Return the connection corresponding to the specified and validated
+ * index in the connection table.
+ *
+ * @param[in] table The connection table for which to retrieve the connection.
+ * @param[in] id The index for which to retrieve the connection.
+ *
+ * @return connection_t * The connection correponding to the specified index in
+ * the connection table.
+ *
+ * @see connection_table_get_by_id
+ *
+ * NOTE:
+ *  - In this function, the index is validated.
+ */
+#define connection_table_get_by_id(table, id)                              \
+  connection_table_validate_id(table, id) ? connection_table_at(table, id) \
+                                          : NULL
+
+/**
+ * @brief Helper function to avoid macro expansion in c++ tests. Wrapper around
+ * 'connection_table_get_by_id'.
+ */
+connection_t *_connection_table_get_by_id(connection_table_t *table, off_t id);
+
+/**
+ * @brief Returns the index of a given connection in the connection table.
+ *
+ * @param[in] table The connection table from which to retrieve the index.
+ * @param[in] conn The connection for which to retrieve the index.
+ *
+ * @return off_t The index of the specified connection in the connection table.
+ */
+#define connection_table_get_connection_id(table, conn) \
+  (conn - table->connections)
+
+#define connection_table_foreach(table, conn, BODY) \
+  pool_foreach(table->connections, (conn), BODY)
+
+#define connection_table_enumerate(table, i, conn, BODY) \
+  pool_enumerate(table->connections, (i), (conn), BODY)
+
+/**
+ * @brief Create a new connection table (extended parameters).
+ *
+ * @param[in] init_size Initially allocated size (hint, 0 = use default value).
+ * @param[in] max_size Maximum size (0 = unlimited).
+ *
+ * @return connection_table_t* The newly created connection table.
+ */
+connection_table_t *_connection_table_create(size_t init_size, size_t max_size);
+
+/**
+ * @brief Create a new connection table (minimal parameters).
+ *
+ * @return connection_table_t* The newly created connection table.
+ */
+#define connection_table_create() _connection_table_create(0, 0)
+
+/**
+ * @brief Free a connection table
+ *
+ * @param[in] table Connection table to free
+ */
+void connection_table_free(connection_table_t *table);
+
+/**
+ * @brief Retrieve a connection from the connection table by address pair.
+ *
+ * @param[in] table The connection table in which to search.
+ * @param[in] pair The address pair to search for.
+ *
+ * @return connection_t * The connection matching the specified address pair, or
+ * NULL if not found.
+ */
+connection_t *connection_table_get_by_pair(const connection_table_t *table,
+                                           const address_pair_t *pair);
+
+/**
+ * @brief Return a connection index from the connection table by name.
+ *
+ * @param[in] table The connection table in which to search.
+ * @param[in] name The name to search for.
+ *
+ * @return off_t The index of the connection matching the name, or
+ * CONNECTION_ID_UNDEFINED if not found.
+ */
+off_t connection_table_get_id_by_name(const connection_table_t *table,
+                                      const char *name);
+
+/**
+ * @brief Return a connection from the connection table by name.
+ *
+ * @param[in] table The connection table in which to search.
+ * @param[in] name The name to search for.
+ *
+ * @return connection_t * The connection matching the name, or NULL if not
+ * found.
+ */
+connection_t *connection_table_get_by_name(const connection_table_t *table,
+                                           const char *name);
+
+/**
+ * @brief Remove a connection from the connection table by its index.
+ *
+ * @param[in] table The connection table from which to delete the connection.
+ * @param[in] id The index of the connection to remove.
+ */
+void connection_table_remove_by_id(connection_table_t *table, off_t id);
+
+/**
+ * @brief Print the connection table content.
+ *
+ * @param[in] table The connection table to print.
+ */
+void connection_table_print_by_pair(const connection_table_t *table);
+
+void connection_table_print_by_name(const connection_table_t *table);
+
+char *connection_table_get_random_name(const connection_table_t *table);
+
+#endif /* HICNLIGHT_CONNECTION_TABLE_H */
diff --git a/hicn-light/src/hicn/core/connection_vft.c b/hicn-light/src/hicn/core/connection_vft.c
new file mode 100644
index 000000000..fe97096d3
--- /dev/null
+++ b/hicn-light/src/hicn/core/connection_vft.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file connection_vft.c
+ * @brief Implementation of connection VFT
+ */
+
+#include "connection_vft.h"
+
+#ifdef __linux
+extern connection_ops_t connection_hicn;
+#endif
+
+extern connection_ops_t connection_tcp;
+extern connection_ops_t connection_udp;
+
+const connection_ops_t *connection_vft[] = {
+#ifdef __linux
+    [FACE_PROTOCOL_HICN] = &connection_hicn,
+#endif
+
+    [FACE_PROTOCOL_TCP] = &connection_tcp,
+    [FACE_PROTOCOL_UDP] = &connection_udp,
+};
diff --git a/hicn-light/src/hicn/core/connection_vft.h b/hicn-light/src/hicn/core/connection_vft.h
new file mode 100644
index 000000000..e6290cdd4
--- /dev/null
+++ b/hicn-light/src/hicn/core/connection_vft.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file connection_vft.h
+ * @brief Connection VFT
+ */
+
+#ifndef HICNLIGHT_CONNECTION_VFT_H
+#define HICNLIGHT_CONNECTION_VFT_H
+
+#include "connection.h"
+
+typedef struct {
+  int (*initialize)(connection_t* connection);
+  void (*finalize)(connection_t* connection);
+  int (*get_socket)(const listener_t* listener, const address_t* local,
+                    const address_t* remote, const char* interface_name);
+  bool (*flush)(const connection_t* connection);
+  bool (*send)(const connection_t* connection, msgbuf_t* msgbuf, bool queue);
+  int (*send_packet)(const connection_t* connection, const uint8_t* packet,
+                     size_t size);
+  // void (*read_callback)(connection_t * connection, int fd, void * data);
+  size_t data_size;
+} connection_ops_t;
+
+#define DECLARE_CONNECTION(NAME)                       \
+  const connection_ops_t connection_##NAME = {         \
+      .initialize = connection_##NAME##_initialize,    \
+      .finalize = connection_##NAME##_finalize,        \
+      .get_socket = listener_##NAME##_get_socket,      \
+      .flush = connection_##NAME##_flush,              \
+      .send = connection_##NAME##_send,                \
+      .send_packet = connection_##NAME##_send_packet,  \
+      .data_size = sizeof(connection_##NAME##_data_t), \
+  };
+
+//    .read_callback = connection_ ## NAME ## _read_callback,
+
+extern const connection_ops_t* connection_vft[];
+
+#endif /* HICNLIGHT_CONNECTION_VFT_H */
diff --git a/hicn-light/src/hicn/core/content_store.c b/hicn-light/src/hicn/core/content_store.c
new file mode 100644
index 000000000..edbdc5ac1
--- /dev/null
+++ b/hicn-light/src/hicn/core/content_store.c
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file content_store.c
+ * \brief Implementation of hICN content_store
+ */
+
+#include "content_store.h"
+#include "packet_cache.h"
+
+extern const cs_ops_t cs_lru;
+
+const cs_ops_t *const cs_vft[] = {
+    [CS_TYPE_LRU] = &cs_lru,
+};
+
+cs_t *_cs_create(cs_type_t type, size_t max_size) {
+  if (!CS_TYPE_VALID(type)) {
+    ERROR("[cs_create] Invalid content store type");
+    return NULL;
+  }
+
+  if (max_size == 0) max_size = DEFAULT_CS_SIZE;
+
+  cs_t *cs = malloc(sizeof(cs_t));
+  if (!cs) return NULL;
+
+  cs->type = type;
+  cs->num_entries = 0;
+  cs->max_size = max_size;
+  cs_vft[type]->initialize(cs);
+  cs->stats.lru = (cs_lru_stats_t){0};
+
+  return cs;
+}
+
+void cs_free(cs_t *cs) {
+  assert(cs);
+
+  cs_vft[cs->type]->finalize(cs);
+  free(cs);
+}
+
+void _cs_clear(cs_t **cs_ptr) {
+  cs_type_t cs_type = (*cs_ptr)->type;
+  size_t max_size = (*cs_ptr)->max_size;
+
+  // Free and recreate the CS
+  cs_free(*cs_ptr);
+  *cs_ptr = _cs_create(cs_type, max_size);
+}
+
+void cs_hit(cs_t *cs) {
+  cs->stats.lru.countHits++;
+  TRACE("ContentStore hit (hits %u, misses %u)", cs->stats.lru.countHits,
+        cs->stats.lru.countMisses);
+}
+
+void cs_miss(cs_t *cs) {
+  cs->stats.lru.countMisses++;
+  TRACE("ContentStore miss (hits %u, misses %u)", cs->stats.lru.countHits,
+        cs->stats.lru.countMisses);
+}
+
+void cs_log(cs_t *cs) {
+  DEBUG(
+      "Content store: size = %u, capacity = %u, hits = %u, misses = %u, adds = "
+      "%u, updates = %u, deletions = %u (with evictions = %u)",
+      cs->num_entries, cs->max_size, cs->stats.lru.countHits,
+      cs->stats.lru.countMisses, cs->stats.lru.countAdds,
+      cs->stats.lru.countUpdates, cs->stats.lru.countLruDeletions,
+      cs->stats.lru.countLruEvictions);
+}
diff --git a/hicn-light/src/hicn/core/content_store.h b/hicn-light/src/hicn/core/content_store.h
new file mode 100644
index 000000000..d47d603be
--- /dev/null
+++ b/hicn-light/src/hicn/core/content_store.h
@@ -0,0 +1,106 @@
+#ifndef HICNLIGHT_CS_H
+#define HICNLIGHT_CS_H
+
+#include "../base/pool.h"
+#include "../content_store/lru.h"
+#include "msgbuf_pool.h"
+
+#define INVALID_ENTRY_ID ~0ul /* off_t */
+#define DEFAULT_CS_SIZE 256   // Fixed CS size
+
+typedef struct {
+  off_t msgbuf_id;
+  struct {
+    off_t prev;
+    off_t next;
+  } lru;
+} cs_entry_t;
+
+#define cs_entry_get_msgbuf_id(entry) ((entry)->msgbuf_id)
+
+typedef enum {
+  CS_TYPE_UNDEFINED,
+  CS_TYPE_LRU,
+  CS_TYPE_N,
+} cs_type_t;
+
+#define CS_TYPE_VALID(type) (type != CS_TYPE_UNDEFINED) && (type != CS_TYPE_N)
+
+typedef struct {
+  /* The maximum allowed expiry time (will never be exceeded). */
+  uint64_t max_expiry_time;  // XXX part of lru ?
+} cs_options_t;
+
+typedef struct {
+  cs_type_t type;
+  int num_entries;
+  size_t max_size;
+  cs_lru_state_t lru;
+  union {
+    cs_lru_stats_t lru;
+  } stats;
+} cs_t;
+
+/**
+ * @brief Create a new content store  (extended parameters).
+ *
+ * @param[in] type Content store type
+ * @param[in] max_size Maximum size (0 = use default value)
+ *
+ * @return cs_t* - The newly created content store
+ */
+cs_t *_cs_create(cs_type_t type, size_t max_size);
+
+/**
+ * @brief Create a new content store
+ *
+ * @param[in] size Maximum content store size
+ *
+ * @return cs_t* - The newly created content store
+ */
+#define cs_create(size) _cs_create(CS_TYPE_LRU, (size))
+
+/**
+ * @brief Free a content store data structure.
+ *
+ * @param[in] pool_ptr Pointer to the content store to free
+ */
+void cs_free(cs_t *cs);
+
+/**
+ * @brief Clear the content of the content store (helper).
+ *
+ * @param[in, out] cs Pointer to the content store to clear
+ */
+void _cs_clear(cs_t **cs);
+
+/**
+ * @brief Clear the content of the content store.
+ *
+ * @param[in, out] cs Pointer to the content store to clear
+ */
+#define cs_clear(cs) _cs_clear((cs_t **)&cs);
+
+/**
+ * @brief Update content store statistics upon CS hit event.
+ *
+ * @param[in] cs Pointer to the content store to use
+ */
+void cs_hit(cs_t *cs);
+
+/**
+ * @brief Update content store statistics upon CS miss event.
+ *
+ * @param[in] cs Pointer to the content store to use
+ */
+void cs_miss(cs_t *cs);
+
+/**
+ * @brief Log content store statistics, e.g. the CS current and maximum size,
+ * the number of matches, misses, add operations, update operations, evictions.
+ *
+ * @param cs Pointer to the CS data structure to use
+ */
+void cs_log(cs_t *cs);
+
+#endif /* HICNLIGHT_CS_H */
diff --git a/hicn-light/src/hicn/core/dispatcher.c b/hicn-light/src/hicn/core/dispatcher.c
deleted file mode 100644
index 59951e950..000000000
--- a/hicn-light/src/hicn/core/dispatcher.c
+++ /dev/null
@@ -1,474 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * @header dispatcher.c
- * @abstract Event dispatcher for hicn-light.  Uses parcEvent
- * @discussion
- *     Wraps the functions we use in parcEvent, along with StreamBuffer and
- * Message. The dispatcher is the event loop, so it manages things like signals,
- * timers, and network events.
- */
-
-#ifndef _WIN32
-#include <arpa/inet.h>
-#include <sys/socket.h>
-#include <unistd.h>
-#endif
-#include <errno.h>
-#include <fcntl.h>
-#include <signal.h>
-#include <hicn/hicn-light/config.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#include <parc/algol/parc_EventQueue.h>
-#include <parc/algol/parc_EventTimer.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <hicn/core/dispatcher.h>
-
-#include <pthread.h>
-
-#ifndef INPORT_ANY
-#define INPORT_ANY 0
-#endif
-
-struct dispatcher {
-  PARCEventScheduler *Base;
-  Logger *logger;
-};
-
-// ==========================================
-// Public API
-
-PARCEventScheduler *dispatcher_GetEventScheduler(Dispatcher *dispatcher) {
-  return dispatcher->Base;
-}
-
-Dispatcher *dispatcher_Create(Logger *logger) {
-  Dispatcher *dispatcher = parcMemory_AllocateAndClear(sizeof(Dispatcher));
-  parcAssertNotNull(dispatcher,
-                    "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Dispatcher));
-
-  dispatcher->Base = parcEventScheduler_Create();
-  dispatcher->logger = logger_Acquire(logger);
-
-  parcAssertNotNull(dispatcher->Base,
-                    "Got NULL from parcEventScheduler_Create()");
-
-  return dispatcher;
-}
-
-void dispatcher_Destroy(Dispatcher **dispatcherPtr) {
-  parcAssertNotNull(dispatcherPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*dispatcherPtr,
-                    "Parameter must dereference to non-null pointer");
-  Dispatcher *dispatcher = *dispatcherPtr;
-
-  logger_Release(&dispatcher->logger);
-  parcEventScheduler_Destroy(&(dispatcher->Base));
-  parcMemory_Deallocate((void **)&dispatcher);
-  *dispatcherPtr = NULL;
-}
-
-void dispatcher_Stop(Dispatcher *dispatcher) {
-  struct timeval delay = {0, 1000};
-
-  parcEventScheduler_Stop(dispatcher->Base, &delay);
-}
-
-void dispatcher_Run(Dispatcher *dispatcher) {
-  parcAssertNotNull(dispatcher, "Parameter must be non-null");
-
-  parcEventScheduler_Start(dispatcher->Base, 0);
-}
-
-void dispatcher_RunDuration(Dispatcher *dispatcher, struct timeval *duration) {
-  parcAssertNotNull(dispatcher, "Parameter dispatcher must be non-null");
-  parcAssertNotNull(duration, "Parameter duration must be non-null");
-
-  parcEventScheduler_Stop(dispatcher->Base, duration);
-  parcEventScheduler_Start(dispatcher->Base, 0);
-}
-
-void dispatcher_RunCount(Dispatcher *dispatcher, unsigned count) {
-  parcAssertNotNull(dispatcher, "Parameter must be non-null");
-
-  for (unsigned i = 0; i < count; i++) {
-    parcEventScheduler_Start(dispatcher->Base,
-                             PARCEventSchedulerDispatchType_LoopOnce);
-  }
-}
-
-PARCEventSocket *dispatcher_CreateListener(Dispatcher *dispatcher,
-                                           PARCEventSocket_Callback *callback,
-                                           void *user_data, int backlog,
-                                           const struct sockaddr *sa,
-                                           int socklen) {
-  PARCEventSocket *listener = parcEventSocket_Create(
-      dispatcher->Base, callback, NULL, user_data, sa, socklen);
-  if (listener == NULL) {
-    perror("Problem creating listener");
-  }
-  return listener;
-}
-
-void dispatcher_DestroyListener(Dispatcher *dispatcher,
-                                PARCEventSocket **listenerPtr) {
-  parcAssertNotNull(listenerPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*listenerPtr,
-                    "Parameter must dereference to non-null pointer");
-  parcEventSocket_Destroy(listenerPtr);
-}
-
-PARCEventQueue *dispatcher_CreateStreamBufferFromSocket(Dispatcher *dispatcher,
-                                                        SocketType fd) {
-  parcAssertNotNull(dispatcher, "Parameter dispatcher must be non-null");
-  PARCEventQueue *buffer = parcEventQueue_Create(
-      dispatcher->Base, fd,
-      PARCEventQueueOption_CloseOnFree | PARCEventQueueOption_DeferCallbacks);
-  parcAssertNotNull(buffer,
-                    "Got null from parcEventBufver_Create for socket %d", fd);
-  return buffer;
-}
-
-PARCEventTimer *dispatcher_CreateTimer(Dispatcher *dispatcher, bool isPeriodic,
-                                       PARCEvent_Callback *callback,
-                                       void *userData) {
-  parcAssertNotNull(dispatcher, "Parameter dispatcher must be non-null");
-  parcAssertNotNull(callback, "Parameter callback must be non-null");
-
-  PARCEventType flags = 0;
-  if (isPeriodic) {
-    flags |= PARCEventType_Persist;
-  }
-  PARCEventTimer *event =
-      parcEventTimer_Create(dispatcher->Base, flags, callback, userData);
-  return event;
-}
-
-void dispatcher_StartTimer(Dispatcher *dispatcher, PARCEventTimer *timerEvent,
-                           struct timeval *delay) {
-  parcAssertNotNull(dispatcher, "Parameter dispatcher must be non-null");
-  parcAssertNotNull(timerEvent, "Parameter timerEvent must be non-null");
-  int failure = parcEventTimer_Start(timerEvent, delay);
-  parcAssertFalse(failure < 0, "Error starting timer event %p: (%d) %s",
-                  (void *)timerEvent, errno, strerror(errno));
-}
-
-void dispatcher_StopTimer(Dispatcher *dispatcher, PARCEventTimer *event) {
-  parcAssertNotNull(dispatcher, "Parameter dispatcher must be non-null");
-  parcAssertNotNull(event, "Parameter event must be non-null");
-
-  int failure = parcEventTimer_Stop(event);
-  parcAssertFalse(failure < 0, "Error stopping signal event %p: (%d) %s",
-                  (void *)event, errno, strerror(errno));
-}
-
-void dispatcher_DestroyTimerEvent(Dispatcher *dispatcher,
-                                  PARCEventTimer **eventPtr) {
-  parcAssertNotNull(dispatcher, "Parameter dispatcher must be non-null");
-  parcAssertNotNull(eventPtr,
-                    "Parameter eventPtr must be non-null double pointer");
-  parcAssertNotNull(*eventPtr,
-                    "Paramter eventPtr must dereference to non-null pointer");
-
-  parcEventTimer_Destroy(eventPtr);
-  eventPtr = NULL;
-}
-
-PARCEvent *dispatcher_CreateNetworkEvent(Dispatcher *dispatcher,
-                                         bool isPersistent,
-                                         PARCEvent_Callback *callback,
-                                         void *userData, int fd) {
-  short flags = PARCEventType_Timeout | PARCEventType_Read;
-  if (isPersistent) {
-    flags |= PARCEventType_Persist;
-  }
-
-  PARCEvent *event =
-      parcEvent_Create(dispatcher->Base, fd, flags, callback, userData);
-  parcAssertNotNull(event, "Got null from parcEvent_Create for socket %d", fd);
-  return event;
-}
-
-void dispatcher_DestroyNetworkEvent(Dispatcher *dispatcher,
-                                    PARCEvent **eventPtr) {
-  parcAssertNotNull(dispatcher, "Parameter dispatcher must be non-null");
-  parcAssertNotNull(eventPtr,
-                    "Parameter eventPtr must be non-null double pointer");
-  parcAssertNotNull(*eventPtr,
-                    "Paramter eventPtr must dereference to non-null pointer");
-
-  parcEvent_Destroy(eventPtr);
-  eventPtr = NULL;
-}
-
-void dispatcher_StartNetworkEvent(Dispatcher *dispatcher, PARCEvent *event) {
-  parcAssertNotNull(dispatcher, "Parameter dispatcher must be non-null");
-  parcAssertNotNull(event, "Parameter event must be non-null");
-
-  int failure = parcEvent_Start(event);
-  parcAssertFalse(failure < 0, "Error starting signal event %p: (%d) %s",
-                  (void *)event, errno, strerror(errno));
-}
-
-void dispatcher_StopNetworkEvent(Dispatcher *dispatcher, PARCEvent *event) {
-  parcAssertNotNull(dispatcher, "Parameter dispatcher must be non-null");
-  parcAssertNotNull(event, "Parameter event must be non-null");
-
-  int failure = parcEvent_Stop(event);
-  parcAssertFalse(failure < 0, "Error stopping signal event %p: (%d) %s",
-                  (void *)event, errno, strerror(errno));
-}
-
-PARCEventSignal *dispatcher_CreateSignalEvent(
-    Dispatcher *dispatcher, PARCEventSignal_Callback *callback, void *userData,
-    int signal) {
-  parcAssertNotNull(dispatcher, "Parameter dispatcher must be non-null");
-  parcAssertNotNull(callback, "Parameter callback must be non-null");
-
-  PARCEventSignal *event = parcEventSignal_Create(
-      dispatcher->Base, signal, PARCEventType_Signal | PARCEventType_Persist,
-      callback, userData);
-  parcAssertNotNull(event,
-                    "Got null event when creating signal catcher for signal %d",
-                    signal);
-
-  return event;
-}
-
-void dispatcher_DestroySignalEvent(Dispatcher *dispatcher,
-                                   PARCEventSignal **eventPtr) {
-  parcAssertNotNull(dispatcher, "Parameter dispatcher must be non-null");
-  parcAssertNotNull(eventPtr,
-                    "Parameter eventPtr must be non-null double pointer");
-  parcAssertNotNull(*eventPtr,
-                    "Paramter eventPtr must dereference to non-null pointer");
-
-  parcEventSignal_Destroy(eventPtr);
-  eventPtr = NULL;
-}
-
-void dispatcher_StartSignalEvent(Dispatcher *dispatcher,
-                                 PARCEventSignal *event) {
-  parcAssertNotNull(dispatcher, "Parameter dispatcher must be non-null");
-  parcAssertNotNull(event, "Parameter event must be non-null");
-
-  int failure = parcEventSignal_Start(event);
-  parcAssertFalse(failure < 0, "Error starting signal event %p: (%d) %s",
-                  (void *)event, errno, strerror(errno));
-}
-
-void dispatcher_StopSignalEvent(Dispatcher *dispatcher,
-                                PARCEventSignal *event) {
-  parcAssertNotNull(dispatcher, "Parameter dispatcher must be non-null");
-  parcAssertNotNull(event, "Parameter event must be non-null");
-
-  int failure = parcEventSignal_Stop(event);
-  parcAssertFalse(failure < 0, "Error stopping signal event %p: (%d) %s",
-                  (void *)event, errno, strerror(errno));
-}
-
-/**
- * Bind to a local address/port then connect to peer.
- */
-static bool dispatcher_StreamBufferBindAndConnect(Dispatcher *dispatcher,
-                                                  PARCEventQueue *buffer,
-                                                  struct sockaddr *localSock,
-                                                  socklen_t localSockLength,
-                                                  struct sockaddr *remoteSock,
-                                                  socklen_t remoteSockLength) {
-  // we need to bind, then connect.  Special operation, so we make our
-  // own fd then pass it off to the buffer event
-
-#ifndef _WIN32
-  int fd = socket(localSock->sa_family, SOCK_STREAM, 0);
-  if (fd < 0) {
-    perror("socket");
-    return -1;
-  }
-
-  // Set non-blocking flag
-  int flags = fcntl(fd, F_GETFL, NULL);
-  if (flags < 0) {
-    perror("F_GETFL");
-    close(fd);
-    return -1;
-  }
-  int failure = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
-  if (failure) {
-    perror("F_SETFL");
-    close(fd);
-    return -1;
-  }
-
-  failure = bind(fd, localSock, localSockLength);
-  if (failure) {
-    perror("bind");
-    close(fd);
-    return false;
-  }
-
-  parcEventQueue_SetFileDescriptor(buffer, fd);
-
-  failure = parcEventQueue_ConnectSocket(buffer, remoteSock, remoteSockLength);
-  if (failure && (errno != EINPROGRESS)) {
-    perror("connect");
-    close(fd);
-    return false;
-  }
-#else
-  SOCKET fd = socket(localSock->sa_family, SOCK_STREAM, 0);
-  if (fd == INVALID_SOCKET) {
-    perror("socket");
-    return -1;
-  }
-
-  // Set non-blocking flag
-  u_long mode = 1;
-  int result = ioctlsocket(fd, FIONBIO, &mode);
-  if (result == NO_ERROR) {
-    perror("ioctlsocket error");
-    closesocket(fd);
-    WSACleanup();
-    return -1;
-  }
-
-  int failure = bind(fd, localSock, (int)localSockLength);
-  if (failure) {
-    perror("bind");
-    closesocket(fd);
-    WSACleanup();
-    return false;
-  }
-
-  parcEventQueue_SetFileDescriptor(buffer, (int)fd);
-
-  failure = parcEventQueue_ConnectSocket(buffer, remoteSock, remoteSockLength);
-  if (failure && (errno != EINPROGRESS)) {
-    perror("connect");
-    closesocket(fd);
-    WSACleanup();
-    return false;
-  }
-#endif
-
-  return true;
-}
-
-/**
- * Connect to an INET peer
- * @return NULL on error, otherwise a streambuffer
- */
-static PARCEventQueue *dispatcher_StreamBufferConnect_INET(
-    Dispatcher *dispatcher, const Address *localAddress,
-    const Address *remoteAddress) {
-  struct sockaddr_in localSock, remoteSock;
-  addressGetInet(localAddress, &localSock);
-  addressGetInet(remoteAddress, &remoteSock);
-
-  PARCEventQueue *buffer = parcEventQueue_Create(
-      dispatcher->Base, -1, PARCEventQueueOption_CloseOnFree);
-  parcAssertNotNull(buffer, "got null buffer from parcEventQueue_Create()");
-
-  bool success = dispatcher_StreamBufferBindAndConnect(
-      dispatcher, buffer, (struct sockaddr *)&localSock, sizeof(localSock),
-      (struct sockaddr *)&remoteSock, sizeof(remoteSock));
-  if (!success) {
-    parcEventQueue_Destroy(&buffer);
-    buffer = NULL;
-  }
-
-  return buffer;
-}
-
-/**
- * Connect to an INET peer
- * @return NULL on error, otherwise a streambuffer
- */
-static PARCEventQueue *
-// static StreamBuffer *
-dispatcher_StreamBufferConnect_INET6(Dispatcher *dispatcher,
-                                     const Address *localAddress,
-                                     const Address *remoteAddress) {
-  struct sockaddr_in6 localSock, remoteSock;
-  addressGetInet6(localAddress, &localSock);
-  addressGetInet6(remoteAddress, &remoteSock);
-
-  PARCEventQueue *buffer = parcEventQueue_Create(
-      dispatcher->Base, -1, PARCEventQueueOption_CloseOnFree);
-  parcAssertNotNull(buffer, "got null buffer from parcEventQueue_Create()");
-
-  bool success = dispatcher_StreamBufferBindAndConnect(
-      dispatcher, buffer, (struct sockaddr *)&localSock, sizeof(localSock),
-      (struct sockaddr *)&remoteSock, sizeof(remoteSock));
-  if (!success) {
-    parcEventQueue_Destroy(&buffer);
-    buffer = NULL;
-  }
-
-  return buffer;
-}
-
-PARCEventQueue *dispatcher_StreamBufferConnect(Dispatcher *dispatcher,
-                                               const AddressPair *pair) {
-  const Address *localAddress = addressPair_GetLocal(pair);
-  const Address *remoteAddress = addressPair_GetRemote(pair);
-
-  // they must be of the same address family
-  if (addressGetType(localAddress) != addressGetType(remoteAddress)) {
-    char message[2048];
-    char *localAddressString = addressToString(localAddress);
-    char *remoteAddressString = addressToString(remoteAddress);
-    snprintf(message, 2048,
-             "Remote address not same type as local address, expected %d got "
-             "%d\nlocal %s remote %s",
-             addressGetType(localAddress), addressGetType(remoteAddress),
-             localAddressString, remoteAddressString);
-
-    parcMemory_Deallocate((void **)&localAddressString);
-    parcMemory_Deallocate((void **)&remoteAddressString);
-
-    parcAssertTrue(
-        addressGetType(localAddress) == addressGetType(remoteAddress), "%s",
-        message);
-  }
-
-  address_type type = addressGetType(localAddress);
-
-  PARCEventQueue *result = NULL;
-
-  switch (type) {
-    case ADDR_INET:
-      return dispatcher_StreamBufferConnect_INET(dispatcher, localAddress,
-                                                 remoteAddress);
-      break;
-    case ADDR_INET6:
-      return dispatcher_StreamBufferConnect_INET6(dispatcher, localAddress,
-                                                  remoteAddress);
-      break;
-    default:
-      parcTrapIllegalValue(type, "local address unsupported address type: %d",
-                           type);
-  }
-  return result;
-}
diff --git a/hicn-light/src/hicn/core/dispatcher.h b/hicn-light/src/hicn/core/dispatcher.h
deleted file mode 100644
index e5c2df336..000000000
--- a/hicn-light/src/hicn/core/dispatcher.h
+++ /dev/null
@@ -1,288 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * @header hicn-light Dispatcher
- * @abstract The dispatcher is the event loop run by Forwarder.
- * @discussion
- *     These functions manage listeners, timers, and network events inside
- *     the event loop.
- *
- *     Curently, it is a thin wrapper around an event so we don't have to
- *     expose that implementation detail to other modules.
- *
- */
-
-#ifndef dispatcher_h
-#define dispatcher_h
-
-#ifndef _WIN32
-#include <sys/socket.h>
-#endif
-#include <stdbool.h>
-
-struct dispatcher;
-typedef struct dispatcher Dispatcher;
-
-#include <parc/algol/parc_Event.h>
-#include <parc/algol/parc_EventQueue.h>
-#include <parc/algol/parc_EventScheduler.h>
-#include <parc/algol/parc_EventSignal.h>
-#include <parc/algol/parc_EventSocket.h>
-#include <parc/algol/parc_EventTimer.h>
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/core/logger.h>
-
-PARCEventScheduler *dispatcher_GetEventScheduler(Dispatcher *dispatcher);
-/**
- * Creates an event dispatcher
- *
- * Event dispatcher based on PARCEvent
- *
- * @return non-null Allocated event dispatcher
- * @return null An error
- */
-Dispatcher *dispatcher_Create(Logger *logger);
-
-/**
- * Destroys event dispatcher
- *
- * Caller is responsible for destroying call events before destroying
- * the event dispatcher.
- */
-void dispatcher_Destroy(Dispatcher **dispatcherPtr);
-
-/**
- * @function dispatcher_Stop
- * @abstract Called from a different thread, tells the dispatcher to stop
- * @discussion
- *   Called from a user thread or from an interrupt handler.
- *   Does not block.  Use <code>dispatcher_WaitForStopped()</code> to
- *   block until stopped after calling this.
- */
-void dispatcher_Stop(Dispatcher *dispatcher);
-
-/**
- * @function dispatcher_WaitForStopped
- * @abstract Blocks until dispatcher in stopped state
- * @discussion
- *   Used after <code>dispatcher_Stop()</code> to wait for stop.
- */
-void dispatcher_WaitForStopped(Dispatcher *dispatcher);
-
-/**
- * @function dispatcher_Run
- * @abstract Runs the forwarder, blocks.
- */
-void dispatcher_Run(Dispatcher *dispatcher);
-
-/**
- * @function dispatcher_RunDuration
- * @abstract Runs forwarder for at most duration, blocks.
- * @discussion
- *   Blocks running the forwarder for a duration.  May be called
- *   iteratively to keep running.  Duration is a minimum, actual
- *   runtime may be slightly longer.
- */
-void dispatcher_RunDuration(Dispatcher *dispatcher, struct timeval *duration);
-
-/**
- * @header dispatcher_RunCount
- * @abstract Run the event loop for the given count cycles
- * @discussion
- *     Runs the event loop for the given number of cycles, blocking
- *     until done.  May be called sequentially over and over.
- *
- */
-void dispatcher_RunCount(Dispatcher *dispatcher, unsigned count);
-
-typedef int SocketType;
-
-typedef struct evconnlistener Listener;
-
-/**
- * @typedef ListenerCallback
- * @abstract Callback function typedef for a stream listener
- *
- * @constant listener is the object created by <code>forwarder_NewBind()</code>
- * that received the client connection
- * @constant client_socket is the client socket
- * @constant user_data is the user_data passed to
- * <code>forwarder_NewBind()</code>
- * @constant client_addr is the client address
- * @constant socklen is the length of client_addr
- * @discussion <#Discussion#>
- */
-typedef void(ListenerCallback)(Listener *listener, SocketType client_socket,
-                               struct sockaddr *client_addr, int socklen,
-                               void *user_data);
-
-/**
- * @header forwarder_NewBind
- * @abstract Allocate a new stream listener
- * @discussion
- *     The server socket will be freed when closed and will be reusable.
- *
- * @param forwarder that owns the event loop
- * @param cb is the callback for a new connection
- * @param user_data is opaque user data passed to the callback
- * @param backlog is the listen() depth, may use -1 for a default value
- * @param sa is the socket address to bind to (INET, INET6, LOCAL)
- * @param socklen is the sizeof the actual sockaddr (e.g. sizeof(sockaddr_un))
- */
-PARCEventSocket *dispatcher_CreateListener(Dispatcher *dispatcher,
-                                           PARCEventSocket_Callback *callback,
-                                           void *user_data, int backlog,
-                                           const struct sockaddr *sa,
-                                           int socklen);
-
-void dispatcher_DestroyListener(Dispatcher *dispatcher,
-                                PARCEventSocket **listenerPtr);
-
-typedef struct event TimerEvent;
-typedef struct event NetworkEvent;
-typedef struct event SignalEvent;
-
-/**
- * @typedef EventCallback
- * @abstract A network event or a timer callback
- * @constant fd The file descriptor associated with the event, may be -1 for
- * timers
- * @constant which_event is a bitmap of the EventType
- * @constant user_data is the user_data passed to
- * <code>Forwarder_CreateEvent()</code>
- */
-typedef void(EventCallback)(SocketType fd, short which_event, void *user_data);
-
-/**
- * @function dispatcher_CreateTimer
- * @abstract Creates a Event for use as a timer.
- * @discussion
- *
- *   When created, the timer is idle and you need to call
- * <code>forwarder_StartTimer()</code>
- *
- * @param isPeriodic means the timer will fire repeatidly, otherwise it is a
- * one-shot and needs to be set again with <code>dispatcher_StartTimer()</code>
- */
-PARCEventTimer *dispatcher_CreateTimer(Dispatcher *dispatcher, bool isPeriodic,
-                                       PARCEvent_Callback *callback,
-                                       void *userData);
-
-/**
- * @function dispatcher_StartTimer
- * @abstract Starts the timer with the given delay.
- * @discussion
- *   If the timer is periodic, it will keep firing with the given delay
- */
-void dispatcher_StartTimer(Dispatcher *dispatcher, PARCEventTimer *timerEvent,
-                           struct timeval *delay);
-
-void dispatcher_StopTimer(Dispatcher *dispatcher, PARCEventTimer *timerEvent);
-
-/**
- * @function dispatcher_DestroyTimerEvent
- * @abstract Cancels the timer and frees the event
- */
-void dispatcher_DestroyTimerEvent(Dispatcher *dispatcher,
-                                  PARCEventTimer **eventPtr);
-
-/**
- * @function dispatcher_CreateNetworkEvent
- * @abstract Creates a network event callback on the socket
- * @discussion
- *   May be used on any sort of file descriptor or socket.  The event is edge
- * triggered and non-reentrent. This means you need to drain the events off the
- * socket, as the callback will not be called again until a new event arrives.
- *
- *   When created, the event is idle and you need to call
- * <code>forwarder_StartNetworkEvent()</code>
- *
- * @param isPersistent means the callback will keep firing with new events,
- * otherwise its a one-shot
- * @param fd is the socket to monitor
- */
-PARCEvent *dispatcher_CreateNetworkEvent(Dispatcher *dispatcher,
-                                         bool isPersistent,
-                                         PARCEvent_Callback *callback,
-                                         void *userData, int fd);
-
-void dispatcher_StartNetworkEvent(Dispatcher *dispatcher, PARCEvent *event);
-void dispatcher_StopNetworkEvent(Dispatcher *dispatcher, PARCEvent *event);
-
-void dispatcher_DestroyNetworkEvent(Dispatcher *dispatcher,
-                                    PARCEvent **eventPtr);
-
-/**
- * @function dispatcher_CreateSignalEvent
- * @abstract Creates a signal trap
- * @discussion
- *   May be used on catchable signals.  The event is edge triggered and
- * non-reentrent.  Signal events are persistent.
- *
- *   When created, the signal trap is idle and you need to call
- * <code>forwarder_StartSignalEvent()</code>
- *
- * @param signal is the system signal to monitor (e.g. SIGINT).
- * @return <#return#>
- */
-PARCEventSignal *dispatcher_CreateSignalEvent(
-    Dispatcher *dispatcher, PARCEventSignal_Callback *callback, void *userData,
-    int signal);
-
-void dispatcher_DestroySignalEvent(Dispatcher *dispatcher,
-                                   PARCEventSignal **eventPtr);
-
-void dispatcher_StartSignalEvent(Dispatcher *dispatcher,
-                                 PARCEventSignal *event);
-void dispatcher_StopSignalEvent(Dispatcher *dispatcher, PARCEventSignal *event);
-
-// =============
-// stream buffers
-
-#include <hicn/core/streamBuffer.h>
-#include <hicn/io/addressPair.h>
-
-/**
- * @function dispatcher_CreateStreamBuffer
- * @abstract Creates a high-function buffer around a stream socket
- */
-PARCEventQueue *dispatcher_CreateStreamBufferFromSocket(Dispatcher *dispatcher,
-                                                        SocketType fd);
-
-/**
- * @function dispatcher_StreamBufferConnect
- * @abstract Create a TCP tunnel to a remote peer
- * @discussion
- *   For TCP, both address pairs need to be the same address family: both INET
- * or both INET6.  The remote address must have the complete socket information
- * (address, port).  The local socket could be wildcarded or may specify down to
- * the (address, port) pair.
- *
- *   If the local address is IPADDR_ANY and the port is 0, then it is a normal
- * call to "connect" that will use whatever local IP address and whatever local
- * port for the connection.  If either the address or port is set, the local
- * socket will first be bound (via bind(2)), and then call connect().
- *
- *   It is unlikely that the buffer will be connected by the time the function
- * returns.  The eventCallback will fire once the remote system accepts the
- * conneciton.
- *
- * @return NULL on error, otherwise a streambuffer.
- */
-PARCEventQueue *dispatcher_StreamBufferConnect(Dispatcher *dispatcher,
-                                               const AddressPair *pair);
-#endif  // dispatcher_h
diff --git a/hicn-light/src/hicn/core/fib.c b/hicn-light/src/hicn/core/fib.c
new file mode 100644
index 000000000..d8d3c7cfa
--- /dev/null
+++ b/hicn-light/src/hicn/core/fib.c
@@ -0,0 +1,478 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <hicn/hicn-light/config.h>
+#include <stdio.h>
+
+#include <hicn/core/fib.h>
+
+typedef struct fib_node_s {
+  struct fib_node_s *left;
+  struct fib_node_s *right;
+  fib_entry_t *entry;
+  bool is_used;
+} fib_node_t;
+
+static fib_node_t *fib_node_create(fib_node_t *left, fib_node_t *right,
+                                   fib_entry_t *entry, bool is_used) {
+  fib_node_t *node = malloc(sizeof(fib_node_t));
+  if (!node) return NULL;
+
+  *node = (fib_node_t){
+      .left = left,
+      .right = right,
+      .entry = entry,
+      .is_used = is_used,
+  };
+
+  return node;
+}
+
+static void fib_node_free(fib_node_t *node) {
+  if (!node) return;
+
+  fib_node_free(node->right);
+  fib_node_free(node->left);
+
+  fib_entry_free(node->entry);
+  free(node);
+}
+
+/******************************************************************************/
+
+struct fib_s {
+  void *forwarder;
+  fib_node_t *root;
+  unsigned size;
+};
+
+fib_t *fib_create(void *forwarder) {
+  fib_t *fib = malloc(sizeof(fib_t));
+  if (!fib) return NULL;
+
+  fib->forwarder = forwarder;
+  fib->root = NULL;
+  fib->size = 0;
+
+  return fib;
+}
+
+void fib_free(fib_t *fib) {
+  assert(fib);
+
+  fib_node_free(fib->root);
+
+  free(fib);
+}
+
+size_t fib_get_size(const fib_t *fib) {
+  assert(fib);
+  return fib->size;
+}
+
+#define FIB_SET(CURR, NEW_PREFIX, CURR_PREFIX_LEN)                      \
+  do {                                                                  \
+    bool bit;                                                           \
+    int res = nameBitvector_testBit(NEW_PREFIX, CURR_PREFIX_LEN, &bit); \
+    assert(res >= 0);                                                   \
+    (void)res; /* unused */                                             \
+    CURR = bit ? CURR->right : CURR->left;                              \
+  } while (0)
+
+#define FIB_INSERT(DST, SRC, PREFIX, PREFIX_LEN)               \
+  do {                                                         \
+    bool bit;                                                  \
+    int res = nameBitvector_testBit(PREFIX, PREFIX_LEN, &bit); \
+    assert(res >= 0);                                          \
+    (void)res; /* unused */                                    \
+    if (bit)                                                   \
+      DST->right = SRC;                                        \
+    else                                                       \
+      DST->left = SRC;                                         \
+  } while (0)
+
+void fib_add(fib_t *fib, fib_entry_t *entry) {
+  assert(fib);
+  assert(entry);
+
+  NameBitvector *new_prefix = name_GetContentName(fib_entry_get_prefix(entry));
+  uint32_t new_prefix_len = nameBitvector_GetLength(new_prefix);
+  fib_node_t *curr = fib->root;
+  fib_node_t *last = NULL;
+
+  NameBitvector *curr_name;
+  uint32_t curr_prefix_len;
+  uint32_t match_len;
+
+  while (curr) {
+    curr_name = name_GetContentName(fib_entry_get_prefix(curr->entry));
+
+    match_len = nameBitvector_lpm(new_prefix, curr_name);
+    curr_prefix_len = nameBitvector_GetLength(curr_name);
+
+    if (curr_prefix_len !=
+            match_len ||  // the new entry does not match the curr
+        curr_prefix_len >=
+            new_prefix_len)  // in this case we cannot procede anymore
+      break;
+
+    last = curr;
+    FIB_SET(curr, new_prefix, curr_prefix_len);
+  }
+
+  // this is the root (empty trie) or an empty child
+  if (!curr) {
+    fib_node_t *new_node = fib_node_create(NULL, NULL, entry, true);
+    if (!last) {
+      fib->root = new_node;
+    } else {
+      uint32_t last_prefix_len = nameBitvector_GetLength(
+          name_GetContentName(fib_entry_get_prefix(last->entry)));
+
+      FIB_INSERT(last, new_node, new_prefix, last_prefix_len);
+    }
+    fib->size++;
+    return;
+  }
+
+  // curr is not null
+
+  // the node already exist
+  // if is not in use we turn it on and we set the rigth fib entry
+  if (curr_prefix_len == match_len && new_prefix_len == match_len) {
+    if (!curr->is_used) {
+      curr->is_used = true;
+      curr->entry = entry;
+      fib->size++;
+      return;
+    } else {
+      // this case should never happen beacuse of the way we add
+      // entries in the fib
+      const nexthops_t *nexthops = fib_entry_get_nexthops(entry);
+      unsigned nexthop;
+      nexthops_foreach(nexthops, nexthop,
+                       { fib_entry_nexthops_add(curr->entry, nexthop); });
+    }
+  }
+
+  // key is prefix of the curr node (so new_prefix_len < curr_prefix_len)
+  if (new_prefix_len == match_len) {
+    fib_node_t *new_node = fib_node_create(NULL, NULL, entry, true);
+    if (!last) {
+      fib->root = new_node;
+    } else {
+      uint32_t last_prefix_len = nameBitvector_GetLength(
+          name_GetContentName(fib_entry_get_prefix(last->entry)));
+      FIB_INSERT(last, new_node, new_prefix, last_prefix_len);
+    }
+    FIB_INSERT(new_node, curr, curr_name, match_len);
+    fib->size++;
+    return;
+  }
+
+  // in the last case we need to add an inner node
+  Name inner_prefix = EMPTY_NAME;
+  name_Copy(fib_entry_get_prefix(entry), &inner_prefix);
+  nameBitvector_clear(name_GetContentName(&inner_prefix), match_len);
+  name_setLen(&inner_prefix, match_len);
+
+  // this is an inner node, we don't want an acctive strategy
+  // like low_latency that sends probes in this node
+  fib_entry_t *inner_entry = fib_entry_create(
+      &inner_prefix, STRATEGY_TYPE_UNDEFINED, NULL, fib->forwarder);
+
+  fib_node_t *inner_node = fib_node_create(NULL, NULL, inner_entry, false);
+  fib_node_t *new_node = fib_node_create(NULL, NULL, entry, true);
+
+  if (!last) {
+    // we need to place the inner_node at the root
+    fib->root = inner_node;
+  } else {
+    uint32_t last_prefix_len = nameBitvector_GetLength(
+        name_GetContentName(fib_entry_get_prefix(last->entry)));
+    NameBitvector *inner_name = name_GetContentName(&inner_prefix);
+    FIB_INSERT(last, inner_node, inner_name, last_prefix_len);
+  }
+
+  bool bit;
+  int res = nameBitvector_testBit(new_prefix, match_len, &bit);
+  assert(res >= 0);
+  (void)res; /* unused */
+  inner_node->left = bit ? curr : new_node;
+  inner_node->right = bit ? new_node : curr;
+  fib->size++;
+}
+
+fib_entry_t *fib_contains(const fib_t *fib, const Name *prefix) {
+  assert(fib);
+  assert(prefix);
+
+  NameBitvector *key_name = name_GetContentName(prefix);
+  uint32_t key_prefix_len = nameBitvector_GetLength(key_name);
+
+  fib_node_t *curr = fib->root;
+
+  while (curr) {
+    NameBitvector *curr_name =
+        name_GetContentName(fib_entry_get_prefix(curr->entry));
+    uint32_t match_len = nameBitvector_lpm(key_name, curr_name);
+    uint32_t curr_prefix_len = nameBitvector_GetLength(curr_name);
+
+    if (match_len < curr_prefix_len) {
+      // the current node does not match completelly the key, so
+      // the key is not in the trie
+      // this implies curr_prefix_len > key_prefix_len
+      return NULL;
+    }
+
+    if (curr_prefix_len == key_prefix_len) {  //== match_len
+      // this is an exact match
+      if (!curr->is_used) {
+        // the key does not exists
+        return NULL;
+      }
+      // we found the key
+      return curr->entry;
+    }
+
+    FIB_SET(curr, key_name, curr_prefix_len);
+  }
+
+  return NULL;
+}
+
+static void fib_node_remove(fib_t *fib, const Name *prefix) {
+  assert(fib);
+  assert(prefix);
+
+  NameBitvector *key_name = name_GetContentName(prefix);
+  uint32_t key_prefix_len = nameBitvector_GetLength(key_name);
+
+  fib_node_t *curr = fib->root;
+  fib_node_t *parent = NULL;
+  fib_node_t *grandpa = NULL;
+
+  uint32_t match_len;
+  uint32_t curr_prefix_len;
+
+  while (curr) {
+    NameBitvector *curr_name =
+        name_GetContentName(fib_entry_get_prefix(curr->entry));
+    match_len = nameBitvector_lpm(key_name, curr_name);
+    curr_prefix_len = nameBitvector_GetLength(curr_name);
+
+    if (match_len < curr_prefix_len || curr_prefix_len == key_prefix_len) {
+      break;
+    }
+
+    grandpa = parent;
+    parent = curr;
+
+    FIB_SET(curr, key_name, curr_prefix_len);
+  }
+
+  if (!curr || !curr->is_used || (curr_prefix_len != key_prefix_len)) {
+    // the node does not exists
+    return;
+  }
+
+  // curr has 2 children, leave it there and mark it as inner
+  if (curr->right && curr->left) {
+    curr->is_used = false;
+    fib->size--;
+    return;
+  }
+
+  // curr has no children
+  if (!curr->right && !curr->left) {
+    if (!parent) {
+      // curr is the root and is the only node in the fib
+      fib->root = NULL;
+      fib->size--;
+      fib_node_free(curr);
+      return;
+    }
+    if (!grandpa) {
+      // parent is the root
+      if (fib->root->left == curr)
+        fib->root->left = NULL;
+      else
+        fib->root->right = NULL;
+      fib->size--;
+      fib_node_free(curr);
+      return;
+    }
+    if (!parent->is_used) {
+      // parent is an inner node
+      // remove curr and inner_node (parent), connect the other child
+      // of the parent to the grandpa
+      fib_node_t *tmp = (parent->right == curr) ? parent->left : parent->right;
+
+      if (grandpa->right == parent)
+        grandpa->right = tmp;
+      else
+        grandpa->left = tmp;
+
+      fib->size--;
+      fib_node_free(curr);
+      fib_node_free(parent);
+      return;
+    }
+    // parent is node not an inner_node
+    // just remove curr the node
+    if (parent->right == curr)
+      parent->right = NULL;
+    else
+      parent->left = NULL;
+    fib->size--;
+    fib_node_free(curr);
+    return;
+  }
+
+  // curr has one child
+  if (curr->right || curr->left) {
+    if (!parent) {
+      // curr is the root
+      fib->root = fib->root->right ? fib->root->right : fib->root->left;
+      fib->size--;
+      fib_node_free(curr);
+      return;
+    }
+    // attach the child of curr to parent
+    fib_node_t *tmp = curr->right ? curr->right : curr->left;
+
+    if (parent->right == curr)
+      parent->right = tmp;
+    else
+      parent->left = tmp;
+
+    fib->size--;
+    fib_node_free(curr);
+    return;
+  }
+}
+
+void fib_remove(fib_t *fib, const Name *name, unsigned conn_id) {
+  assert(fib);
+  assert(name);
+
+  fib_entry_t *entry = fib_contains(fib, name);
+  if (!entry) return;
+
+  fib_entry_nexthops_remove(entry, conn_id);
+#ifndef WITH_MAPME
+  if (fib_entry_nexthops_len(entry) == 0) fib_node_remove(fib, name);
+#endif /* WITH_MAPME */
+}
+
+static size_t fib_node_remove_connection_id(fib_node_t *node, unsigned conn_id,
+                                            fib_entry_t **array, size_t pos) {
+  if (!node) return pos;
+  if (node->is_used) {
+    fib_entry_nexthops_remove(node->entry, conn_id);
+#ifndef WITH_MAPME
+    if (fib_entry_nexthops_len(node->entry) == 0) array[pos++] = node->entry;
+#endif /* WITH_MAPME */
+  }
+  pos = fib_node_remove_connection_id(node->right, conn_id, array, pos);
+  pos = fib_node_remove_connection_id(node->left, conn_id, array, pos);
+  return pos;
+}
+
+void fib_remove_connection_id(fib_t *fib, unsigned conn_id) {
+  assert(fib);
+
+  fib_entry_t **array = malloc(sizeof(fib_entry_t *) * fib->size);
+
+  size_t pos = 0;
+  pos = fib_node_remove_connection_id(fib->root, conn_id, array, pos);
+
+  for (int i = 0; i < pos; i++)
+    fib_node_remove(fib, fib_entry_get_prefix(array[i]));
+  free(array);
+}
+
+fib_entry_t *fib_match_message(const fib_t *fib,
+                               const msgbuf_t *interest_msgbuf) {
+  assert(fib);
+  assert(interest_msgbuf);
+
+  return fib_match_bitvector(
+      fib, name_GetContentName(msgbuf_get_name(interest_msgbuf)));
+}
+
+fib_entry_t *fib_match_name(const fib_t *fib, const Name *name) {
+  assert(fib);
+  assert(name);
+
+  return fib_match_bitvector(fib, name_GetContentName(name));
+}
+
+fib_entry_t *fib_match_bitvector(const fib_t *fib, const NameBitvector *name) {
+  assert(fib);
+  assert(name);
+
+  uint32_t key_prefix_len = nameBitvector_GetLength(name);
+
+  fib_node_t *curr = fib->root;
+  fib_node_t *candidate = NULL;
+
+  while (curr) {
+    NameBitvector *curr_name =
+        name_GetContentName(fib_entry_get_prefix(curr->entry));
+    uint32_t match_len = nameBitvector_lpm(name, curr_name);
+    uint32_t curr_prefix_len = nameBitvector_GetLength(curr_name);
+
+    if (match_len < curr_prefix_len) {
+      // the current node does not match completelly the key, so
+      // return the parent of this node (saved in candidate)
+      break;
+    }
+
+    if (curr->is_used) candidate = curr;
+
+    // if we are here match_len == curr_prefix_len (can't be larger)
+    // so this node is actually a good candidate for a match
+    if (curr_prefix_len == key_prefix_len) {
+      // this an exact match, do not continue
+      break;
+    }
+
+    FIB_SET(curr, name, curr_prefix_len);
+  }
+
+  return candidate ? candidate->entry : NULL;
+}
+
+static size_t fib_node_collect_entries(fib_node_t *node, fib_entry_t **array,
+                                       size_t pos) {
+  assert(array);
+
+  if (!node) return pos;
+
+  if (node->is_used) array[pos++] = node->entry;
+
+  pos = fib_node_collect_entries(node->right, array, pos);
+  pos = fib_node_collect_entries(node->left, array, pos);
+  return pos;
+}
+
+size_t fib_get_entry_array(const fib_t *fib, fib_entry_t ***array_p) {
+  size_t pos = 0;
+  *array_p = malloc(sizeof(fib_entry_t *) * fib->size);
+  if (!*array_p) return pos;
+  pos = fib_node_collect_entries(fib->root, *array_p, pos);
+  return pos;
+}
diff --git a/hicn-light/src/hicn/core/fib.h b/hicn-light/src/hicn/core/fib.h
new file mode 100644
index 000000000..c0fda960b
--- /dev/null
+++ b/hicn-light/src/hicn/core/fib.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HICNLIGHT_FIB_H
+#define HICNLIGHT_FIB_H
+
+#include "fib_entry.h"
+#include "msgbuf.h"
+#include "name.h"
+
+#define _fib_var(x) _fib_##x
+
+typedef struct fib_s fib_t;
+
+fib_t *fib_create(void *forwarder);
+
+void fib_free(fib_t *fib);
+
+size_t fib_get_size(const fib_t *fib);
+
+void fib_add(fib_t *fib, fib_entry_t *node);
+
+fib_entry_t *fib_contains(const fib_t *fib, const Name *prefix);
+
+void fib_remove(fib_t *fib, const Name *prefix, unsigned conn_id);
+
+void fib_remove_connection_id(fib_t *fib, unsigned conn_id);
+
+fib_entry_t *fib_match_message(const fib_t *fib,
+                               const msgbuf_t *interest_msgbuf);
+fib_entry_t *fib_match_name(const fib_t *fib, const Name *name);
+fib_entry_t *fib_match_bitvector(const fib_t *fib, const NameBitvector *name);
+
+size_t fib_get_entry_array(const fib_t *fib, fib_entry_t ***array_p);
+
+#define fib_foreach_entry(FIB, ENTRY, BODY)                            \
+  do {                                                                 \
+    fib_entry_t **_fib_var(array);                                     \
+    size_t _fib_var(n) = fib_get_entry_array((FIB), &_fib_var(array)); \
+    size_t _fib_var(i);                                                \
+    for (_fib_var(i) = 0; _fib_var(i) < _fib_var(n); _fib_var(i)++) {  \
+      ENTRY = _fib_var(array)[_fib_var(i)];                            \
+      do {                                                             \
+        BODY                                                           \
+      } while (0);                                                     \
+    }                                                                  \
+    free(_fib_var(array));                                             \
+  } while (0)
+
+#endif /* HICNLIGHT_FIB_H */
diff --git a/hicn-light/src/hicn/core/fib_entry.c b/hicn-light/src/hicn/core/fib_entry.c
new file mode 100644
index 000000000..616f12961
--- /dev/null
+++ b/hicn-light/src/hicn/core/fib_entry.c
@@ -0,0 +1,588 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+
+#include <hicn/hicn-light/config.h>
+#include <hicn/core/fib_entry.h>
+#include <hicn/core/strategy.h>
+#include <hicn/core/nameBitvector.h>
+
+#ifdef WITH_MAPME
+#include <hicn/core/ticks.h>
+#endif /* WITH_MAPME */
+
+#ifdef WITH_POLICY
+#include <hicn/core/forwarder.h>
+#include <hicn/policy.h>
+
+#ifdef WITH_MAPME
+#include <hicn/core/mapme.h>
+#endif /* WITH_MAPME */
+
+#endif /* WITH_POLICY */
+
+#ifdef WITH_POLICY_STATS
+#include <hicn/core/policy_stats.h>
+#endif /* WITH_POLICY_STATS */
+
+fib_entry_t *fib_entry_create(Name *name, strategy_type_t strategy_type,
+                              strategy_options_t *strategy_options,
+                              const forwarder_t *forwarder) {
+  assert(name);
+  assert(forwarder);
+
+  fib_entry_t *entry = malloc(sizeof(fib_entry_t));
+  if (!entry) goto ERR_MALLOC;
+
+  memset(entry, 0, sizeof(*entry));
+  name_Copy(name, &entry->name);
+  entry->nexthops = NEXTHOPS_EMPTY;
+
+  fib_entry_add_strategy_options(entry, STRATEGY_TYPE_BESTPATH, NULL);
+  fib_entry_add_strategy_options(entry, STRATEGY_TYPE_REPLICATION, NULL);
+  fib_entry_set_strategy(entry, strategy_type, strategy_options);
+
+#ifdef WITH_MAPME
+  entry->user_data = NULL;
+  entry->user_data_release = NULL;
+#endif /* WITH_MAPME */
+
+  entry->forwarder = forwarder;
+
+#ifdef WITH_POLICY
+  entry->policy = POLICY_EMPTY;
+#endif /* WITH_POLICY */
+
+#ifdef WITH_POLICY_STATS
+  entry->policy_stats = POLICY_STATS_EMPTY;
+  entry->policy_counters = POLICY_COUNTERS_EMPTY;
+#endif /* WITH_POLICY_STATS */
+
+  return entry;
+
+ERR_MALLOC:
+  return NULL;
+}
+
+void fib_entry_free(fib_entry_t *entry) {
+  assert(entry);
+#ifdef WITH_MAPME
+  if (entry->user_data) entry->user_data_release(&entry->user_data);
+#endif /* WITH_MAPME */
+  free(entry);
+}
+
+void fib_entry_add_strategy_options(fib_entry_t *entry,
+                                    strategy_type_t strategy_type,
+                                    strategy_options_t *strategy_options) {
+  // for the moment only the best path and replication strategies support
+  // strategy options return for the other strategyes
+  if (strategy_type != STRATEGY_TYPE_BESTPATH &&
+      strategy_type != STRATEGY_TYPE_REPLICATION)
+    return;
+
+  if (!strategy_options) {
+    if (strategy_type == STRATEGY_TYPE_BESTPATH) {
+      entry->strategy.options.bestpath.local_prefixes = NULL;
+    } else {
+      entry->strategy.options.replication.local_prefixes = NULL;
+    }
+    return;
+  }
+
+  local_prefixes_t *new_prefixes;
+  local_prefixes_t *curr_prefixes;
+
+  if (strategy_type == STRATEGY_TYPE_BESTPATH) {
+    new_prefixes = strategy_options->bestpath.local_prefixes;
+    curr_prefixes = entry->strategy.options.bestpath.local_prefixes;
+
+    if (!curr_prefixes) {
+      entry->strategy.options.bestpath.local_prefixes = create_local_prefixes();
+      curr_prefixes = entry->strategy.options.bestpath.local_prefixes;
+    }
+  } else {
+    new_prefixes = strategy_options->replication.local_prefixes;
+    curr_prefixes = entry->strategy.options.replication.local_prefixes;
+
+    if (!curr_prefixes) {
+      entry->strategy.options.replication.local_prefixes =
+          create_local_prefixes();
+      curr_prefixes = entry->strategy.options.replication.local_prefixes;
+    }
+  }
+
+  local_prefixes_add_prefixes(curr_prefixes, new_prefixes);
+}
+
+void fib_entry_set_strategy(fib_entry_t *entry, strategy_type_t strategy_type,
+                            strategy_options_t *strategy_options) {
+  // Default strategy if undefined
+  if (!STRATEGY_TYPE_VALID(strategy_type)) strategy_type = STRATEGY_TYPE_RANDOM;
+
+  if (entry->strategy.type == strategy_type) {  // startegy alredy set
+    if (strategy_type != STRATEGY_TYPE_BESTPATH) {
+      return;  // nothing to do
+    } else {
+      strategy_initialize(&entry->strategy, entry->forwarder);
+      return;
+    }
+  }
+
+  entry->strategy.type = strategy_type;
+  if (strategy_options) entry->strategy.options = *strategy_options;
+
+  strategy_initialize(&entry->strategy, entry->forwarder);
+}
+
+#ifdef WITH_POLICY
+
+nexthops_t *fib_entry_filter_nexthops(fib_entry_t *entry, nexthops_t *nexthops,
+                                      unsigned ingress_id, bool prefer_local) {
+  assert(entry);
+  assert(nexthops);
+
+  nexthops_reset(nexthops);
+
+  // DEBUG("[fib_entry_filter_nexthops] num=%d/%d ingress_id=%d",
+  //         nexthops_get_curlen(nexthops), nexthops_get_len(nexthops),
+  //         ingress_id);
+
+  /* Filter out ingress, down & administrative down faces */
+  const connection_table_t *table =
+      forwarder_get_connection_table(entry->forwarder);
+  connection_t *conn;
+  unsigned nexthop, i;
+  uint_fast32_t flags;
+
+  hicn_policy_t policy = fib_entry_get_policy(entry);
+
+  nexthops_enumerate(nexthops, i, nexthop, {
+    conn = connection_table_at(table, nexthop);
+    nexthops_disable_if(nexthops, i, nexthop == ingress_id);
+    nexthops_disable_if(nexthops, i,
+                        (connection_get_admin_state(conn) == FACE_STATE_DOWN));
+    nexthops_disable_if(nexthops, i,
+                        (connection_get_state(conn) == FACE_STATE_DOWN));
+  });
+
+  // DEBUG("After pruning, num=%d/%d", nexthops_get_curlen(nexthops),
+  // nexthops_get_len(nexthops));
+
+  if (prefer_local) {
+    /* Backup flags and cur_len*/
+    flags = nexthops->flags;
+    size_t cur_len = nexthops_get_curlen(nexthops);
+
+    /* Filter local */
+    nexthops_enumerate(nexthops, i, nexthop, {
+      conn = connection_table_at(table, nexthop);
+      nexthops_disable_if(nexthops, i, (!connection_is_local(conn)));
+    });
+
+    /* Local faces have priority */
+    if (nexthops_get_curlen(nexthops) > 0) return nexthops;
+
+    nexthops->flags = flags;
+    nexthops->cur_elts = cur_len;
+  }
+
+  /* Filter out local */
+  nexthops_enumerate(nexthops, i, nexthop, {
+    conn = connection_table_at(table, nexthop);
+    nexthops_disable_if(nexthops, i, (connection_is_local(conn)));
+
+    /* Policy filtering : next hops */
+    nexthops_disable_if(
+        nexthops, i,
+        (policy.tags[POLICY_TAG_WIRED].state == POLICY_STATE_REQUIRE) &&
+            (!connection_has_tag(conn, POLICY_TAG_WIRED)));
+    nexthops_disable_if(
+        nexthops, i,
+        (policy.tags[POLICY_TAG_WIRED].state == POLICY_STATE_PROHIBIT) &&
+            (connection_has_tag(conn, POLICY_TAG_WIRED)));
+    nexthops_disable_if(
+        nexthops, i,
+        (policy.tags[POLICY_TAG_WIFI].state == POLICY_STATE_REQUIRE) &&
+            (!connection_has_tag(conn, POLICY_TAG_WIFI)));
+    nexthops_disable_if(
+        nexthops, i,
+        (policy.tags[POLICY_TAG_WIFI].state == POLICY_STATE_PROHIBIT) &&
+            (connection_has_tag(conn, POLICY_TAG_WIFI)));
+    nexthops_disable_if(
+        nexthops, i,
+        (policy.tags[POLICY_TAG_CELLULAR].state == POLICY_STATE_REQUIRE) &&
+            (!connection_has_tag(conn, POLICY_TAG_CELLULAR)));
+    nexthops_disable_if(
+        nexthops, i,
+        (policy.tags[POLICY_TAG_CELLULAR].state == POLICY_STATE_PROHIBIT) &&
+            (connection_has_tag(conn, POLICY_TAG_CELLULAR)));
+    nexthops_disable_if(
+        nexthops, i,
+        (policy.tags[POLICY_TAG_TRUSTED].state == POLICY_STATE_REQUIRE) &&
+            (!connection_has_tag(conn, POLICY_TAG_TRUSTED)));
+    nexthops_disable_if(
+        nexthops, i,
+        (policy.tags[POLICY_TAG_TRUSTED].state == POLICY_STATE_PROHIBIT) &&
+            (connection_has_tag(conn, POLICY_TAG_TRUSTED)));
+  });
+
+  if (nexthops_get_curlen(nexthops) == 0) {
+    DEBUG("After REQUIRE/PROHIBIT pruning, num=%d/%d",
+          nexthops_get_curlen(nexthops), nexthops_get_len(nexthops));
+    return nexthops;
+  }
+
+  /* We have at least one matching next hop, implement heuristic */
+
+  /*
+   * As VPN connections might trigger duplicate uses of one interface, we start
+   * by filtering out interfaces based on trust status.
+   */
+  flags = nexthops->flags;
+
+  if ((policy.tags[POLICY_TAG_TRUSTED].state == POLICY_STATE_REQUIRE) ||
+      (policy.tags[POLICY_TAG_TRUSTED].state == POLICY_STATE_PREFER)) {
+    /* Try to filter out NON TRUSTED faces */
+    nexthops_enumerate(nexthops, i, nexthop, {
+      conn = connection_table_at(table, nexthop);
+      nexthops_disable_if(nexthops, i,
+                          (!connection_has_tag(conn, POLICY_TAG_TRUSTED)));
+    });
+
+    if ((nexthops_get_curlen(nexthops) == 0) &&
+        (policy.tags[POLICY_TAG_TRUSTED].state == POLICY_STATE_REQUIRE)) {
+      return nexthops;
+    }
+
+  } else {
+    /* Try to filter out TRUSTED faces */
+    nexthops_enumerate(nexthops, i, nexthop, {
+      conn = connection_table_at(table, nexthop);
+      nexthops_disable_if(nexthops, i,
+                          (connection_has_tag(conn, POLICY_TAG_TRUSTED)));
+    });
+  }
+
+  if (nexthops_get_curlen(nexthops) == 0) nexthops->flags = flags;
+
+  /* Other preferences */
+  if (policy.tags[POLICY_TAG_WIRED].state == POLICY_STATE_AVOID) {
+    nexthops_enumerate(nexthops, i, nexthop, {
+      conn = connection_table_at(table, nexthop);
+      nexthops_disable_if(nexthops, i,
+                          connection_has_tag(conn, POLICY_TAG_WIRED));
+    });
+    if (nexthops_get_curlen(nexthops) == 0) nexthops->flags = flags;
+  }
+  if (policy.tags[POLICY_TAG_WIFI].state == POLICY_STATE_AVOID) {
+    nexthops_enumerate(nexthops, i, nexthop, {
+      conn = connection_table_at(table, nexthop);
+      nexthops_disable_if(nexthops, i,
+                          connection_has_tag(conn, POLICY_TAG_WIFI));
+    });
+    if (nexthops_get_curlen(nexthops) == 0) nexthops->flags = flags;
+  }
+  if (policy.tags[POLICY_TAG_CELLULAR].state == POLICY_STATE_AVOID) {
+    nexthops_enumerate(nexthops, i, nexthop, {
+      conn = connection_table_at(table, nexthop);
+      nexthops_disable_if(nexthops, i,
+                          connection_has_tag(conn, POLICY_TAG_CELLULAR));
+    });
+    if (nexthops_get_curlen(nexthops) == 0) nexthops->flags = flags;
+  }
+
+  if (policy.tags[POLICY_TAG_WIRED].state == POLICY_STATE_PREFER) {
+    nexthops_enumerate(nexthops, i, nexthop, {
+      conn = connection_table_at(table, nexthop);
+      nexthops_disable_if(nexthops, i,
+                          !connection_has_tag(conn, POLICY_TAG_WIRED));
+    });
+    if (nexthops_get_curlen(nexthops) == 0) nexthops->flags = flags;
+  }
+  if (policy.tags[POLICY_TAG_WIFI].state == POLICY_STATE_PREFER) {
+    nexthops_enumerate(nexthops, i, nexthop, {
+      conn = connection_table_at(table, nexthop);
+      nexthops_disable_if(nexthops, i,
+                          !connection_has_tag(conn, POLICY_TAG_WIFI));
+    });
+    if (nexthops_get_curlen(nexthops) == 0) nexthops->flags = flags;
+  }
+  if (policy.tags[POLICY_TAG_CELLULAR].state == POLICY_STATE_PREFER) {
+    nexthops_enumerate(nexthops, i, nexthop, {
+      conn = connection_table_at(table, nexthop);
+      nexthops_disable_if(nexthops, i,
+                          !connection_has_tag(conn, POLICY_TAG_CELLULAR));
+    });
+    if (nexthops_get_curlen(nexthops) == 0) nexthops->flags = flags;
+  }
+
+  DEBUG("[fib_entry_filter_nexthops] before face priority num=%d/%d",
+        nexthops_get_curlen(nexthops), nexthops_get_len(nexthops));
+
+  /* Priority */
+  uint32_t max_priority = 0;
+  nexthops_foreach(nexthops, nexthop, {
+    conn = connection_table_at(table, nexthop);
+    uint32_t priority = connection_get_priority(conn);
+    if (priority > max_priority) max_priority = priority;
+  });
+  nexthops_enumerate(nexthops, i, nexthop, {
+    conn = connection_table_at(table, nexthop);
+    nexthops_disable_if(nexthops, i,
+                        connection_get_priority(conn) < max_priority);
+  });
+
+  DEBUG("[fib_entry_filter_nexthops] result num=%d/%d",
+        nexthops_get_curlen(nexthops), nexthops_get_len(nexthops));
+
+  return nexthops;
+}
+
+/*
+ * Update available next hops following policy update.
+ *
+ * The last nexthop parameter is only used if needed, otherwise the pointer to
+ * fib entry is returned to avoid an useless copy
+ */
+nexthops_t *fib_entry_get_available_nexthops(fib_entry_t *entry,
+                                             unsigned ingress_id,
+                                             nexthops_t *new_nexthops) {
+  // DEBUG("[fib_entry_get_available_nexthops]");
+
+  connection_table_t *table = forwarder_get_connection_table(entry->forwarder);
+
+  /*
+   * Give absolute preference to local faces, with no policy, unless
+   * ingress_id == ~0, which means we are searching faces on which to
+   * advertise our prefix
+   */
+  if (ingress_id == ~0) {
+    assert(new_nexthops);
+    /* We create a nexthop structure based on connections */
+    // XXX This should be done close to where it is needed
+    connection_t *connection;
+    connection_table_foreach(table, connection, {
+      if (connection_is_local(connection)) continue;
+      new_nexthops->elts[nexthops_get_len(new_nexthops)] =
+          connection_table_get_connection_id(table, connection);
+      nexthops_inc(new_nexthops);
+    });
+
+#ifdef WITH_POLICY
+    return fib_entry_filter_nexthops(entry, new_nexthops, ingress_id, false);
+#else
+    return new_nexthops;
+#endif
+  }
+
+#ifdef WITH_POLICY
+  return fib_entry_filter_nexthops(entry, fib_entry_get_nexthops(entry),
+                                   ingress_id, true);
+#else
+  return fib_entry_get_nexthops(entry);
+#endif
+}
+
+hicn_policy_t fib_entry_get_policy(const fib_entry_t *entry) {
+  return entry->policy;
+}
+
+void fib_entry_set_policy(fib_entry_t *entry, hicn_policy_t policy) {
+  entry->policy = policy;
+
+#ifdef WITH_MAPME
+  /*
+   * Skip entries that do not correspond to a producer ( / have a locally
+   * served prefix / have no local connection as next hop)
+   */
+  if (!fib_entry_has_local_nexthop(entry)) return;
+  mapme_t *mapme = forwarder_get_mapme(entry->forwarder);
+  mapme_set_all_adjacencies(mapme, entry);
+#endif /* WITH_MAPME */
+}
+
+#endif /* WITH_POLICY */
+
+void fib_entry_nexthops_add(fib_entry_t *entry, unsigned nexthop) {
+  /*
+   * Nexthop is added to both:
+   *  - fib_entry: it is added to the nexthops_t struct, in the elts array.
+   *  - strategy: only used to eventually initialize internal state, might be
+   *  empty like in the random strategy.
+   */
+  off_t id = nexthops_add(&entry->nexthops, nexthop);
+  strategy_add_nexthop(&entry->strategy, &entry->nexthops, id);
+}
+
+void fib_entry_nexthops_remove(fib_entry_t *entry, unsigned nexthop) {
+  off_t id = nexthops_remove(&entry->nexthops, nexthop);
+  strategy_remove_nexthop(&entry->strategy, &entry->nexthops, id);
+}
+
+nexthops_t *fib_entry_get_nexthops_from_strategy(fib_entry_t *entry,
+                                                 const msgbuf_t *msgbuf,
+                                                 bool is_retransmission) {
+  assert(entry);
+  assert(msgbuf);
+
+  // DEBUG("[fib_entry_get_nexthops_from_strategy]");
+
+  const policy_stats_mgr_t *mgr =
+      forwarder_get_policy_stats_mgr(entry->forwarder);
+  assert(mgr);
+
+  /* Filtering */
+  nexthops_t *nexthops = fib_entry_get_available_nexthops(
+      entry, msgbuf_get_connection_id(msgbuf), NULL);
+  if (nexthops_get_curlen(nexthops) == 0) return nexthops;
+
+#ifdef WITH_POLICY_STATS
+  /*
+   * Update statistics about loss rates. We only detect losses upon
+   * retransmissions, and assume for the computation that the candidate set of
+   * output faces is the same as previously (i.e. does not take into account
+   * event such as face up/down, policy update, etc. Otherwise we would need to
+   * know what was the previous choice !
+   */
+  if (is_retransmission)
+    policy_stats_on_retransmission(mgr, &entry->policy_counters, nexthops);
+#endif /* WITH_POLICY_STATS */
+
+  /*
+   * NOTE: We might want to call a forwarding strategy even with no nexthop to
+   * take a fallback decision.
+   */
+  if (nexthops_get_curlen(nexthops) == 0) return nexthops;
+
+#ifdef WITH_POLICY
+
+  /*
+   * Filter out nexthops with lowest strategy priority.
+   * Initializing at 0 allows to disable nexthops with a negative priority
+   */
+  unsigned max_priority = 0;
+  unsigned i;
+  nexthop_t nexthop;
+  nexthops_enumerate(nexthops, i, nexthop, {
+    (void)nexthop;
+    int priority = nexthops->state[i].priority;
+    if (priority > max_priority) max_priority = priority;
+  });
+  nexthops_enumerate(nexthops, i, nexthop, {
+    int priority = nexthops->state[i].priority;
+    nexthops_disable_if(nexthops, i, (priority < max_priority));
+  });
+
+  /*
+   * If multipath is disabled, we don't offer much choice to the forwarding
+   * strategy, but still go through it for accounting purposes.
+   */
+  hicn_policy_t policy = fib_entry_get_policy(entry);
+  if ((policy.tags[POLICY_TAG_MULTIPATH].state == POLICY_STATE_PROHIBIT) ||
+      (policy.tags[POLICY_TAG_MULTIPATH].state == POLICY_STATE_AVOID)) {
+    DEBUG(
+        "[fib_entry_get_nexthops_from_strategy] select single nexthops due to "
+        "multipath policy");
+    nexthops_select_first(nexthops);
+  }
+
+#endif /* WITH_POLICY */
+
+  // DEBUG("[fib_entry_get_nexthops_from_strategy] calling lookup_nethops "
+  // "on strategy (num=%d)", nexthops_get_len(nexthops));
+  return strategy_lookup_nexthops(&entry->strategy, nexthops, msgbuf);
+}
+
+void fib_entry_on_data(fib_entry_t *entry, nexthops_t *data_nexthops,
+                       const msgbuf_t *msgbuf, Ticks pitEntryCreation,
+                       Ticks objReception) {
+  assert(entry);
+  assert(data_nexthops);
+  assert(msgbuf);
+
+#ifdef WITH_POLICY_STATS
+  if (pitEntryCreation != 0) {  // if pitEntryCreation we no match in the pit
+                                // was found
+    const policy_stats_mgr_t *mgr =
+        forwarder_get_policy_stats_mgr(entry->forwarder);
+    Ticks rtt = objReception - pitEntryCreation;
+    policy_stats_on_data(mgr, &entry->policy_stats, &entry->policy_counters,
+                         data_nexthops, msgbuf, rtt);
+  }
+#endif /* WITH_POLICY_STATS */
+
+  if (pitEntryCreation != 0 ||
+      (fib_entry_strategy_type(entry) == STRATEGY_TYPE_BESTPATH)) {
+    strategy_on_data(&entry->strategy, &entry->nexthops, data_nexthops, msgbuf,
+                     pitEntryCreation, objReception);
+  }
+}
+
+void fib_entry_on_timeout(fib_entry_t *entry,
+                          const nexthops_t *timeout_nexthops) {
+  assert(entry);
+  assert(timeout_nexthops);
+
+#ifdef WITH_POLICY_STATS
+  const policy_stats_mgr_t *mgr =
+      forwarder_get_policy_stats_mgr(entry->forwarder);
+  policy_stats_on_timeout(mgr, &entry->policy_counters, timeout_nexthops);
+#endif /* WITH_POLICY_STATS */
+
+  strategy_on_timeout(&entry->strategy, &entry->nexthops, timeout_nexthops);
+}
+
+const Name *fib_entry_get_prefix(const fib_entry_t *entry) {
+  assert(entry);
+  return &(entry->name);
+}
+
+/*
+ * Return true if we have at least one local connection as next hop
+ */
+bool fib_entry_has_local_nexthop(const fib_entry_t *entry) {
+  connection_table_t *table = forwarder_get_connection_table(entry->forwarder);
+
+  unsigned nexthop;
+  nexthops_foreach(fib_entry_get_nexthops(entry), nexthop, {
+    const connection_t *conn = connection_table_at(table, nexthop);
+    /* Ignore non-local connections */
+    if (!connection_is_local(conn)) continue;
+    return true;
+  });
+  return false;
+}
+
+#ifdef WITH_MAPME
+
+void *fib_entry_get_user_data(const fib_entry_t *entry) {
+  assert(entry);
+
+  return entry->user_data;
+}
+
+void fib_entry_set_user_data(fib_entry_t *entry, const void *user_data,
+                             void (*user_data_release)(void **)) {
+  assert(entry);
+  assert(user_data);
+  assert(user_data_release);
+
+  entry->user_data = (void *)user_data;
+  entry->user_data_release = user_data_release;
+}
+
+#endif /* WITH_MAPME */
diff --git a/hicn-light/src/hicn/core/fib_entry.h b/hicn-light/src/hicn/core/fib_entry.h
new file mode 100644
index 000000000..628c4cd4f
--- /dev/null
+++ b/hicn-light/src/hicn/core/fib_entry.h
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file fib_entry.h
+ * @brief A forwarding entry in the FIB table
+ *
+ * A Forwarding Information Base (FIB) entry (fib_entry_t) is a
+ * set of nexthops for a name.  It also indicates the forwarding strategy.
+ *
+ * Each nexthop contains the ConnectionId assocaited with it.  This could be
+ * something specific like a MAC address or point-to-point tunnel.  Or, it
+ * could be something general like a MAC group address or ip multicast overlay.
+ *
+ * See strategy.h for a description of forwarding strategies.
+ * In short, a strategy is the algorithm used to select one or more nexthops
+ * from the set of available nexthops.
+ *
+ * Each nexthop also contains a void* to a forwarding strategy data container.
+ * This allows a strategy to keep proprietary information about each nexthop.
+ *
+ *
+ */
+
+#ifndef fib_entry_h
+#define fib_entry_h
+
+#include "name.h"
+#include "strategy.h"
+#include "msgbuf.h"
+#include "nexthops.h"
+#include "policy_stats.h"
+
+typedef struct {
+  Name name;
+  unsigned refcount;
+  nexthops_t nexthops;
+  strategy_entry_t strategy;
+
+  const void *forwarder;
+
+#ifdef WITH_POLICY
+  hicn_policy_t policy;
+#endif /* WITH_POLICY */
+
+  policy_counters_t policy_counters;
+  policy_stats_t policy_stats;
+
+#ifdef WITH_MAPME
+  /* In case of no multipath, this stores the previous decision taken by policy.
+   * As the list of nexthops is not expected to change, we can simply store the
+   * flags */
+  uint_fast32_t prev_nexthops_flags;
+  void *user_data;
+  void (*user_data_release)(void **user_data);
+#endif /* WITH_MAPME */
+} fib_entry_t;
+
+#define _fib_entry_var(x) _fib_entry_##x
+
+#define fib_entry_strategy_type(fib_entry) ((fib_entry)->strategy.type)
+
+#define fib_entry_get_nexthops(fib_entry) (&(fib_entry)->nexthops)
+#define fib_entry_nexthops_len(fib_entry) \
+  (nexthops_get_len(&(fib_entry)->nexthops))
+#define fib_entry_nexthops_curlen(fib_entry) \
+  (nexthops_curlen(&(fib_entry)->nexthops))
+#define fib_entry_get_nexthop(fib_entry, i) ((fib_entry)->nexthops.elts[i])
+#define fib_entry_foreach_nexthop(fib_entry, nexthop, BODY) \
+  nexthops_foreach(fib_entry->nexthops, BODY)
+
+#define fib_entry_nexthops_changed(fib_entry) \
+  ((fib_entry)->prev_nexthops_flags == fib_entry_get_nexthops(fib_entry)->flags)
+
+#define fib_entry_set_prev_nexthops(fib_entry) \
+  ((fib_entry)->prev_nexthops_flags = fib_entry_get_nexthops(fib_entry)->flags)
+
+struct forwarder_s;
+fib_entry_t *fib_entry_create(Name *name, strategy_type_t strategy_type,
+                              strategy_options_t *strategy_options,
+                              const struct forwarder_s *table);
+
+void fib_entry_free(fib_entry_t *entry);
+
+void fib_entry_add_strategy_options(fib_entry_t *entry,
+                                    strategy_type_t strategy_type,
+                                    strategy_options_t *strategy_options);
+
+void fib_entry_set_strategy(fib_entry_t *fib_entry,
+                            strategy_type_t strategy_type,
+                            strategy_options_t *strategy_options);
+
+void fib_entry_nexthops_add(fib_entry_t *fib_entry, unsigned nexthop);
+
+void fib_entry_nexthops_remove(fib_entry_t *fib_entry, unsigned nexthop);
+
+size_t fib_entry_NexthopCount(const fib_entry_t *fib_entry);
+
+/**
+ * @function fib_entry_nexthops_get
+ * @abstract Returns the nexthop set of the FIB entry.  You must Acquire if it
+ * will be saved.
+ * @discussion
+ *   Returns the next hop set for the FIB entry.
+ */
+const nexthops_t *fib_entry_nexthops_get(const fib_entry_t *fib_entry);
+
+const nexthops_t *fib_entry_nexthops_getFromForwardingStrategy(
+    fib_entry_t *fib_entry, const msgbuf_t *interest_msgbuf,
+    bool is_retransmission);
+
+void fib_entry_on_data(fib_entry_t *fib_entry, nexthops_t *nexthops,
+                       const msgbuf_t *object_msgbuf, Ticks pit_entry_creation,
+                       Ticks data_reception);
+
+#ifdef WITH_POLICY
+hicn_policy_t fib_entry_get_policy(const fib_entry_t *fib_entry);
+void fib_entry_reconsider_policy(fib_entry_t *fib_entry);
+void fib_entry_set_policy(fib_entry_t *fib_entry, hicn_policy_t policy);
+void fib_entry_update_stats(fib_entry_t *fib_entry, uint64_t now);
+#endif /* WITH_POLICY */
+
+nexthops_t *fib_entry_get_available_nexthops(fib_entry_t *fib_entry,
+                                             unsigned in_connection,
+                                             nexthops_t *new_nexthops);
+void fib_entry_on_timeout(fib_entry_t *fib_entry, const nexthops_t *egressId);
+nexthops_t *fib_entry_get_nexthops_from_strategy(
+    fib_entry_t *fib_entry, const msgbuf_t *interest_msgbuf,
+    bool is_retransmission);
+
+/**
+ * @function fib_entry_get_prefix
+ * @abstract Returns a copy of the prefix.
+ * @return A reference counted copy that you must destroy
+ */
+const Name *fib_entry_get_prefix(const fib_entry_t *fib_entry);
+
+bool fib_entry_has_local_nexthop(const fib_entry_t *entry);
+
+#ifdef WITH_MAPME
+
+/**
+ * @function fib_entry_get_user_data
+ * @abstract Returns user data associated to the FIB entry.
+ * @param [in] fib_entry - Pointer to the FIB entry.
+ * @return User data as a void pointer
+ */
+void *fib_entry_get_user_data(const fib_entry_t *fib_entry);
+
+/**
+ * @function fib_entry_get_user_data
+ * @abstract Associates user data and release callback to a FIB entry.
+ * @param [in] fib_entry - Pointer to the FIB entry.
+ * @param [in] user_data - Generic pointer to user data
+ * @param [in@ user_data_release - Callback used to release user data upon
+ * change of FIB entry removal.
+ */
+void fib_entry_set_user_data(fib_entry_t *fib_entry, const void *user_data,
+                             void (*user_data_release)(void **));
+
+#endif /* WITH_MAPME */
+
+#endif  // fib_entry_h
diff --git a/hicn-light/src/hicn/core/forwarder.c b/hicn-light/src/hicn/core/forwarder.c
index 94e8cc885..37502f3ac 100644
--- a/hicn-light/src/hicn/core/forwarder.c
+++ b/hicn-light/src/hicn/core/forwarder.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -23,6 +23,15 @@
  * the event scheduler
  */
 
+/* Bypass FIB and send packet one by one */
+//#define BYPASS_FIB 1
+
+/* Send packets one by one : only effective if FIB is not bypassed */
+//#define USE_SEND_PACKET 1
+
+/* Batch sending: only if the previous option is undefined */
+#define USE_QUEUE true
+
 #ifndef _WIN32
 #include <arpa/inet.h>
 #include <sys/socket.h>
@@ -30,8 +39,7 @@
 #endif
 #include <errno.h>
 #include <fcntl.h>
-#include <signal.h>
-#include <hicn/hicn-light/config.h>
+//#include <hicn/hicn-light/config.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -41,90 +49,108 @@
 #define __STDC_FORMAT_MACROS
 #include <inttypes.h>
 
-#include <parc/algol/parc_ArrayList.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Object.h>
-#include <parc/logging/parc_LogReporterTextStdout.h>
-
-#include <hicn/core/connectionManager.h>
-#include <hicn/core/connectionTable.h>
-#include <hicn/core/dispatcher.h>
-#include <hicn/core/forwarder.h>
-#include <hicn/core/messagePacketType.h>
+#include "connection_table.h"
+#include "fib.h"
+#include "forwarder.h"
+#include "listener_table.h"
 #ifdef WITH_MAPME
-#include <hicn/core/mapme.h>
+#include "mapme.h"
 #endif /* WITH_MAPME */
-#include <hicn/config/configuration.h>
-#include <hicn/config/configurationFile.h>
-#include <hicn/config/configurationListeners.h>
-#include <hicn/processor/messageProcessor.h>
+#include "msgbuf.h"
+#include "msgbuf_pool.h"
+#include "packet_cache.h"
+#include "../config/configuration.h"
+// #include "../config/configuration_file.h"
+#include "../config/commands.h"
+#include "../io/base.h"  // MAX_MSG
+
+#ifdef WITH_POLICY_STATS
+#include <hicn/core/policy_stats.h>
+#endif /* WITH_POLICY_STATS */
 
 #include <hicn/core/wldr.h>
+#include <hicn/util/log.h>
+
+typedef struct {
+  // Packets processed
+  uint32_t countReceived;  // Interest and data only
+  uint32_t countInterestsReceived;
+  uint32_t countObjectsReceived;
+
+  // Packets Dropped
+  uint32_t countDropped;
+  uint32_t countInterestsDropped;
+  uint32_t countObjectsDropped;
+  uint32_t countOtherDropped;
+
+  // Forwarding
+  uint32_t countInterestForwarded;
+  uint32_t countObjectsForwarded;
+
+  // Errors while forwarding
+  uint32_t countDroppedConnectionNotFound;
+  uint32_t countSendFailures;
+  uint32_t countDroppedNoRoute;
+
+  // Interest processing
+  uint32_t countInterestsAggregated;
+  uint32_t countInterestsRetransmitted;
+  uint32_t countInterestsSatisfiedFromStore;
+  uint32_t countInterestsExpired;
+  uint32_t countDataExpired;
+
+  // Data processing
+  uint32_t countDroppedNoReversePath;
+
+  // TODO(eloparco): Currently not used
+  // uint32_t countDroppedNoHopLimit;
+  // uint32_t countDroppedZeroHopLimitFromRemote;
+  // uint32_t countDroppedZeroHopLimitToRemote;
+} forwarder_stats_t;
+
+struct forwarder_s {
+  //    uint16_t server_port;
 
-#include <parc/assert/parc_Assert.h>
-
-// the router's clock frequency (we now use the monotonic clock)
-#define HZ 1000
-
-// these will all be a little off because its all integer division
-#define MSEC_PER_TICK (1000 / HZ)
-#define USEC_PER_TICK (1000000 / HZ)
-#define NSEC_PER_TICK ((1000000000ULL) / HZ)
-#define MSEC_TO_TICKS(msec) \
-  ((msec < FC_MSEC_PER_TICK) ? 1 : msec / FC_MSEC_PER_TICK)
-#define NSEC_TO_TICKS(nsec) ((nsec < NSEC_PER_TICK) ? 1 : nsec / NSEC_PER_TICK)
-
-struct forwarder {
-  Dispatcher *dispatcher;
-
-  uint16_t server_port;
+  // used by seed48 and nrand48
+  unsigned short seed[3];
 
-  PARCEventSignal *signal_int;
-  PARCEventSignal *signal_term;
-#ifndef _WIN32
-  PARCEventSignal *signal_usr1;
-#endif
-  PARCEventTimer *keepalive_event;
+  connection_table_t *connection_table;
+  listener_table_t *listener_table;
+  configuration_t *config;
 
-  // will skew the virtual clock forward.  In normal operaiton, it is 0.
-  Ticks clockOffset;
+  pkt_cache_t *pkt_cache;
+  fib_t *fib;
+  msgbuf_pool_t *msgbuf_pool;
 
-  unsigned nextConnectionid;
-  Messenger *messenger;
-  ConnectionManager *connectionManager;
-  ConnectionTable *connectionTable;
-  ListenerSet *listenerSet;
-  Configuration *config;
+#ifdef WITH_MAPME
+  mapme_t *mapme;
+#endif /* WITH_MAPME */
 
-  // we'll eventually want to setup a threadpool of these
-  MessageProcessor *processor;
+  bool store_in_cs;
+  bool serve_from_cs;
 
-  Logger *logger;
+  forwarder_stats_t stats;
+#ifdef WITH_POLICY_STATS
+  policy_stats_mgr_t policy_stats_mgr;
+#endif /* WITH_POLICY_STATS */
 
-  PARCClock *clock;
+  /*
+   * The message forwarder has to decide whether to queue incoming packets for
+   * batching, or trigger the transmission on the connection
+   */
+  unsigned pending_conn[MAX_MSG];
+  size_t num_pending_conn;
 
-#if !defined(__APPLE__)
-  hicn_socket_helper_t
-      *hicnSocketHelper;  // state required to manage hicn connections
-#endif
-  // used by seed48 and nrand48
-  unsigned short seed[3];
+  // msgbuf_t msgbuf; /* Storage for msgbuf, which are currently processed 1 by
+  // 1 */
 
-#ifdef WITH_MAPME
-  MapMe *mapme;
-#endif /* WITH_MAPME */
+  subscription_table_t *subscriptions;
 };
 
-// signal traps through the event scheduler
-static void _signal_cb(int, PARCEventType, void *);
-
-// A no-op keepalive to prevent Libevent from exiting the dispatch loop
-static void _keepalive_cb(int, PARCEventType, void *);
-
 /**
  * Reseed our pseudo-random number generator.
  */
-static void forwarder_Seed(Forwarder *forwarder) {
+static void forwarder_seed(forwarder_t *forwarder) {
 #ifndef _WIN32
   int fd;
   ssize_t res;
@@ -150,452 +176,990 @@ static void forwarder_Seed(Forwarder *forwarder) {
 #endif
 }
 
-Logger *forwarder_GetLogger(const Forwarder *forwarder) {
-  return forwarder->logger;
-}
+forwarder_t *forwarder_create(configuration_t *configuration) {
+  forwarder_t *forwarder = malloc(sizeof(forwarder_t));
+  if (!forwarder) goto ERR_MALLOC;
 
-// ============================================================================
-// Setup and destroy section
+  forwarder_seed(forwarder);
+  srand(forwarder->seed[0] ^ forwarder->seed[1] ^ forwarder->seed[2]);
 
-Forwarder *forwarder_Create(Logger *logger) {
-  Forwarder *forwarder = parcMemory_AllocateAndClear(sizeof(Forwarder));
-  parcAssertNotNull(forwarder, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Forwarder));
-  memset(forwarder, 0, sizeof(Forwarder));
-  forwarder_Seed(forwarder);
+  forwarder->config = configuration;
 
-  forwarder->clock = parcClock_Monotonic();
-  forwarder->clockOffset = 0;
+  forwarder->listener_table = listener_table_create();
+  if (!forwarder->listener_table) goto ERR_LISTENER_TABLE;
 
-  if (logger) {
-    forwarder->logger = logger_Acquire(logger);
-    logger_SetClock(forwarder->logger, forwarder->clock);
-  } else {
-    PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
-    forwarder->logger = logger_Create(reporter, forwarder->clock);
-    parcLogReporter_Release(&reporter);
-  }
+  forwarder->connection_table = connection_table_create();
+  if (!forwarder->connection_table) goto ERR_CONNECTION_TABLE;
 
-  forwarder->nextConnectionid = 1;
-  forwarder->dispatcher = dispatcher_Create(forwarder->logger);
-  forwarder->messenger = messenger_Create(forwarder->dispatcher);
-  forwarder->connectionManager = connectionManager_Create(forwarder);
-  forwarder->connectionTable = connectionTable_Create();
-  forwarder->listenerSet = listenerSet_Create();
-  forwarder->config = configuration_Create(forwarder);
-  forwarder->processor = messageProcessor_Create(forwarder);
-
-  forwarder->signal_term = dispatcher_CreateSignalEvent(
-      forwarder->dispatcher, _signal_cb, forwarder, SIGTERM);
-  dispatcher_StartSignalEvent(forwarder->dispatcher, forwarder->signal_term);
-
-  forwarder->signal_int = dispatcher_CreateSignalEvent(
-      forwarder->dispatcher, _signal_cb, forwarder, SIGINT);
-  dispatcher_StartSignalEvent(forwarder->dispatcher, forwarder->signal_int);
-#ifndef _WIN32
-  forwarder->signal_usr1 = dispatcher_CreateSignalEvent(
-      forwarder->dispatcher, _signal_cb, forwarder, SIGPIPE);
-  dispatcher_StartSignalEvent(forwarder->dispatcher, forwarder->signal_usr1);
-#endif
+  forwarder->fib = fib_create(forwarder);
+  if (!forwarder->fib) goto ERR_FIB;
 
-#if !defined(__APPLE__) && !defined(__ANDROID__) && !defined(_WIN32) && \
-    defined(PUNTING)
-  forwarder->hicnSocketHelper = hicn_create();
-  if (!forwarder->hicnSocketHelper)
-      goto ERR_SOCKET;
-#endif /* __APPLE__ */
+  forwarder->msgbuf_pool = msgbuf_pool_create();
+  if (!forwarder->msgbuf_pool) goto ERR_PACKET_POOL;
 
-#ifdef WITH_MAPME
-  if (!(mapme_create(&forwarder->mapme, forwarder)))
-      goto ERR_MAPME;
-#endif /* WITH_MAPME */
+  size_t objectStoreSize = configuration_get_cs_size(configuration);
+  forwarder->pkt_cache = pkt_cache_create(objectStoreSize);
+  if (!forwarder->pkt_cache) goto ERR_PKT_CACHE;
 
+  forwarder->subscriptions = subscription_table_create();
+  if (!forwarder->subscriptions) goto ERR_SUBSCRIPTION;
 
-       /* ignore child */
-#ifndef _WIN32
-  signal(SIGCHLD, SIG_IGN);
-
-  /* ignore tty signals */
-  signal(SIGTSTP, SIG_IGN);
-  signal(SIGTTOU, SIG_IGN);
-  signal(SIGTTIN, SIG_IGN);
-#endif
+  // the two flags for the cs are set to true by default. If the cs
+  // is active it always work as expected unless the use modifies this
+  // values using controller
+  if (objectStoreSize != 0) {
+    forwarder->store_in_cs = true;
+    forwarder->serve_from_cs = true;
+  }
 
-  // We no longer use this for ticks, but we need to have at least one event
-  // schedule to keep Libevent happy.
+#ifdef WITH_MAPME
+  forwarder->mapme = mapme_create(forwarder);
+  if (!forwarder->mapme) goto ERR_MAPME;
+#endif /* WITH_MAPME */
 
-  struct timeval wtnow_timeout;
-  timerclear(&wtnow_timeout);
+#ifdef WITH_POLICY_STATS
+  if (policy_stats_mgr_initialize(&forwarder->policy_stats_mgr, forwarder) < 0)
+    goto ERR_MGR;
+#endif /* WITH_POLICY_STATS */
 
-  wtnow_timeout.tv_sec = 0;
-  wtnow_timeout.tv_usec = 50000;  // 20 Hz keepalive
+  memset(&forwarder->stats, 0, sizeof(forwarder_stats_t));
 
-  PARCEventScheduler *base =
-      dispatcher_GetEventScheduler(forwarder->dispatcher);
-  forwarder->keepalive_event = parcEventTimer_Create(
-      base, PARCEventType_Persist, _keepalive_cb, (void *)forwarder);
-  parcEventTimer_Start(forwarder->keepalive_event, &wtnow_timeout);
+  forwarder->num_pending_conn = 0;
 
   return forwarder;
 
+ERR_MGR:
 #ifdef WITH_MAPME
 ERR_MAPME:
 #endif /* WITH_MAPME */
-#if !defined(__APPLE__) && !defined(__ANDROID__) && !defined(_WIN32) && \
-    defined(PUNTING)
-  hicn_free(forwarder->hicnSocketHelper);
-ERR_SOCKET:
-#endif
-  listenerSet_Destroy(&(forwarder->listenerSet));
-  connectionManager_Destroy(&(forwarder->connectionManager));
-  connectionTable_Destroy(&(forwarder->connectionTable));
-  messageProcessor_Destroy(&(forwarder->processor));
-  configuration_Destroy(&(forwarder->config));
-  messenger_Destroy(&(forwarder->messenger));
-
-  dispatcher_DestroySignalEvent(forwarder->dispatcher,
-                                &(forwarder->signal_int));
-  dispatcher_DestroySignalEvent(forwarder->dispatcher,
-                                &(forwarder->signal_term));
-#ifndef _WIN32
-  dispatcher_DestroySignalEvent(forwarder->dispatcher,
-                                &(forwarder->signal_usr1));
-#endif
-
-  parcClock_Release(&forwarder->clock);
-  logger_Release(&forwarder->logger);
 
-  // do the dispatcher last
-  dispatcher_Destroy(&(forwarder->dispatcher));
-
-  parcMemory_Deallocate((void **)&forwarder);
+ERR_SUBSCRIPTION:
+  subscription_table_free(forwarder->subscriptions);
+ERR_PKT_CACHE:
+  pkt_cache_free(forwarder->pkt_cache);
+
+  msgbuf_pool_free(forwarder->msgbuf_pool);
+ERR_PACKET_POOL:
+  fib_free(forwarder->fib);
+ERR_FIB:
+  connection_table_free(forwarder->connection_table);
+ERR_CONNECTION_TABLE:
+  listener_table_free(forwarder->listener_table);
+ERR_LISTENER_TABLE:
+  free(forwarder);
+ERR_MALLOC:
   return NULL;
 }
 
-void forwarder_Destroy(Forwarder **ptr) {
-  parcAssertNotNull(ptr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*ptr, "Parameter must dereference to non-null pointer");
-  Forwarder *forwarder = *ptr;
-#if !defined(__APPLE__) && !defined(__ANDROID__) && !defined(_WIN32) && \
-    defined(PUNTING)
-  hicn_free(forwarder->hicnSocketHelper);
-#endif
-  parcEventTimer_Destroy(&(forwarder->keepalive_event));
+void forwarder_free(forwarder_t *forwarder) {
+  assert(forwarder);
 
-  listenerSet_Destroy(&(forwarder->listenerSet));
-  connectionManager_Destroy(&(forwarder->connectionManager));
-  connectionTable_Destroy(&(forwarder->connectionTable));
-  messageProcessor_Destroy(&(forwarder->processor));
-  configuration_Destroy(&(forwarder->config));
-
-  // the messenger is used by many of the other pieces, so destroy it last
-  messenger_Destroy(&(forwarder->messenger));
+  policy_stats_mgr_finalize(&forwarder->policy_stats_mgr);
 
 #ifdef WITH_MAPME
   mapme_free(forwarder->mapme);
 #endif /* WITH_MAPME */
 
-  dispatcher_DestroySignalEvent(forwarder->dispatcher,
-                                &(forwarder->signal_int));
-  dispatcher_DestroySignalEvent(forwarder->dispatcher,
-                                &(forwarder->signal_term));
-#ifndef _WIN32
-  dispatcher_DestroySignalEvent(forwarder->dispatcher,
-                                &(forwarder->signal_usr1));
-#endif
+  pkt_cache_free(forwarder->pkt_cache);
+  msgbuf_pool_free(forwarder->msgbuf_pool);
+  fib_free(forwarder->fib);
+  connection_table_free(forwarder->connection_table);
+  listener_table_free(forwarder->listener_table);
+  subscription_table_free(forwarder->subscriptions);
+  configuration_free(forwarder->config);
+  free(forwarder);
+}
 
-  parcClock_Release(&forwarder->clock);
-  logger_Release(&forwarder->logger);
+void forwarder_setup_local_listeners(forwarder_t *forwarder, uint16_t port) {
+  assert(forwarder);
+  listener_setup_local(forwarder, port);
+}
 
-  // do the dispatcher last
-  dispatcher_Destroy(&(forwarder->dispatcher));
+configuration_t *forwarder_get_configuration(forwarder_t *forwarder) {
+  assert(forwarder);
+  return forwarder->config;
+}
 
-  parcMemory_Deallocate((void **)&forwarder);
-  *ptr = NULL;
+subscription_table_t *forwarder_get_subscriptions(forwarder_t *forwarder) {
+  return forwarder->subscriptions;
 }
 
-void forwarder_SetupAllListeners(Forwarder *forwarder, uint16_t port,
-                                 const char *localPath) {
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
+connection_table_t *forwarder_get_connection_table(
+    const forwarder_t *forwarder) {
+  assert(forwarder);
+  return forwarder->connection_table;
+}
 
-  configurationListeners_SetupAll(forwarder->config, port, localPath);
+listener_table_t *forwarder_get_listener_table(forwarder_t *forwarder) {
+  assert(forwarder);
+  return forwarder->listener_table;
 }
 
-void forwarder_SetupLocalListeners(Forwarder *forwarder, uint16_t port) {
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
-  configurationListeners_SetutpLocalIPv4(forwarder->config, port);
+void forwarder_cs_set_store(forwarder_t *forwarder, bool val) {
+  assert(forwarder);
+  forwarder->store_in_cs = val;
 }
 
-void forwarder_SetupFromConfigFile(Forwarder *forwarder, const char *filename) {
-  ConfigurationFile *configFile = configurationFile_Create(forwarder, filename);
-  if (configFile) {
-    configurationFile_Process(configFile);
-    configurationFile_Release(&configFile);
-  }
+bool forwarder_cs_get_store(forwarder_t *forwarder) {
+  assert(forwarder);
+  return forwarder->store_in_cs;
 }
 
-Configuration *forwarder_GetConfiguration(Forwarder *forwarder) {
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
-  return forwarder->config;
+void forwarder_cs_set_serve(forwarder_t *forwarder, bool val) {
+  assert(forwarder);
+  forwarder->serve_from_cs = val;
 }
 
-// ============================================================================
+bool forwarder_cs_get_serve(forwarder_t *forwarder) {
+  assert(forwarder);
+  return forwarder->serve_from_cs;
+}
+
+void forwarder_cs_set_size(forwarder_t *forwarder, size_t size) {
+  assert(forwarder);
 
-unsigned forwarder_GetNextConnectionId(Forwarder *forwarder) {
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
-  return forwarder->nextConnectionid++;
+  if (pkt_cache_set_cs_size(forwarder->pkt_cache, size) < 0) {
+    ERROR(
+        "Unable to resize the CS: provided maximum size (%u) is smaller than "
+        "the number of elements currently stored in the CS (%u). Clear the CS "
+        "and retry.",
+        size, pkt_cache_get_cs_size(forwarder->pkt_cache));
+  }
 }
 
-Messenger *forwarder_GetMessenger(Forwarder *forwarder) {
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
-  return forwarder->messenger;
+size_t forwarder_cs_get_size(forwarder_t *forwarder) {
+  assert(forwarder);
+  return pkt_cache_get_cs_size(forwarder->pkt_cache);
 }
 
-Dispatcher *forwarder_GetDispatcher(Forwarder *forwarder) {
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
-  return forwarder->dispatcher;
+size_t forwarder_cs_get_num_stale_entries(forwarder_t *forwarder) {
+  assert(forwarder);
+  return pkt_cache_get_num_cs_stale_entries(forwarder->pkt_cache);
 }
 
-#ifdef WITH_POLICY
-ConnectionTable *forwarder_GetConnectionTable(const Forwarder *forwarder) {
+void forwarder_cs_clear(forwarder_t *forwarder) {
+  assert(forwarder);
+
+  pkt_cache_cs_clear(forwarder->pkt_cache);
+}
+
+/**
+ * @function forwarder_Drop
+ * @abstract Whenever we "drop" a message, increment counters
+ * @discussion
+ *   This is a bookkeeping function.  It increments the appropriate counters.
+ *
+ *   The default action for a message is to destroy it in
+ * <code>forwarder_Receive()</code>, so this function does not need to do
+ * that.
+ *
+ */
+static ssize_t forwarder_drop(forwarder_t *forwarder, off_t msgbuf_id) {
+  forwarder->stats.countDropped++;
+
+  const msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(forwarder);
+  const msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id);
+
+  switch (msgbuf_get_type(msgbuf)) {
+    case MSGBUF_TYPE_INTEREST:
+      forwarder->stats.countInterestsDropped++;
+      break;
+
+    case MSGBUF_TYPE_DATA:
+      forwarder->stats.countObjectsDropped++;
+      break;
+
+    default:
+      forwarder->stats.countOtherDropped++;
+      break;
+  }
+
+  return msgbuf_get_len(msgbuf);
+  // dont destroy message here, its done at end of receive
+}
+
+#ifndef BYPASS_FIB
+/*
+ *   If the hoplimit is equal to 0, then we may only forward it to local
+ * applications.  Otherwise, we may forward it off the system.
+ *
+ */
+
+static ssize_t forwarder_forward_via_connection(forwarder_t *forwarder,
+                                                off_t msgbuf_id,
+                                                unsigned conn_id) {
+  connection_table_t *table = forwarder_get_connection_table(forwarder);
+
+  const msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(forwarder);
+  msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id);
+
+  const connection_t *conn = connection_table_get_by_id(table, conn_id);
+
+  if (!conn) {
+    forwarder->stats.countDroppedConnectionNotFound++;
+    WARN("forward msgbuf %lu to interface %u not found (count %u)", msgbuf_id,
+         conn_id, forwarder->stats.countDroppedConnectionNotFound);
+    return forwarder_drop(forwarder, msgbuf_id);
+  }
+
+  /* Always queue the packet... */
+  // DEBUG("Queueing packet\n");
+
+#if defined(USE_SEND_PACKET) || !defined(__linux__)
+
+  // Here we need to update the path label of a data packet before send
+  // it. The path label update can be done here because the packet is sent
+  // directly to the socket
+  if (msgbuf_get_type(msgbuf) == MSGBUF_TYPE_DATA)
+    msgbuf_update_pathlabel(msgbuf, connection_get_id(conn));
+
+  bool success = connection_send_packet(conn, msgbuf_get_packet(msgbuf),
+                                        msgbuf_get_len(msgbuf));
 #else
-ConnectionTable *forwarder_GetConnectionTable(Forwarder *forwarder) {
-#endif /* WITH_POLICY */
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
-  return forwarder->connectionTable;
+
+  // In this case we cannot update the path label even if it is need because
+  // the packet is not copied and only the packet id is enqueued to the ring
+  // buffer associated the output interface. If the path label is updated here
+  // all data packets get delivered to the next hop with the same label that is
+  // associated to the last connection used. For this reason the path label
+  // update must be done before the packet is actually sent inside the different
+  // IO implementations.
+  bool success = connection_send(conn, msgbuf_id, USE_QUEUE);
+
+#endif
+
+  /* ... and mark the connection as pending if this is not yet the case */
+  unsigned i;
+  for (i = 0; i < forwarder->num_pending_conn; i++) {
+    if (forwarder->pending_conn[i] == conn_id) break;
+  }
+  if (i == forwarder->num_pending_conn)  // Not found
+    forwarder->pending_conn[forwarder->num_pending_conn++] = conn_id;
+
+  if (!success) {
+    forwarder->stats.countSendFailures++;
+
+    DEBUG("forward msgbuf %llu to interface %u send failure (count %u)",
+          msgbuf_id, conn_id, forwarder->stats.countSendFailures);
+    return forwarder_drop(forwarder, msgbuf_id);
+  }
+
+  switch (msgbuf_get_type(msgbuf)) {
+    case MSGBUF_TYPE_INTEREST:
+      forwarder->stats.countInterestForwarded++;
+      break;
+
+    case MSGBUF_TYPE_DATA:
+      forwarder->stats.countObjectsForwarded++;
+      break;
+
+    default:
+      break;
+  }
+
+  TRACE("forward msgbuf %p to interface %u", msgbuf, conn_id);
+  return msgbuf_get_len(msgbuf);
 }
 
-ListenerSet *forwarder_GetListenerSet(Forwarder *forwarder) {
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
-  return forwarder->listenerSet;
+/**
+ * @function forwarder_forward_to_nexthops
+ * @abstract Try to forward to each nexthop listed in the NumberSet
+ * @discussion
+ *   Will not forward to the ingress connection.
+ *
+ * @return The number of nexthops tried
+ */
+static unsigned forwarder_forward_to_nexthops(forwarder_t *forwarder,
+                                              off_t msgbuf_id,
+                                              const nexthops_t *nexthops) {
+  // DEBUG("[forwarder_forward_to_nexthops] num=%d/%d",
+  // nexthops_get_curlen(nexthops), nexthops_get_len(nexthops));
+  unsigned forwardedCopies = 0;
+
+  const msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(forwarder);
+  msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id);
+  unsigned ingressId = msgbuf_get_connection_id(msgbuf);
+
+  unsigned nexthop;
+  nexthops_foreach(nexthops, nexthop, {
+    // DEBUG("[forwarder_forward_to_nexthops]  - nexthop = %d");
+    if (nexthop == ingressId) continue;
+
+    forwardedCopies++;
+    // INFO("[forwarder_forward_to_nexthops]  - nexthop = %d OK", nexthop);
+    forwarder_forward_via_connection(forwarder, msgbuf_id, nexthop);
+  });
+
+  return forwardedCopies;
 }
 
-void forwarder_SetChacheStoreFlag(Forwarder *forwarder, bool val) {
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
-  messageProcessor_SetCacheStoreFlag(forwarder->processor, val);
+static bool forwarder_forward_via_fib(forwarder_t *forwarder, off_t msgbuf_id,
+                                      pkt_cache_verdict_t verdict,
+                                      pkt_cache_entry_t *entry) {
+  assert(forwarder);
+  assert(msgbuf_id_is_valid(msgbuf_id));
+
+  const msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(forwarder);
+  msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id);
+  assert(msgbuf_get_type(msgbuf) == MSGBUF_TYPE_INTEREST);
+
+  fib_entry_t *fib_entry = fib_match_message(forwarder->fib, msgbuf);
+  if (!fib_entry) return false;
+
+  // DEBUG("[forwarder] Getting nexthops from strategy");
+  nexthops_t *nexthops = fib_entry_get_nexthops_from_strategy(
+      fib_entry, msgbuf, verdict == PKT_CACHE_VERDICT_RETRANSMIT_INTEREST);
+
+  if (nexthops_get_curlen(nexthops) == 0) {
+    ERROR("Message %p returned an empty next hop set", msgbuf);
+    return false;
+  }
+
+  // if this is the first time that we sent this interest the pit entry would be
+  // NULL. in that case we add the interest to the pit
+  if (entry == NULL) {
+    entry = pkt_cache_add_to_pit(forwarder->pkt_cache, msgbuf);
+  }
+  pit_entry_t *pit_entry = &entry->u.pit_entry;
+  if (!pit_entry) {
+    return false;
+  }
+
+  pit_entry_set_fib_entry(pit_entry, fib_entry);
+
+  // this requires some additional checks. It may happen that some of the output
+  // faces selected by the forwarding strategy are not usable. So far all the
+  // forwarding strategy return only valid faces (or an empty list)
+  unsigned nexthop;
+  nexthops_foreach(nexthops, nexthop, {
+    // DEBUG("Adding egress to PIT for nexthop %d", nexthop);
+    pit_entry_egress_add(pit_entry, nexthop);
+  });
+
+  if (forwarder_forward_to_nexthops(forwarder, msgbuf_id, nexthops) <= 0) {
+    // this should never happen
+    ERROR("Message %p returned an empty next hop set", msgbuf);
+    return false;
+  }
+
+  return true;
 }
 
-bool forwarder_GetChacheStoreFlag(Forwarder *forwarder) {
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
-  return messageProcessor_GetCacheStoreFlag(forwarder->processor);
+#endif /* ! BYPASS_FIB */
+
+ssize_t _forwarder_forward_upon_interest(forwarder_t *forwarder,
+                                         msgbuf_pool_t *msgbuf_pool,
+                                         off_t data_msgbuf_id,
+                                         off_t interest_msgbuf_id,
+                                         pkt_cache_entry_t *entry,
+                                         pkt_cache_verdict_t verdict) {
+  msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, interest_msgbuf_id);
+
+  if (verdict == PKT_CACHE_VERDICT_AGGREGATE_INTEREST) {
+    // the packet shuold not be forwarder
+    forwarder_drop(forwarder, interest_msgbuf_id);
+    return msgbuf_get_len(msgbuf);
+  }
+
+  // - Forward reply if a data packet matching the interest was found
+  if (verdict == PKT_CACHE_VERDICT_FORWARD_DATA) {
+    assert(forwarder->serve_from_cs == true);
+
+    msgbuf_t *interest_msgbuf = msgbuf_pool_at(msgbuf_pool, interest_msgbuf_id);
+    msgbuf_t *data_msgbuf = msgbuf_pool_at(msgbuf_pool, data_msgbuf_id);
+
+    msgbuf_reset_pathlabel(data_msgbuf);
+
+    forwarder_forward_via_connection(forwarder, data_msgbuf_id,
+                                     msgbuf_get_connection_id(interest_msgbuf));
+
+    // - Try to forward the interest
+  } else if (!forwarder_forward_via_fib(forwarder, interest_msgbuf_id, verdict,
+                                        entry)) {
+    forwarder->stats.countDroppedNoRoute++;
+    INFO("Message %lu did not match FIB, no route (count %u)",
+         interest_msgbuf_id, forwarder->stats.countDroppedNoRoute);
+
+    // - Drop the packet (no forwarding)
+    forwarder_drop(forwarder, interest_msgbuf_id);
+  }
+
+  return msgbuf_get_len(msgbuf);
+}
+
+static void _forwarder_update_interest_stats(forwarder_t *forwarder,
+                                             pkt_cache_verdict_t verdict,
+                                             msgbuf_t *msgbuf,
+                                             pkt_cache_entry_t *entry) {
+  long expiration = -1;
+  if (entry == NULL)
+    expiration = ticks_now() + msgbuf_get_interest_lifetime(msgbuf);
+  else if (entry->has_expire_ts)
+    expiration = entry->expire_ts;
+
+  switch (verdict) {
+    case PKT_CACHE_VERDICT_FORWARD_INTEREST:
+      DEBUG(
+          "Message will be added to PIT (expiration=%ld), "
+          "if nexthops are available",
+          expiration);
+      break;
+
+    case PKT_CACHE_VERDICT_AGGREGATE_INTEREST:
+      forwarder->stats.countInterestsAggregated++;
+      DEBUG("Message aggregated in PIT (expiration=%ld)", expiration);
+      break;
+
+    case PKT_CACHE_VERDICT_RETRANSMIT_INTEREST:
+      forwarder->stats.countInterestsRetransmitted++;
+      DEBUG("Message retransmitted (expiration=%ld)", expiration);
+      break;
+
+    case PKT_CACHE_VERDICT_FORWARD_DATA:
+      forwarder->stats.countInterestsSatisfiedFromStore++;
+      DEBUG("Message satisfied from content store (expiration=%ld)",
+            expiration);
+      break;
+
+    case PKT_CACHE_VERDICT_INTEREST_EXPIRED_FORWARD_INTEREST:
+      forwarder->stats.countInterestsExpired++;
+      DEBUG("Message replaced expired interest (expiration=%ld)", expiration);
+      break;
+
+    case PKT_CACHE_VERDICT_DATA_EXPIRED_FORWARD_INTEREST:
+      forwarder->stats.countDataExpired++;
+      DEBUG("Message replaced expired data (expiration=%ld)", expiration);
+      break;
+
+    case PKT_CACHE_VERDICT_ERROR:
+      ERROR("Inivalid packet cache content");
+      break;
+
+    default:
+      break;
+  }
 }
 
-void forwarder_SetChacheServeFlag(Forwarder *forwarder, bool val) {
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
-  messageProcessor_SetCacheServeFlag(forwarder->processor, val);
+/**
+ * @function forwarder_process_interest
+ * @abstract Receive an interest from the network
+ * @discussion
+ *   (1) if interest in the PIT, aggregate in PIT
+ *   (2) if interest in the ContentStore, reply
+ *   (3) if in the FIB, forward
+ *   (4) drop
+ *
+ */
+static ssize_t forwarder_process_interest(forwarder_t *forwarder,
+                                          off_t msgbuf_id) {
+  assert(forwarder);
+  assert(msgbuf_id_is_valid(msgbuf_id));
+
+  msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(forwarder);
+  msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id);
+
+  assert(msgbuf_get_type(msgbuf) == MSGBUF_TYPE_INTEREST);
+
+  forwarder->stats.countReceived++;
+  forwarder->stats.countInterestsReceived++;
+
+  WITH_DEBUG({
+    char *nameString = name_ToString(msgbuf_get_name(msgbuf));
+    DEBUG("INTEREST (%s) msgbuf_id=%lu ingress=%u length=%u", nameString,
+          msgbuf_id, msgbuf_get_connection_id(msgbuf), msgbuf_get_len(msgbuf));
+    free(nameString);
+  })
+
+  pkt_cache_verdict_t verdict = PKT_CACHE_VERDICT_ERROR;
+  off_t data_msgbuf_id = INVALID_MSGBUF_ID;
+  pkt_cache_entry_t *entry = NULL;
+  pkt_cache_on_interest(forwarder->pkt_cache, msgbuf_pool, msgbuf_id, &verdict,
+                        &data_msgbuf_id, &entry, forwarder->serve_from_cs);
+
+  _forwarder_update_interest_stats(forwarder, verdict, msgbuf, entry);
+
+  return _forwarder_forward_upon_interest(
+      forwarder, msgbuf_pool, data_msgbuf_id, msgbuf_id, entry, verdict);
 }
 
-bool forwarder_GetChacheServeFlag(Forwarder *forwarder) {
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
-  return messageProcessor_GetCacheServeFlag(forwarder->processor);
+static void _forwarder_log_on_data(forwarder_t *forwarder,
+                                   pkt_cache_verdict_t verdict) {
+  switch (verdict) {
+    case PKT_CACHE_VERDICT_FORWARD_DATA:
+      DEBUG("Message added to CS from PIT");
+      break;
+    case PKT_CACHE_VERDICT_STORE_DATA:
+      DEBUG("Message added to CS (expired or no previous interest pending)");
+      break;
+    case PKT_CACHE_VERDICT_CLEAR_DATA:
+      break;
+    case PKT_CACHE_VERDICT_UPDATE_DATA:
+      DEBUG("Message updated in CS");
+      break;
+    case PKT_CACHE_VERDICT_IGNORE_DATA:
+      DEBUG("Message not stored in CS");
+      break;
+    case PKT_CACHE_VERDICT_ERROR:
+      ERROR("Inivalid packet cache content");
+      break;
+    default:
+      break;
+  }
 }
 
-void forwarder_ReceiveCommand(Forwarder *forwarder, command_id command,
-                              struct iovec *message, unsigned ingressId) {
-  configuration_ReceiveCommand(forwarder->config, command, message, ingressId);
+/**
+ * @function forwarder_process_data
+ * @abstract Process an in-bound content object
+ * @discussion
+ *   (1) If it does not match anything in the PIT, drop it
+ *   (2) Add to Content Store
+ *   (3) Reverse path forward via PIT entries
+ *
+ * @param <#param1#>
+ */
+static ssize_t forwarder_process_data(forwarder_t *forwarder, off_t msgbuf_id) {
+  msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(forwarder);
+  msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id);
+
+  WITH_DEBUG({
+    char *nameString = name_ToString(msgbuf_get_name(msgbuf));
+    DEBUG("DATA (%s) msgbuf_id=%lu ingress=%u length=%u", nameString, msgbuf_id,
+          msgbuf_get_connection_id(msgbuf), msgbuf_get_len(msgbuf));
+    free(nameString);
+  )}
+
+  forwarder->stats.countReceived++;
+  forwarder->stats.countObjectsReceived++;
+
+  const connection_table_t *table = forwarder_get_connection_table(forwarder);
+  const connection_t *conn =
+      connection_table_get_by_id(table, msgbuf_get_connection_id(msgbuf));
+
+  pkt_cache_verdict_t verdict = PKT_CACHE_VERDICT_ERROR;
+  bool wrong_egress;
+  nexthops_t *ingressSetUnion =
+      pkt_cache_on_data(forwarder->pkt_cache, msgbuf_pool, msgbuf_id,
+                        forwarder->store_in_cs, connection_is_local(conn), &wrong_egress, &verdict);
+
+  _forwarder_log_on_data(forwarder, verdict);
+
+  if (wrong_egress) {  // Interest sent via a connection but received from another
+    WARN("Data coming from unexpected connection, discarded");
+  } else if (!ingressSetUnion) {  // No match in the PIT
+    forwarder->stats.countDroppedNoReversePath++;
+    DEBUG("Message %lu did not match PIT, no reverse path", msgbuf_id);
+
+    // MOVE PROBE HOOK ELSEWHERE
+    // XXX relationship with forwarding strategy... insert hooks
+    // if the packet is a probe we need to analyze it
+    // NOTE : probes are not stored in PIT
+    if (msgbuf_is_probe(msgbuf)) {
+      fib_entry_t *entry = fib_match_message(forwarder->fib, msgbuf);
+      if (entry && fib_entry_strategy_type(entry) == STRATEGY_TYPE_BESTPATH) {
+        nexthops_t probe_nexthops = NEXTHOPS_EMPTY;
+        nexthops_add(&probe_nexthops, msgbuf_get_connection_id(msgbuf));
+        fib_entry_on_data(entry, &probe_nexthops, msgbuf, 0, ticks_now());
+        // XXX TODO CONFIRM WE DON'T EXIT HERE ?
+      }
+    }
+    forwarder_drop(forwarder, msgbuf_id);
+  } else {
+    // Reverse path forward via PIT entries
+    forwarder_forward_to_nexthops(forwarder, msgbuf_id, ingressSetUnion);
+    free(ingressSetUnion);
+  }
+
+  return msgbuf_get_len(msgbuf);
 }
 
-void forwarder_Receive(Forwarder *forwarder, Message *message) {
-  parcAssertNotNull(forwarder, "Parameter hicn-light must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
+void forwarder_flush_connections(forwarder_t *forwarder) {
+  // DEBUG("[forwarder_flush_connections]");
+  const connection_table_t *table = forwarder_get_connection_table(forwarder);
 
-  // this takes ownership of the message, so we're done here
+  for (unsigned i = 0; i < forwarder->num_pending_conn; i++) {
+    unsigned conn_id = forwarder->pending_conn[i];
+    const connection_t *conn = connection_table_at(table, conn_id);
+    if (!connection_flush(conn)) {
+      WARN("Could not flush connection queue");
+      // XXX keep track of non flushed connections...
+    }
+  }
+  forwarder->num_pending_conn = 0;
+  // DEBUG("[forwarder_flush_connections] done");
+}
 
+// XXX move to wldr file, worst case in connection.
+void forwarder_apply_wldr(const forwarder_t *forwarder, const msgbuf_t *msgbuf,
+                          connection_t *connection) {
   // this are the checks needed to implement WLDR. We set wldr only on the STAs
-  // and we let the AP to react according to choise of the client.
+  // and we let the AP to react according to choice of the client.
   // if the STA enables wldr using the set command, the AP enable wldr as well
   // otherwise, if the STA disable it the AP remove wldr
   // WLDR should be enabled only on the STAs using the command line
   // TODO
   // disable WLDR command line on the AP
-  const Connection *conn = connectionTable_FindById(
-      forwarder->connectionTable, message_GetIngressConnectionId(message));
-
-  if (!conn) {
-    /*
-     * Drop is a static method in messageProcessor which might or might not need
-     * to be called for accounting purposes. This call was initially absent so
-     * the behaviour was kept like this, as this situation is unlikely. We need
-     * to release memory though, as this is not done in Drop anyways.
-     */
-    //messageProcessor_Drop(forwarder->processor, message);
-    message_Release(&message);
-    return;
-  }
-
-  if (message_HasWldr(message)) {
-    if (connection_HasWldr(conn)) {
+  if (msgbuf_has_wldr(msgbuf)) {
+    if (connection_has_wldr(connection)) {
       // case 1: WLDR is enabled
-      connection_DetectLosses((Connection *)conn, message);
-    } else if (!connection_HasWldr(conn) &&
-               connection_WldrAutoStartAllowed(conn)) {
+      connection_wldr_detect_losses(connection, msgbuf);
+    } else if (!connection_has_wldr(connection) &&
+               connection_wldr_autostart_is_allowed(connection)) {
       // case 2: We are on an AP. We enable WLDR
-      connection_EnableWldr((Connection *)conn);
-      connection_DetectLosses((Connection *)conn, message);
+      connection_wldr_enable(connection, true);
+      connection_wldr_detect_losses(connection, msgbuf);
     }
     // case 3: Ignore WLDR
   } else {
-    if (connection_HasWldr(conn) && connection_WldrAutoStartAllowed(conn)) {
+    if (connection_has_wldr(connection) &&
+        connection_wldr_autostart_is_allowed(connection)) {
       // case 1: STA do not use WLDR, we disable it
-      connection_DisableWldr((Connection *)conn);
+      connection_wldr_enable(connection, false);
     }
   }
-
-  messageProcessor_Receive(forwarder->processor, message);
 }
 
-Ticks forwarder_GetTicks(const Forwarder *forwarder) {
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
-  return parcClock_GetTime(forwarder->clock) + forwarder->clockOffset;
-}
+bool forwarder_add_or_update_route(forwarder_t *forwarder, ip_prefix_t *prefix,
+                                   unsigned ingress_id) {
+  assert(forwarder);
+  assert(prefix);
 
-Ticks forwarder_NanosToTicks(uint64_t nanos) { return NSEC_TO_TICKS(nanos); }
+  configuration_t *config = forwarder_get_configuration(forwarder);
 
-uint64_t forwarder_TicksToNanos(Ticks ticks) {
-  return (1000000000ULL) * ticks / HZ;
-}
+  char prefix_s[MAXSZ_IP_PREFIX];
+  int rc = ip_prefix_snprintf(prefix_s, MAXSZ_IP_PREFIX, prefix);
+  assert(rc < MAXSZ_IP_PREFIX);
+  if (rc < 0) return false;
+
+  DEBUG("Adding prefix=%s for conn_id=%d", prefix_s, ingress_id);
 
-bool forwarder_AddOrUpdateRoute(Forwarder *forwarder,
-                                add_route_command *control, unsigned ifidx) {
-  parcAssertNotNull(forwarder, "Parameter hicn-light must be non-null");
-  parcAssertNotNull(control, "Parameter route must be non-null");
+  // XXX TODO this should store options too
+  strategy_type_t strategy_type = configuration_get_strategy(config, prefix_s);
 
-  // we only have one message processor
-  bool res =
-      messageProcessor_AddOrUpdateRoute(forwarder->processor, control, ifidx);
+  Name name_prefix = EMPTY_NAME;
+  name_CreateFromAddress(&name_prefix, prefix->family, prefix->address,
+                         prefix->len);
+  fib_entry_t *entry = fib_contains(forwarder->fib, &name_prefix);
+  if (!entry) {
+    entry = fib_entry_create(&name_prefix, strategy_type, NULL, forwarder);
+    fib_entry_nexthops_add(entry, ingress_id);
+    fib_add(forwarder->fib, entry);
+
+  } else {
+    fib_entry_nexthops_add(entry, ingress_id);
+  }
 
-  return res;
+  return true;
 }
 
+bool forwarder_remove_route(forwarder_t *forwarder, ip_prefix_t *prefix,
+                            unsigned ingress_id) {
+  assert(forwarder);
+  assert(prefix);
 
-bool forwarder_RemoveRoute(Forwarder *forwarder, remove_route_command *control,
-                           unsigned ifidx) {
-  parcAssertNotNull(forwarder, "Parameter hicn-light must be non-null");
-  parcAssertNotNull(control, "Parameter route must be non-null");
+  Name name_prefix = EMPTY_NAME;
+  name_CreateFromAddress(&name_prefix, prefix->family, prefix->address,
+                         prefix->len);
+  fib_remove(forwarder->fib, &name_prefix, ingress_id);
 
-  // we only have one message processor
-  return messageProcessor_RemoveRoute(forwarder->processor, control, ifidx);
+  return true;
 }
 
 #ifdef WITH_POLICY
 
-bool forwarder_AddOrUpdatePolicy(Forwarder *forwarder,
-                                add_policy_command *control) {
-  parcAssertNotNull(forwarder, "Parameter forwarder must be non-null");
-  parcAssertNotNull(control, "Parameter control must be non-null");
+bool forwarder_add_or_update_policy(forwarder_t *forwarder, ip_prefix_t *prefix,
+                                    hicn_policy_t *policy) {
+  assert(forwarder);
+  assert(prefix);
+  assert(policy);
 
-  return messageProcessor_AddOrUpdatePolicy(forwarder->processor, control);
+  Name name_prefix = EMPTY_NAME;
+  name_CreateFromAddress(&name_prefix, prefix->family, prefix->address,
+                         prefix->len);
+  fib_entry_t *entry = fib_contains(forwarder->fib, &name_prefix);
+  if (!entry) return false;
+  fib_entry_set_policy(entry, *policy);
+
+  return true;
 }
 
-bool forwarder_RemovePolicy(Forwarder *forwarder, remove_policy_command *control) {
-  parcAssertNotNull(forwarder, "Parameter forwarder must be non-null");
-  parcAssertNotNull(control, "Parameter control must be non-null");
+bool forwarder_remove_policy(forwarder_t *forwarder, ip_prefix_t *prefix) {
+  assert(forwarder);
+  assert(prefix);
+
+  Name name_prefix = EMPTY_NAME;
+  name_CreateFromAddress(&name_prefix, prefix->family, prefix->address,
+                         prefix->len);
+  fib_entry_t *entry = fib_contains(forwarder->fib, &name_prefix);
+
+  if (!entry) return false;
+
+  fib_entry_set_policy(entry, POLICY_EMPTY);
 
-  return messageProcessor_RemovePolicy(forwarder->processor, control);
+  return true;
 }
 
 #endif /* WITH_POLICY */
 
-void forwarder_RemoveConnectionIdFromRoutes(Forwarder *forwarder,
-                                            unsigned connectionId) {
-  parcAssertNotNull(forwarder, "Parameter hicn-light must be non-null");
-  messageProcessor_RemoveConnectionIdFromRoutes(forwarder->processor,
-                                                connectionId);
+void forwarder_remove_connection_id_from_routes(forwarder_t *forwarder,
+                                                unsigned connection_id) {
+  assert(forwarder);
+
+  fib_remove_connection_id(forwarder->fib, connection_id);
 }
 
-void forwarder_SetStrategy(Forwarder *forwarder, Name *prefix,
-                           strategy_type strategy,
-                           unsigned related_prefixes_len,
-                           Name **related_prefixes) {
-  parcAssertNotNull(forwarder, "Parameter hicn-light must be non-null");
-  parcAssertNotNull(prefix, "Parameter prefix must be non-null");
+void forwarder_add_strategy_options(forwarder_t *forwarder, Name *name_prefix,
+                                    strategy_type_t strategy_type,
+                                    strategy_options_t *strategy_options) {
+  assert(forwarder);
+  assert(name_prefix);
+  assert(strategy_options);
+  assert(STRATEGY_TYPE_VALID(strategy_type));
+
+  fib_entry_t *entry = fib_contains(forwarder->fib, name_prefix);
+  if (!entry) return;
 
-  processor_SetStrategy(forwarder->processor, prefix, strategy,
-                        related_prefixes_len, related_prefixes);
+  fib_entry_add_strategy_options(entry, strategy_type, strategy_options);
 }
 
-FibEntryList *forwarder_GetFibEntries(Forwarder *forwarder) {
-  return messageProcessor_GetFibEntries(forwarder->processor);
+void forwarder_set_strategy(forwarder_t *forwarder, Name *name_prefix,
+                            strategy_type_t strategy_type,
+                            strategy_options_t *strategy_options) {
+  assert(forwarder);
+  assert(name_prefix);
+  assert(STRATEGY_TYPE_VALID(strategy_type));
+  /* strategy_options might be NULL */
+
+  fib_entry_t *entry = fib_contains(forwarder->fib, name_prefix);
+  if (!entry) {
+    // there is no exact match. so if the forwarding strategy is not in the list
+    // of strategies that can be set by the transport, return
+    if (strategy_type != STRATEGY_TYPE_BESTPATH &&
+        strategy_type != STRATEGY_TYPE_REPLICATION) {
+      return;
+    }
+
+    // here it may be the transprot that wants to set the strategy, but it has
+    // no knowledge of the length of the prefix. so we apply the strategy at the
+    // matching fib entry, which later will be the one that will be used to send
+    // interests with this name
+    entry = fib_match_name(forwarder->fib, name_prefix);
+    if (!entry) {
+      return;  // no fib match, return
+    }
+  }
+
+  fib_entry_set_strategy(entry, strategy_type, strategy_options);
 }
 
-void forwarder_SetContentObjectStoreSize(Forwarder *forwarder,
-                                         size_t maximumContentStoreSize) {
-  messageProcessor_SetContentObjectStoreSize(forwarder->processor,
-                                             maximumContentStoreSize);
+cs_t *forwarder_get_cs(const forwarder_t *forwarder) {
+  assert(forwarder);
+
+  return pkt_cache_get_cs(forwarder->pkt_cache);
 }
 
-void forwarder_ClearCache(Forwarder *forwarder) {
-  messageProcessor_ClearCache(forwarder->processor);
+// =======================================================
+
+fib_t *forwarder_get_fib(forwarder_t *forwarder) { return forwarder->fib; }
+
+msgbuf_pool_t *forwarder_get_msgbuf_pool(const forwarder_t *forwarder) {
+  return forwarder->msgbuf_pool;
 }
 
-PARCClock *forwarder_GetClock(const Forwarder *forwarder) {
-  return forwarder->clock;
+#ifdef WITH_MAPME
+void forwarder_on_connection_event(const forwarder_t *forwarder,
+                                   const connection_t *connection,
+                                   connection_event_t event) {
+  mapme_on_connection_event(forwarder->mapme, connection, event);
 }
 
-#if !defined(__APPLE__)
-hicn_socket_helper_t *forwarder_GetHicnSocketHelper(Forwarder *forwarder) {
-  return forwarder->hicnSocketHelper;
+mapme_t *forwarder_get_mapme(const forwarder_t *forwarder) {
+  return forwarder->mapme;
 }
-#endif
 
-// =======================================================
+#endif /* WITH_MAPME */
 
-static void _signal_cb(int sig, PARCEventType events, void *user_data) {
-  Forwarder *forwarder = (Forwarder *)user_data;
+#ifdef WITH_POLICY_STATS
+const policy_stats_mgr_t *forwarder_get_policy_stats_mgr(
+    const forwarder_t *forwarder) {
+  return &forwarder->policy_stats_mgr;
+}
+#endif /* WITH_POLICY_STATS */
 
-  logger_Log(forwarder->logger, LoggerFacility_Core, PARCLogLevel_Warning,
-             __func__, "signal %d events %d", sig, events);
+/**
+ * @brief Process a packet by creating the corresponding message buffer and
+ * dispatching it to the forwarder for further processing.
+ * @param[in] forwarder Forwarder instance.
+ *
+ */
+// XXX ??? XXX = process for listener as we are resolving connection id
+//
+
+msgbuf_type_t get_type_from_packet(uint8_t *packet) {
+  if (messageHandler_IsTCP(packet)) {
+    if (messageHandler_IsData(packet)) {
+      return MSGBUF_TYPE_DATA;
+    } else if (messageHandler_IsInterest(packet)) {
+      return MSGBUF_TYPE_INTEREST;
+    } else {
+      return MSGBUF_TYPE_UNDEFINED;
+    }
 
-  switch ((int)sig) {
-    case SIGTERM:
-      logger_Log(forwarder->logger, LoggerFacility_Core, PARCLogLevel_Warning,
-                 __func__, "Caught an terminate signal; exiting cleanly.");
-      dispatcher_Stop(forwarder->dispatcher);
-      break;
+  } else if (messageHandler_IsWldrNotification(packet)) {
+    return MSGBUF_TYPE_WLDR_NOTIFICATION;
 
-    case SIGINT:
-      logger_Log(forwarder->logger, LoggerFacility_Core, PARCLogLevel_Warning,
-                 __func__, "Caught an interrupt signal; exiting cleanly.");
-      dispatcher_Stop(forwarder->dispatcher);
-      break;
-#ifndef _WIN32
-    case SIGUSR1:
-      // dump stats
-      break;
-#endif
+  } else if (mapme_match_packet(packet)) {
+    return MSGBUF_TYPE_MAPME;
 
-    default:
-      break;
-  }
-}
+  } else if (*packet == REQUEST_LIGHT) {
+    return MSGBUF_TYPE_COMMAND;
 
-static void _keepalive_cb(int fd, PARCEventType what, void *user_data) {
-  parcAssertTrue(what & PARCEventType_Timeout, "Got unexpected tick_cb: %d",
-                 what);
-  // function is just a keepalive for hicn-light, does not do anything
+  } else {
+    return MSGBUF_TYPE_UNDEFINED;
+  }
 }
 
-#ifdef WITH_MAPME
-FIB *forwarder_getFib(Forwarder *forwarder) {
-  return messageProcessor_getFib(forwarder->processor);
+/**
+ * @brief Finalize (i.e. close fd and free internal data structures)
+ * the current connection ("SELF") when the command is received.
+ * The connection cannot be removed inside the command handling
+ * because it is needed to return the ack back.
+ */
+static void _forwarder_finalize_connection_if_self(connection_t *conn,
+                                                   msgbuf_t *msgbuf) {
+  uint8_t *packet = msgbuf_get_packet(msgbuf);
+  msg_connection_remove_t *msg = (msg_connection_remove_t *)packet;
+  cmd_connection_remove_t *control = &msg->payload;
+
+  if (strcmp(control->symbolic_or_connid, "SELF") == 0)
+    connection_finalize(conn);
 }
 
-void forwarder_onConnectionEvent(Forwarder *forwarder, const Connection *conn, connection_event_t event) {
-//#ifdef WITH_POLICY
-//    messageProcessor_onConnectionEvent(forwarder->processor, conn, event);
-//#else
-  mapme_onConnectionEvent(forwarder->mapme, conn, event);
-//#endif /* WITH_POLICY */
-}
+ssize_t forwarder_receive(forwarder_t *forwarder, listener_t *listener,
+                          off_t msgbuf_id, address_pair_t *pair, Ticks now) {
+  assert(forwarder);
+  /* listener can be NULL */
+  assert(msgbuf_id_is_valid(msgbuf_id));
+  assert(pair);
+
+  msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(forwarder);
+  msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id);
+  assert(msgbuf);
+
+  uint8_t *packet = msgbuf_get_packet(msgbuf);
+  size_t size = msgbuf_get_len(msgbuf);
+
+  /* Connection lookup */
+  const connection_table_t *table =
+      forwarder_get_connection_table(listener->forwarder);
+  connection_t *connection = connection_table_get_by_pair(table, pair);
+  unsigned conn_id = connection
+                         ? connection_table_get_connection_id(table, connection)
+                         : CONNECTION_ID_UNDEFINED;
+
+  assert((conn_id != CONNECTION_ID_UNDEFINED) || listener);
+
+  msgbuf_type_t type = get_type_from_packet(msgbuf_get_packet(msgbuf));
+
+  msgbuf->type = type;
+  msgbuf->connection_id = conn_id;
+  msgbuf->recv_ts = now;
+
+  switch (type) {
+    case MSGBUF_TYPE_INTEREST:
+      if (!connection_id_is_valid(msgbuf->connection_id)) {
+        char *conn_name = connection_table_get_random_name(table);
+        unsigned connection_id =
+            listener_create_connection(listener, conn_name, pair);
+        msgbuf->connection_id = connection_id;
+        connection = connection_table_get_by_id(table, connection_id);
+        free(conn_name);
+      }
+      msgbuf->path_label = 0;  // not used for interest packets
+      name_create_from_interest(packet, msgbuf_get_name(msgbuf));
+      forwarder_apply_wldr(forwarder, msgbuf, connection);
+      forwarder_process_interest(forwarder, msgbuf_id);
+
+      pkt_cache_log(forwarder->pkt_cache);
+      return size;
+
+    case MSGBUF_TYPE_DATA:
+      if (!connection_id_is_valid(msgbuf->connection_id))
+        return forwarder_drop(forwarder, msgbuf_id);
+      msgbuf_init_pathlabel(msgbuf);
+      name_create_from_data(packet, msgbuf_get_name(msgbuf));
+      forwarder_apply_wldr(forwarder, msgbuf, connection);
+      forwarder_process_data(forwarder, msgbuf_id);
+
+      pkt_cache_log(forwarder->pkt_cache);
+      return size;
+
+    case MSGBUF_TYPE_WLDR_NOTIFICATION:
+      if (!connection_id_is_valid(msgbuf->connection_id))
+        return forwarder_drop(forwarder, msgbuf_id);
+      connection_wldr_handle_notification(connection, msgbuf);
+      return size;
+
+    case MSGBUF_TYPE_MAPME:
+      // XXX what about acks ?
+      if (!connection_id_is_valid(msgbuf->connection_id)) {
+        char *conn_name = connection_table_get_random_name(table);
+        msgbuf->connection_id =
+            listener_create_connection(listener, conn_name, pair);
+        free(conn_name);
+      }
+      mapme_process(forwarder->mapme, msgbuf);
+      return size;
+
+    case MSGBUF_TYPE_COMMAND:
+      // Create the connection to send the ack back
+      if (!connection_id_is_valid(msgbuf->connection_id)) {
+        char *conn_name = connection_table_get_random_name(table);
+        unsigned connection_id =
+            listener_create_connection(listener, conn_name, pair);
+        msgbuf->connection_id = connection_id;
+        connection = connection_table_get_by_id(table, connection_id);
+        free(conn_name);
+      }
+
+      msg_header_t *msg = (msg_header_t *)packet;
+      msgbuf->command.type = msg->header.command_id;
+      if (!command_type_is_valid(msgbuf->command.type)) {
+        ERROR("Invalid command");
+        return 0;
+      }
+
+      size = command_process_msgbuf(forwarder, msgbuf);
+      if (msgbuf->command.type == COMMAND_TYPE_CONNECTION_REMOVE)
+        _forwarder_finalize_connection_if_self(connection, msgbuf);
+      return size;
 
-void forwarder_ProcessMapMe(Forwarder *forwarder, const uint8_t *msgBuffer,
-                            unsigned conn_id) {
-  mapme_Process(forwarder->mapme, msgBuffer, conn_id);
+    default:
+      ERROR("Invalid msgbuf type");
+      forwarder_drop(forwarder, msgbuf_id);
+      return 0;
+  }
 }
 
-MapMe *
-forwarder_getMapmeInstance(const Forwarder *forwarder) {
-    return forwarder->mapme;
+void forwarder_log(forwarder_t *forwarder) {
+  DEBUG(
+      "Forwarder: received = %u (interest = %u, data = %u), dropped = %u "
+      "(interest = %u, data = %u, other = %u), forwarded = { interests = %u, "
+      "data = %u }, dropped = { connection_not_found = %u, send_failure = %u, "
+      "no_route_in_fib = %u }, interest processing = { aggregated = %u, "
+      "retransmitted = %u, satisfied_from_cs = %u, expired_interests = %u, "
+      "expired_data = %u }, data processing = { "
+      "no_reverse_path = %u }\n",
+      forwarder->stats.countReceived, forwarder->stats.countInterestsReceived,
+      forwarder->stats.countObjectsReceived, forwarder->stats.countDropped,
+      forwarder->stats.countInterestsDropped,
+      forwarder->stats.countObjectsDropped, forwarder->stats.countOtherDropped,
+      forwarder->stats.countInterestForwarded,
+      forwarder->stats.countObjectsForwarded,
+      forwarder->stats.countDroppedConnectionNotFound,
+      forwarder->stats.countSendFailures, forwarder->stats.countDroppedNoRoute,
+      forwarder->stats.countInterestsAggregated,
+      forwarder->stats.countInterestsRetransmitted,
+      forwarder->stats.countInterestsSatisfiedFromStore,
+      forwarder->stats.countInterestsExpired, forwarder->stats.countDataExpired,
+      forwarder->stats.countDroppedNoReversePath);
 }
-
-#endif /* WITH_MAPME */
diff --git a/hicn-light/src/hicn/core/forwarder.h b/hicn-light/src/hicn/core/forwarder.h
index d1815b7d4..76c12368a 100644
--- a/hicn-light/src/hicn/core/forwarder.h
+++ b/hicn-light/src/hicn/core/forwarder.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -18,292 +18,212 @@
  * only be called within the forwarders thread of execution.
  */
 
-#ifndef forwarder_h
-#define forwarder_h
+#ifndef HICNLIGHT_FORWARDER_H
+#define HICNLIGHT_FORWARDER_H
 
-#ifndef _WIN32
-#include <sys/time.h>
-#endif
-#include <stdlib.h>
-
-#include <hicn/core/connectionTable.h>
-#include <hicn/core/dispatcher.h>
-#include <hicn/messenger/messenger.h>
+//#ifndef _WIN32
+//#include <sys/time.h>
+//#endif
+//
 
-#include <hicn/core/message.h>
+#include <stdlib.h>
+#include <sys/socket.h>  // struct mmsghdr
 
-#include <hicn/config/configuration.h>
+#include "connection.h"
+#include "connection_table.h"
+#include "packet_cache.h"
+#include "listener_table.h"
+#include "msgbuf.h"
+#include "msgbuf_pool.h"
+#include "../config/configuration.h"
+#include "subscription.h"
 
 #ifdef WITH_MAPME
-#include <hicn/processor/fib.h>
+#include "fib.h"
 #endif /* WITH_MAPME */
 
-#include <hicn/core/logger.h>
-#include <hicn/core/ticks.h>
-#include <hicn/io/listenerSet.h>
-
-#include <hicn/processor/fibEntryList.h>
-
-#include <parc/algol/parc_Clock.h>
-
-#if !defined(__APPLE__)
-#include <hicn/socket/api.h>
-#endif
-
 #define PORT_NUMBER 9695
 #define PORT_NUMBER_AS_STRING "9695"
 
-#include <hicn/utils/commands.h>
+//#include <hicn/utils/commands.h>
 
 // ==============================================
 
-struct forwarder;
-typedef struct forwarder Forwarder;
+typedef struct forwarder_s forwarder_t;
 
 /**
- * @function forwarder_Create
- * @abstract Create the forwarder and use the provided logger for diagnostic
+ * @brief Create the forwarder and use the provided logger for diagnostic
  * output
  * @discussion
  *   If the logger is null, hicn-light will create a STDOUT logger.
  *
  * @param logger may be NULL
  */
-Forwarder *forwarder_Create(Logger *logger);
+forwarder_t *forwarder_create(configuration_t *configuration);
 
 /**
- * @function forwarder_Destroy
- * @abstract Destroys the forwarder, stopping all traffic and freeing all memory
+ * @brief Destroys the forwarder, stopping all traffic and freeing all memory
  */
-void forwarder_Destroy(Forwarder **ptr);
+void forwarder_free(forwarder_t *forwarder);
 
 /**
- * @function forwarder_SetupAllListeners
- * @abstract Setup all listeners (tcp, udp, local, ether, ip multicast) on all
- * interfaces
- * @discussion
- *   Sets up all listeners on all running interfaces.  This provides a quick and
- * easy startup, rather than providing a configuration file or programmatic
- * commands.
- *
- * @param port is used by TCP and UDP listeners, in host byte order
- * @param localPath is the AF_UNIX path to use, if NULL no AF_UNIX listener is
- * setup
- */
-void forwarder_SetupAllListeners(Forwarder *forwarder, uint16_t port,
-                                 const char *localPath);
-/**
- * @function forwarder_SetupAllListeners
- * @abstract Setup one tcp and one udp listener on address 127.0.0.1 and the
+ * @brief Setup one tcp and one udp listener on address 127.0.0.1 and the
  * given port
  */
-void forwarder_SetupLocalListeners(Forwarder *forwarder, uint16_t port);
-
-/**
- * Configure hicn-light via a configuration file
- *
- * The configuration file is a set of lines, just like used in hicnLightControl.
- * You need to have "add listener" lines in the file to receive connections.  No
- * default listeners are configured.
- *
- * @param [in] forwarder An alloated Forwarder
- * @param [in] filename The path to the configuration file
- */
-void forwarder_SetupFromConfigFile(Forwarder *forwarder, const char *filename);
-
-/**
- * Returns the logger used by this forwarder
- *
- * If you will store the logger, you should acquire a reference to it.
- *
- * @param [in] forwarder An allocated hicn-light forwarder
- *
- * @retval non-null The logger used by hicn-light
- * @retval null An error
- */
-Logger *forwarder_GetLogger(const Forwarder *forwarder);
-
-/**
- * @function forwarder_SetLogLevel
- * @abstract Sets the minimum level to log
- */
-void forwarder_SetLogLevel(Forwarder *forwarder, PARCLogLevel level);
-
-/**
- * @function forwarder_GetNextConnectionId
- * @abstract Get the next identifier for a new connection
- */
-unsigned forwarder_GetNextConnectionId(Forwarder *forwarder);
+void forwarder_setup_local_listeners(forwarder_t *forwarder, uint16_t port);
 
-Messenger *forwarder_GetMessenger(Forwarder *forwarder);
+configuration_t *forwarder_get_configuration(forwarder_t *forwarder);
 
-Dispatcher *forwarder_GetDispatcher(Forwarder *forwarder);
+subscription_table_t *forwarder_get_subscriptions(forwarder_t *forwarder);
 
 /**
  * Returns the set of currently active listeners
  *
- * @param [in] forwarder An allocated hicn-light forwarder
+ * @param[in] forwarder An allocated hicn-light forwarder
  *
  * @retval non-null The set of active listeners
  * @retval null An error
  */
-ListenerSet *forwarder_GetListenerSet(Forwarder *forwarder);
+listener_table_t *forwarder_get_listener_table(forwarder_t *forwarder);
 
 /**
  * Returns the forwrder's connection table
  *
- * @param [in] forwarder An allocated hicn-light forwarder
+ * @param[in] forwarder An allocated hicn-light forwarder
  *
  * @retval non-null The connection tabler
  * @retval null An error
  *
  */
-#ifdef WITH_POLICY
-ConnectionTable *forwarder_GetConnectionTable(const Forwarder *forwarder);
-#else
-ConnectionTable *forwarder_GetConnectionTable(Forwarder *forwarder);
-#endif /* WITH_POLICY */
+connection_table_t *forwarder_get_connection_table(
+    const forwarder_t *forwarder);
 
-/**
- * Returns a Tick-based clock
- *
- * Runs at approximately 1 msec per tick (see HZ in forwarder.c).
- * Do not Release this clock.  If you save a copy of it, create your own
- * reference to it with parcClock_Acquire().
- *
- * @param [in] forwarder An allocated hicn-light forwarder
- *
- * @retval non-null An allocated hicn-light Clock based on the Tick counter
- * @retval null An error
- */
-PARCClock *forwarder_GetClock(const Forwarder *forwarder);
+void forwarder_cs_set_store(forwarder_t *forwarder, bool val);
 
-/**
- * Direct call to get the Tick clock
- *
- * Runs at approximately 1 msec per tick (see HZ in forwarder.c)
- *
- * @param [in] forwarder An allocated hicn-light forwarder
- */
-Ticks forwarder_GetTicks(const Forwarder *forwarder);
+bool forwarder_cs_get_store(forwarder_t *forwarder);
+
+void forwarder_cs_set_serve(forwarder_t *forwarder, bool val);
+
+bool forwarder_cs_get_serve(forwarder_t *forwarder);
 
 /**
- * Convert nano seconds to Ticks
+ * Sets the maximum number of content objects in the content store
  *
- * Converts nano seconds to Ticks, based on HZ (in forwarder.c)
+ * Implementation dependent - may wipe the cache.
  */
-Ticks forwarder_NanosToTicks(uint64_t nanos);
-
-uint64_t forwarder_TicksToNanos(Ticks ticks);
+void forwarder_cs_set_size(forwarder_t *forwarder, size_t size);
 
-void forwarder_ReceiveCommand(Forwarder *forwarder, command_id command,
-                              struct iovec *message, unsigned ingressId);
-
-void forwarder_Receive(Forwarder *forwarder, Message *mesage);
+size_t forwarder_cs_get_size(forwarder_t *forwarder);
+size_t forwarder_cs_get_num_stale_entries(forwarder_t *forwarder);
+void forwarder_cs_clear(forwarder_t *forwarder);
 
 /**
- * @function forwarder_AddOrUpdateRoute
- * @abstract Adds or updates a route on all the message processors
+ * @brief Adds or updates a route on all the message processors
  */
-bool forwarder_AddOrUpdateRoute(Forwarder *forwarder,
-                                add_route_command *control, unsigned ifidx);
+bool forwarder_add_or_update_route(forwarder_t *forwarder, ip_prefix_t *prefix,
+                                   unsigned ingress_id);
 
 /**
- * @function forwarder_RemoveRoute
- * @abstract Removes a route from all the message processors
+ * @brief Removes a route from all the message processors
  */
-bool forwarder_RemoveRoute(Forwarder *forwarder, remove_route_command *control,
-                           unsigned ifidx);
+bool forwarder_remove_route(forwarder_t *forwarder, ip_prefix_t *prefix,
+                            unsigned ingress_id);
 
 #ifdef WITH_POLICY
 /**
- * @function forwarder_AddOrUpdatePolicy
- * @abstract Adds or updates a policy on the message processor
+ * @brief Adds or updates a policy on the message processor
  */
-bool forwarder_AddOrUpdatePolicy(Forwarder *forwarder, add_policy_command *control);
+bool forwarder_add_or_update_policy(forwarder_t *forwarder, ip_prefix_t *prefix,
+                                    hicn_policy_t *policy);
 
 /**
- * @function forwarder_RemovePolicy
- * @abstract Removes a policy from the message processor
+ * @brief Removes a policy from the message processor
  */
-bool forwarder_RemovePolicy(Forwarder *forwarder, remove_policy_command *control);
+bool forwarder_remove_policy(forwarder_t *forwarder, ip_prefix_t *prefix);
+
 #endif /* WITH_POLICY */
 
 /**
  * Removes a connection id from all routes
  */
-void forwarder_RemoveConnectionIdFromRoutes(Forwarder *forwarder,
-                                            unsigned connectionId);
+void forwarder_remove_connection_id_from_routes(forwarder_t *forwarder,
+                                                unsigned connection_id);
 
-/**
- * @function forwarder_GetConfiguration
- * @abstract The configuration object
- * @discussion
- *   The configuration contains all user-issued commands.  It does not include
- * dynamic state.
- */
-Configuration *forwarder_GetConfiguration(Forwarder *forwarder);
+void forwarder_add_strategy_options(forwarder_t *forwarder, Name *name_prefix,
+                                    strategy_type_t strategy_type,
+                                    strategy_options_t *strategy_options);
 
-FibEntryList *forwarder_GetFibEntries(Forwarder *forwarder);
+void forwarder_set_strategy(forwarder_t *forwarder, Name *name_prefix,
+                            strategy_type_t strategy_type,
+                            strategy_options_t *strategy_options);
+
+cs_t *forwarder_get_cs(const forwarder_t *forwarder);
 
 /**
- * Sets the maximum number of content objects in the content store
- *
- * Implementation dependent - may wipe the cache.
+ * @brief Returns the forwarder's FIB.
+ * @param[in] forwarder - Pointer to the forwarder.
+ * @returns Pointer to the hICN FIB.
  */
-void forwarder_SetContentObjectStoreSize(Forwarder *forwarder,
-                                         size_t maximumContentStoreSize);
-
-void forwarder_SetChacheStoreFlag(Forwarder *forwarder, bool val);
-
-bool forwarder_GetChacheStoreFlag(Forwarder *forwarder);
-
-void forwarder_SetChacheServeFlag(Forwarder *forwarder, bool val);
-
-bool forwarder_GetChacheServeFlag(Forwarder *forwarder);
-
-void forwarder_ClearCache(Forwarder *forwarder);
-
-void forwarder_SetStrategy(Forwarder *forwarder, Name *prefix,
-                           strategy_type strategy, unsigned related_prefixes_len,
-                           Name **related_prefixes);
-#if !defined(__APPLE__)
-hicn_socket_helper_t *forwarder_GetHicnSocketHelper(Forwarder *forwarder);
-#endif
-#ifdef WITH_MAPME
+fib_t *forwarder_get_fib(forwarder_t *forwarder);
 
 /**
- * @function forwarder_getFib
- * @abstract Returns the hICN forwarder's FIB.
- * @param [in] forwarder - Pointer to the hICN forwarder.
- * @returns Pointer to the hICN FIB.
+ * @brief Return the forwarder packet pool.
+ * @param[in] forwarder The forwarder from which to retrieve the packet
+ * pool.
+ * @return msgbuf_pool_t * The forwarder packet pool.
  */
-FIB *forwarder_getFib(Forwarder *forwarder);
+msgbuf_pool_t *forwarder_get_msgbuf_pool(const forwarder_t *forwarder);
+
+#ifdef WITH_MAPME
 
 /**
- * @function forwarder_onConnectionEvent
- * @abstract Callback fired upon addition of a new connection through the
+ * @brief Callback fired upon addition of a new connection through the
  *   control protocol.
- * @param [in] forwarder - Pointer to the hICN forwarder.
- * @param [in] conn - Pointer to the newly added connection.
- * @param [in] event - Connection event
+ * @param[in] forwarder - Pointer to the forwarder.
+ * @param[in] conn - Pointer to the newly added connection.
+ * @param[in] event - Connection event
  */
-void forwarder_onConnectionEvent(Forwarder *forwarder, const Connection *conn, connection_event_t event);
+void forwarder_on_connection_event(const forwarder_t *forwarder,
+                                   const connection_t *connection,
+                                   connection_event_t event);
 
 /**
- * @function forwarder_ProcessMapMe
- * @abstract Callback fired by an hICN listener upon reception of a MAP-Me
+ * @brief Callback fired by an hICN listener upon reception of a MAP-Me
  *      message.
- * @param [in] forwarder - Pointer to the hICN forwarder.
- * @param [in] msgBuffer - MAP-Me buffer
- * @param [in] conn_id - Ingress connection id
+ * @param[in] forwarder - Pointer to the forwarder.
+ * @param[in] msgBuffer - MAP-Me buffer
+ * @param[in] conn_id - Ingress connection id
  */
-void forwarder_ProcessMapMe(Forwarder *forwarder, const uint8_t *msgBuffer,
-                            unsigned conn_id);
+void forwarder_process_mapme(const forwarder_t *forwarder,
+                             const uint8_t *packet, unsigned conn_id);
 
-struct mapme;
-struct mapme * forwarder_getMapmeInstance(const Forwarder *forwarder);
+struct mapme_s *forwarder_get_mapme(const forwarder_t *forwarder);
 
 #endif /* WITH_MAPME */
 
-#endif  // forwarder_h
+#ifdef WITH_POLICY_STATS
+const policy_stats_mgr_t *forwarder_get_policy_stats_mgr(
+    const forwarder_t *forwarder);
+#endif /* WITH_POLICY_STATS */
+
+void forwarder_flush_connections(forwarder_t *forwarder);
+
+/**
+ * @brief Handles a newly received packet from a listener.
+ *
+ * NOTE: the received msgbuf is incomplete and only holds the packet content and
+ * size/
+ */
+ssize_t forwarder_receive(forwarder_t *forwarder, listener_t *listener,
+                          off_t msgbuf_id, address_pair_t *pair, Ticks now);
+
+/**
+ * @brief Log forwarder statistics, e.g. info about packets processed, packets
+ * dropped, packets forwarded, errors while forwarding, interest and data
+ * processing results.
+ *
+ * @param forwarder Pointer to the forwarder data structure to use
+ */
+void forwarder_log(forwarder_t *forwarder);
+
+#endif  // HICNLIGHT_FORWARDER_H
diff --git a/hicn-light/src/hicn/core/listener.c b/hicn-light/src/hicn/core/listener.c
new file mode 100644
index 000000000..ecdfc38f4
--- /dev/null
+++ b/hicn-light/src/hicn/core/listener.c
@@ -0,0 +1,444 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file listener.c
+ * @brief Implementation of hICN listeners
+ */
+
+#include <string.h>  // strdup
+
+#include <hicn/util/log.h>
+
+#include "forwarder.h"
+#include "listener_vft.h"
+#include "../base/loop.h"
+#include "../io/base.h"
+
+listener_key_t listener_key_factory(address_t address, face_type_t type) {
+  listener_key_t key;
+  memset(&key, 0, sizeof(listener_key_t));
+
+  key.address = address;
+  key.type = type;
+  return key;
+}
+
+listener_t *listener_create(face_type_t type, const address_t *address,
+                            const char *interface_name, const char *name,
+                            forwarder_t *forwarder) {
+  listener_table_t *table = forwarder_get_listener_table(forwarder);
+
+  listener_key_t key = listener_key_factory(*address, type);
+
+  listener_t *listener = listener_table_allocate(table, &key, name);
+  unsigned listener_id = listener_table_get_listener_id(table, listener);
+
+  int ret = listener_initialize(listener, type, name, listener_id, address,
+                                interface_name, forwarder);
+  if (ret < 0) {
+    listener_table_remove_by_id(table, listener_id);
+    listener_finalize(listener);
+    return NULL;
+  }
+
+  WITH_INFO({
+    char addr_str[NI_MAXHOST];
+    int port;
+    address_to_string(address, addr_str, &port);
+    INFO("LISTENER CREATE (%s) %p created for address %s:%d",
+         face_type_str(listener->type), listener, addr_str, port);
+    listener_table_print_by_key(table);
+  })
+
+  return listener;
+}
+
+int listener_initialize(listener_t *listener, face_type_t type,
+                        const char *name, unsigned listener_id,
+                        const address_t *address, const char *interface_name,
+                        forwarder_t *forwarder) {
+  int rc;
+
+  assert(listener);
+  assert(forwarder);
+
+  *listener = (listener_t){
+      .id = listener_id,
+      .name = strdup(name),
+      .key = listener_key_factory(*address, type),
+      .interface_name = strdup(interface_name),
+      .family = address->as_ss.ss_family,
+      .fd = 0,
+      .forwarder = forwarder,
+  };
+
+  face_protocol_t face_protocol = get_protocol(listener->type);
+  if (face_protocol == FACE_PROTOCOL_UNKNOWN) goto ERR_VFT;
+
+  listener->data = malloc(listener_vft[face_protocol]->data_size);
+  if (!listener->data) goto ERR_DATA;
+
+  assert(listener_has_valid_type(listener));
+
+  rc = listener_vft[face_protocol]->initialize(listener);
+  if (rc < 0) goto ERR_VFT;
+
+  listener->fd = listener_vft[face_protocol]->get_socket(listener, address,
+                                                         NULL, interface_name);
+  if (listener->fd < 0) {
+    char addr_str[NI_MAXHOST];
+    int port;
+    address_to_string(address, addr_str, &port);
+    ERROR("Error creating listener %s fd: (%d) %s", addr_str, errno,
+          strerror(errno));
+    goto ERR_FD;
+  }
+  assert(listener->fd > 0);
+
+  // XXX data should be pre-allocated here
+
+  loop_fd_event_create(&listener->event_data, MAIN_LOOP, listener->fd, listener,
+                       (fd_callback_t)listener_read_callback, NULL);
+
+  if (!listener->event_data) {
+    goto ERR_REGISTER_FD;
+  }
+
+  if (loop_fd_event_register(listener->event_data) < 0) {
+    goto ERR_REGISTER_FD;
+  }
+
+  return 0;
+
+ERR_REGISTER_FD:
+#ifndef _WIN32
+  close(listener->fd);
+#else
+  closesocket(listener->fd);
+#endif
+ERR_FD:
+ERR_VFT:
+ERR_DATA:
+  return -1;
+}
+
+int listener_finalize(listener_t *listener) {
+  assert(listener);
+  assert(listener_has_valid_type(listener));
+
+  if (listener->event_data) {
+    loop_event_unregister(listener->event_data);
+    loop_event_free(listener->event_data);
+  }
+
+  if (listener->fd != -1) {
+#ifndef _WIN32
+    close(listener->fd);
+#else
+    closesocket(listener->fd);
+#endif
+  }
+
+  listener_vft[get_protocol(listener->type)]->finalize(listener);
+
+  if (listener->data) free(listener->data);
+  listener->data = NULL;
+  if (listener->interface_name) free(listener->interface_name);
+  listener->interface_name = NULL;
+  if (listener->name) free(listener->name);
+  listener->name = NULL;
+
+  return 0;
+}
+
+int listener_get_socket(const listener_t *listener, const address_t *local,
+                        const address_t *remote, const char *interface_name) {
+  assert(listener);
+  assert(listener_has_valid_type(listener));
+  assert(local);
+  // assert(remote); TODO: can it be null?
+
+  // DEBUG("[listener_get_socket]");
+
+  return listener_vft[get_protocol(listener->type)]->get_socket(
+      listener, local, remote, interface_name);
+}
+
+/*
+ * This is called from the forwarder to dynamially create new connections on the
+ * listener, in that case, name is NULL. It is also called from
+ * connection_create, which is itself called from the configuration part.
+ */
+unsigned listener_create_connection(listener_t *listener,
+                                    const char *connection_name,
+                                    const address_pair_t *pair) {
+  assert(listener);
+  assert(listener_has_valid_type(listener));
+  assert(pair);
+
+  connection_table_t *table =
+      forwarder_get_connection_table(listener->forwarder);
+  connection_t *connection =
+      connection_table_allocate(table, pair, connection_name);
+  unsigned connection_id =
+      connection_table_get_connection_id(table, connection);
+
+  /*
+   * We create a connected connection with its own fd, instead of returning
+   * the fd of the listener. This will allow to avoid specifying the
+   * destination address when sending packets, and will increase performance
+   * by avoiding a FIB lookup for each packet.
+   */
+#ifdef USE_CONNECTED_SOCKETS
+  int fd = listener_get_socket(listener, address_pair_get_local(pair),
+                               address_pair_get_remote(pair),
+                               listener->interface_name);
+#else
+  int fd = 0;  // means listener->fd;
+#endif
+  bool local = address_is_local(address_pair_get_local(pair));
+
+  face_type_t connection_type;
+  switch (listener->type) {
+    case FACE_TYPE_UDP_LISTENER:
+      connection_type = FACE_TYPE_UDP;
+      break;
+    case FACE_TYPE_TCP_LISTENER:
+      connection_type = FACE_TYPE_TCP;
+      break;
+    default:
+      connection_table_remove_by_id(table, connection_id);
+      return CONNECTION_ID_UNDEFINED;
+  }
+
+  int rc = connection_initialize(connection, connection_type, connection_name,
+                                 listener->interface_name, fd, pair, local,
+                                 connection_id, listener);
+  if (rc < 0) {
+    connection_table_remove_by_id(table, connection_id);
+    connection_finalize(connection);
+    return CONNECTION_ID_UNDEFINED;
+  }
+
+  WITH_INFO({
+    char local_addr_str[NI_MAXHOST];
+    char remote_addr_str[NI_MAXHOST];
+    int local_port;
+    int remote_port;
+    address_to_string(&(pair->local), local_addr_str, &local_port);
+    address_to_string(&(pair->remote), remote_addr_str, &remote_port);
+    INFO("%s connection %p created for address pair %s:%d (local=%s) - %s:%d",
+         face_type_str(connection->type), connection, local_addr_str,
+         local_port, connection_is_local(connection) ? "true" : "false",
+         remote_addr_str, remote_port);
+    connection_table_print_by_pair(table);
+  })
+
+#if 0
+  DEBUG("Notification for new connections");
+  // Generate notification message
+  flag_interface_type_t interface_type =
+      FLAG_INTERFACE_TYPE_WIRED | FLAG_INTERFACE_TYPE_CELLULAR;
+  struct {
+    cmd_header_t header;
+    hc_event_interface_update_t payload;
+  } msg = {.header =
+               {
+                   .message_type = NOTIFICATION_LIGHT,
+                   .command_id = EVENT_INTERFACE_UPDATE,
+                   .length = 0,
+                   .seq_num = 0,
+               },
+           .payload = {.interface_type = interface_type}};
+  size_t size = sizeof(msg);
+
+  // Retrieve subscribed connections
+  subscription_table_t *subscriptions =
+      forwarder_get_subscriptions(listener->forwarder);
+  unsigned *subscribed_conn_ids = subscription_table_get_connections_for_topic(
+      subscriptions, TOPIC_CONNECTION);
+
+  // Send notification to subscribed connections
+  for (int i = 0; i < vector_len(subscribed_conn_ids); i++) {
+    DEBUG("Sending notification to connection: %u", subscribed_conn_ids[i]);
+    const connection_t *conn =
+        connection_table_at(table, subscribed_conn_ids[i]);
+    connection_send_packet(conn, (uint8_t *)&msg, size);
+  }
+#endif
+
+  return connection_id;
+}
+
+int listener_punt(const listener_t *listener, const char *prefix_s) {
+  assert(listener);
+  assert(listener_get_type(listener) == FACE_TYPE_HICN);
+  assert(prefix_s);
+
+  return listener_vft[get_protocol(listener->type)]->punt(listener, prefix_s);
+}
+
+ssize_t listener_read_single(listener_t *listener, int fd) {
+  assert(listener);
+
+  msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(listener->forwarder);
+
+  // Preapare the msgbuf
+  msgbuf_t *msgbuf = NULL;
+  off_t msgbuf_id = msgbuf_pool_get(msgbuf_pool, &msgbuf);
+  if (!msgbuf_id_is_valid(msgbuf_id)) return -1;
+
+  // Prepare the address pair
+  address_pair_t pair;
+  memset(&pair, 0, sizeof(address_pair_t));
+  pair.local = listener->address;
+
+  // Read message and populate the remote address
+  ssize_t n = listener_vft[get_protocol(listener->type)]->read_single(
+      fd, msgbuf, address_pair_get_remote(&pair));
+  if (n <= 0) {
+    msgbuf_pool_put(msgbuf_pool, msgbuf);
+    return -1;
+  }
+
+  msgbuf_pool_acquire(msgbuf);
+
+  // Process received packet
+  size_t processed_bytes = forwarder_receive(listener->forwarder, listener,
+                                             msgbuf_id, &pair, ticks_now());
+  forwarder_log(listener->forwarder);
+  if (processed_bytes <= 0) ERROR("Unable to handle message");
+
+  /*
+   * The connection on which we went packets might do batching (even without
+   * sendmmsg), and we need to inform the system that we want to proceed to
+   * sending packets.
+   */
+  forwarder_flush_connections(listener->forwarder);
+  msgbuf_pool_release(msgbuf_pool, &msgbuf);
+  return processed_bytes;
+}
+
+ssize_t listener_read_batch(listener_t *listener, int fd) {
+  assert(listener);
+
+  size_t total_processed_bytes = 0;
+  ssize_t num_msg_received = 0;
+  off_t *acquired_msgbuf_ids;
+  vector_init(acquired_msgbuf_ids, MAX_MSG, 0);
+
+  forwarder_t *forwarder = listener->forwarder;
+  msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(forwarder);
+
+  /* Receive messages in the loop as long as we manage to fill the buffers */
+  do {
+    /* Prepare the msgbuf and address pair arrays */
+    msgbuf_t *msgbufs[MAX_MSG];
+    if (msgbuf_pool_getn(msgbuf_pool, msgbufs, MAX_MSG) < 0) {
+      ERROR("Unable to get message buffers");
+      break;
+    }
+
+    address_pair_t pair[MAX_MSG];
+    address_t *address_remote[MAX_MSG];
+    memset(&pair, 0, MAX_MSG * sizeof(address_pair_t));
+
+    off_t msgbuf_ids[MAX_MSG];
+    for (unsigned i = 0; i < MAX_MSG; i++) {
+      // Copy the pointers to the remote addresses
+      address_remote[i] = address_pair_get_remote(&pair[i]);
+
+      // Populate local addresses
+      pair[i].local = listener->address;
+
+      // Do NOT rely on msgbuf pointers since a msgbuf pool rezise event may
+      // make them invalid, use msgbuf ids instead
+      msgbuf_ids[i] = msgbuf_pool_get_id(msgbuf_pool, msgbufs[i]);
+    }
+
+    // Read batch and populate remote addresses
+    num_msg_received = listener_vft[get_protocol(listener->type)]->read_batch(
+        fd, msgbufs, address_remote, MAX_MSG);
+
+    for (int i = 0; i < MAX_MSG; i++) {
+      // Release unused msg buffers
+      if (i >= num_msg_received) {
+        msgbuf_pool_put(msgbuf_pool, msgbufs[i]);
+        continue;
+      }
+
+      msgbuf_pool_acquire(msgbufs[i]);
+      vector_push(acquired_msgbuf_ids, msgbuf_ids[i]);
+    }
+
+    if (num_msg_received < 0) break;
+    TRACE("[listener_read_batch] batch size = %d", num_msg_received);
+
+    for (unsigned i = 0; i < num_msg_received; i++) {
+      size_t processed_bytes = forwarder_receive(
+          forwarder, listener, msgbuf_ids[i], &pair[i], ticks_now());
+      forwarder_log(listener->forwarder);
+
+      total_processed_bytes += processed_bytes;
+    }
+  } while (num_msg_received ==
+           MAX_MSG); /* backpressure based on queue size ? */
+
+  /*
+   * Signal to the forwarder that we reached the end of a batch and we need to
+   * flush connections out
+   */
+  forwarder_flush_connections(forwarder);
+
+  for (int i = 0; i < vector_len(acquired_msgbuf_ids); i++) {
+    msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, acquired_msgbuf_ids[i]);
+    msgbuf_pool_release(msgbuf_pool, &msgbuf);
+  }
+  vector_free(acquired_msgbuf_ids);
+
+  return total_processed_bytes;
+}
+
+/*
+ * This might be called for a connection on the listener too. The listener is
+ * the entity that owns the buffers used for reading.
+ */
+ssize_t listener_read_callback(listener_t *listener, int fd, void *user_data) {
+  // DEBUG("[listener_read_callback]");
+  // XXX make a single callback and arbitrate between read and readbatch
+  assert(listener);
+
+  /*
+   * As the listener callback is shared between the listener and the different
+   * connections created on top of it, the fd might be either of them.
+   */
+  // assert(fd == listener->fd);
+
+  if (listener_vft[get_protocol(listener->type)]->read_batch)
+    return listener_read_batch(listener, fd);
+
+  return listener_read_single(listener, fd);
+}
+
+void listener_setup_local(forwarder_t *forwarder, uint16_t port) {
+  address_t localhost_ipv4_addr = ADDRESS4_LOCALHOST(port);
+  listener_create(FACE_TYPE_UDP_LISTENER, &localhost_ipv4_addr, "lo", "lo_udp4",
+                  forwarder);
+
+  address_t localhost_ipv6_addr = ADDRESS6_LOCALHOST(port);
+  listener_create(FACE_TYPE_UDP_LISTENER, &localhost_ipv6_addr, "lo", "lo_udp6",
+                  forwarder);
+}
\ No newline at end of file
diff --git a/hicn-light/src/hicn/core/listener.h b/hicn-light/src/hicn/core/listener.h
new file mode 100644
index 000000000..346c874c0
--- /dev/null
+++ b/hicn-light/src/hicn/core/listener.h
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file listener.h
+ * @brief hICN listeners
+ */
+
+#ifndef HICNLIGHT_LISTENER_H
+#define HICNLIGHT_LISTENER_H
+
+#include <hicn/face.h>
+
+#include "address_pair.h"
+#include "msgbuf.h"
+#include "../base/loop.h"
+
+#define LISTENER_ID_UNDEFINED ~0
+
+struct forwarder_s;
+
+typedef struct {
+  address_t address;
+  face_type_t type;
+} listener_key_t;
+
+/**
+ * @brief Create a listener key starting from an address and a face type.
+ *
+ * @param address
+ * @param type
+ * @return listener_key_t The listener key created.
+ *
+ * @note The listener key returned is resetted before intializing
+ * the internal fields, to allow a reliable hash generation.
+ */
+listener_key_t listener_key_factory(address_t address, face_type_t type);
+
+/* This structure holds what is in common to all listeners */
+typedef struct {
+  int id;
+  char *name;
+  union {
+    listener_key_t key;
+    struct {
+      address_t address;
+      face_type_t type;
+    };
+  };
+
+  char *interface_name;
+  unsigned family;
+
+  int fd;
+  event_t *event_data;
+
+  void *data; /* Listener specific data */
+  struct forwarder_s *forwarder;
+} listener_t;
+
+#define listener_get_id(L) ((L)->id)
+#define listener_get_name(L) ((L)->name)
+#define listener_get_key(L) (&(L)->key)
+#define listener_get_type(L) ((L)->type)
+#define listener_get_interface_name(L) ((L)->interface_name)
+#define listener_get_address(L) (&(L)->address)
+#define listener_has_valid_type(L) (face_type_is_valid((L)->type))
+#define listener_id_is_valid(ID) (ID != LISTENER_ID_UNDEFINED)
+
+listener_t *listener_create(face_type_t type, const address_t *address,
+                            const char *interface_name, const char *symbolic,
+                            struct forwarder_s *forwarder);
+
+/**
+ * @brief Helper function used inside 'listener_create' to
+ * setup variables in listener struct.
+ *
+ * @see listener_create
+ */
+int listener_initialize(listener_t *listener, face_type_t type,
+                        const char *name, unsigned listener_id,
+                        const address_t *address, const char *interface_name,
+                        struct forwarder_s *forwarder);
+
+int listener_finalize(listener_t *listener);
+
+int listener_punt(const listener_t *listener, const char *prefix_s);
+
+int listener_get_socket(const listener_t *listener, const address_t *local,
+                        const address_t *remote, const char *interface_name);
+
+unsigned listener_create_connection(listener_t *listener, const char *name,
+                                    const address_pair_t *pair);
+
+void listener_setup_local(struct forwarder_s *forwarder, uint16_t port);
+
+void listener_process_packet(const listener_t *listener, const uint8_t *packet,
+                             size_t size);
+
+ssize_t listener_read_single(listener_t *listener, int fd);
+ssize_t listener_read_batch(listener_t *listener, int fd);
+
+/**
+ * @brief Callback helper function for batch reading data from listener fd.
+ *
+ * This function is usually called from the listener read callback to proceed to
+ * actual reading of data from the fd.
+ *
+ * @see listener_read_callback
+ *
+ * NOTE: the function returns size_t as for TCP we might need to know how much
+ * data we can consume from the socket.
+ */
+ssize_t listener_read_callback(listener_t *listener, int fd, void *user_data);
+
+#define listener_get_forwarder(listener) (listener->forwarder)
+#define listener_get_fd(listener) (listener->fd)
+
+#endif /* HICNLIGHT_LISTENER_H */
diff --git a/hicn-light/src/hicn/core/listener_table.c b/hicn-light/src/hicn/core/listener_table.c
new file mode 100644
index 000000000..32b8e9d45
--- /dev/null
+++ b/hicn-light/src/hicn/core/listener_table.c
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file listener_table.c
+ * \brief Implementation of hICN listener table
+ */
+
+#include <hicn/util/log.h>
+
+#include "listener_table.h"
+#include "listener.h"
+
+/* This is only used as a hint for first allocation, as the table is resizeable
+ */
+#define DEFAULT_LISTENER_TABLE_SIZE 64
+
+listener_table_t *_listener_table_create(size_t init_size, size_t max_size) {
+  if (init_size == 0) init_size = DEFAULT_LISTENER_TABLE_SIZE;
+
+  listener_table_t *table = malloc(sizeof(listener_table_t));
+  if (!table) return NULL;
+
+  table->max_size = max_size;
+
+  /* Initialize indices */
+  table->id_by_name = kh_init_lt_name();
+  table->id_by_key = kh_init_lt_key();
+
+  /*
+   * We start by allocating a reasonably-sized pool, as this will eventually
+   * be resized if needed.
+   */
+  pool_init(table->listeners, init_size, 0);
+
+  return table;
+}
+
+void listener_table_free(listener_table_t *table) {
+  const char *k_name;
+  const listener_key_t *k_key;
+  unsigned v;
+
+  listener_t *listener;
+  const char *name;
+  kh_foreach(table->id_by_key, k_key, v, {
+    listener = listener_table_get_by_id(table, v);
+    name = listener_get_name(listener);
+    INFO("Removing listner %s [%d]", name, listener->fd);
+    listener_finalize(listener);
+  });
+
+  (void)v;
+  kh_foreach(table->id_by_name, k_name, v, { free((char *)k_name); });
+  kh_foreach(table->id_by_key, k_key, v, { free((listener_key_t *)k_key); });
+
+  kh_destroy_lt_name(table->id_by_name);
+  kh_destroy_lt_key(table->id_by_key);
+  pool_free(table->listeners);
+  free(table);
+}
+
+listener_t *listener_table_get_by_address(listener_table_t *table,
+                                          face_type_t type,
+                                          const address_t *address) {
+  listener_key_t key = listener_key_factory(*address, type);
+  khiter_t k = kh_get_lt_key(table->id_by_key, &key);
+  if (k == kh_end(table->id_by_key)) return NULL;
+  return listener_table_at(table, kh_val(table->id_by_key, k));
+}
+
+listener_t *listener_table_get_by_key(listener_table_t *table,
+                                      const listener_key_t *key) {
+  khiter_t k = kh_get_lt_key(table->id_by_key, key);
+  if (k == kh_end(table->id_by_key)) return NULL;
+  return listener_table_at(table, kh_val(table->id_by_key, k));
+}
+
+void listener_table_remove_by_id(listener_table_t *table, off_t id) {
+  listener_t *listener = listener_table_at(table, id);
+  INFO("Removing listener %d (%s)", id, listener_get_name(listener));
+
+  listener_table_deallocate(table, listener);
+}
+
+off_t listener_table_get_id_by_name(const listener_table_t *table,
+                                    const char *name) {
+  khiter_t k = kh_get_lt_name(table->id_by_name, name);
+  if (k == kh_end(table->id_by_name)) return LISTENER_ID_UNDEFINED;
+  return kh_val(table->id_by_name, k);
+}
+
+listener_t *listener_table_get_by_name(listener_table_t *table,
+                                       const char *name) {
+  unsigned listener_id = listener_table_get_id_by_name(table, name);
+  if (!listener_id_is_valid(listener_id)) return NULL;
+  return listener_table_at(table, listener_id);
+}
+
+listener_t *_listener_table_get_by_id(listener_table_t *table, off_t id) {
+  return listener_table_get_by_id(table, id);
+}
+
+void listener_table_print_by_key(const listener_table_t *table) {
+  const listener_key_t *k;
+  unsigned v;
+
+  char addr_str[NI_MAXHOST];
+  int port;
+  listener_t *listener;
+  const char *name;
+
+  INFO("*** Listener table ***");
+  kh_foreach(table->id_by_key, k, v, {
+    address_to_string(&k->address, addr_str, &port);
+    listener = listener_table_get_by_id(table, v);
+    name = listener_get_name(listener);
+    INFO("%s:%d - %s\t\t\t\t(%u, %s)", addr_str, port, face_type_str(k->type),
+         v, name);
+  })
+}
+
+void listener_table_print_by_name(const listener_table_t *table) {
+  const char *k;
+  unsigned v;
+
+  char addr_str[NI_MAXHOST];
+  int port;
+  listener_t *listener;
+  const listener_key_t *key;
+
+  INFO("*** Listener table ***");
+  kh_foreach(table->id_by_name, k, v, {
+    listener = listener_table_get_by_id(table, v);
+    key = listener_get_key(listener);
+    address_to_string(&key->address, addr_str, &port);
+
+    INFO("%s:%d - %s\t\t\t\t(%u, %s)", addr_str, port, face_type_str(key->type),
+         v, k);
+  })
+}
\ No newline at end of file
diff --git a/hicn-light/src/hicn/core/listener_table.h b/hicn-light/src/hicn/core/listener_table.h
new file mode 100644
index 000000000..5fed638e8
--- /dev/null
+++ b/hicn-light/src/hicn/core/listener_table.h
@@ -0,0 +1,310 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file listener_table.h
+ * \brief hICN listener table
+ *
+ * The listener table is composed of:
+ *  - a pool of listeners allowing access through their index in constant time;
+ *  - a set of indices in the form of hash table for efficient index lookups:
+ *     . by name
+ *     . by key (listener_type, address)
+ *
+ * For efficient index retrieval, the header will be prepended and the
+ * resulting pointer will directly point to the listener pool.
+ */
+
+#ifndef HICNLIGHT_LISTENER_TABLE_H
+#define HICNLIGHT_LISTENER_TABLE_H
+
+#include "address.h"
+#include "listener.h"
+#include "../base/common.h"
+#include "../base/hash.h"
+#include "../base/khash.h"
+#include "../base/pool.h"
+
+#define _lt_var(x) _lt_var_##x
+
+/* Hash functions for indices */
+#define key_hash(key) (hash_struct(key))
+#define key_hash_eq(a, b) (key_hash(b) == key_hash(a))
+
+/* Hash table types for indices */
+KHASH_MAP_INIT_STR(lt_name, unsigned);
+KHASH_INIT(lt_key, const listener_key_t *, unsigned, 1, key_hash, key_hash_eq);
+
+typedef struct {
+  size_t max_size;
+
+  kh_lt_key_t *id_by_key;
+  kh_lt_name_t *id_by_name;
+
+  listener_t *listeners;  // pool
+} listener_table_t;
+
+/**
+ * @brief Allocate a listener from the listener table.
+ *
+ * @param[in] table The listener table from which to allocate a listener.
+ * @param[out] listener The pointer that will hold the allocated listener.
+ * @param[in] pair The address pair associated to the listener (to update index)
+ * @param[in] name The name associated to the listener (to update index)
+ *
+ * NOTE:
+ *  - This function updates all indices from the listener table if the
+ *  allocation is successful.
+ *  - You should always check that the returned listener is not NULL, which
+ *  would signal that the pool is exhausted and could not be extended.
+ */
+
+static inline listener_t *listener_table_allocate(const listener_table_t *table,
+                                                  const listener_key_t *key,
+                                                  const char *name) {
+  listener_t *listener;
+  pool_get(table->listeners, listener);
+
+  if (listener) {
+    off_t id = listener - table->listeners;
+    int res;
+    khiter_t k;
+
+    // Add in name hash table
+    k = kh_put_lt_name(table->id_by_name, strdup(name), &res);
+    assert(res > 0);
+    kh_value(table->id_by_name, k) = id;
+
+    // Add in key hash table
+    listener_key_t *key_copy = (listener_key_t *)malloc(sizeof(listener_key_t));
+    memcpy(key_copy, key, sizeof(listener_key_t));
+
+    k = kh_put_lt_key(table->id_by_key, key_copy, &res);
+    assert(res > 0);
+    kh_value(table->id_by_key, k) = id;
+  }
+
+  return listener;
+}
+
+/**
+ * @brief Deallocate a listener and return it to the listener table pool.
+ *
+ * @param[in] table The listener table to which the listener is returned.
+ * @param[in] conn The listener that is returned to the pool.
+ *
+ * NOTE:
+ *  - Upon returning a listener to the pool, all indices pointing to that
+ *  listener are also cleared.
+ */
+
+static inline void listener_table_deallocate(const listener_table_t *table,
+                                             listener_t *listener) {
+  const char *name = listener_get_name(listener);
+  listener_key_t *key = listener_get_key(listener);
+  khiter_t k;
+
+  // Remove from name hash table
+  k = kh_get_lt_name(table->id_by_name, name);
+  assert(k != kh_end(table->id_by_name));
+  free((char *)kh_key(table->id_by_name, k));
+  kh_del_lt_name(table->id_by_name, k);
+
+  // Remove from key hash table
+  k = kh_get_lt_key(table->id_by_key, key);
+  assert(k != kh_end(table->id_by_key));
+  free((listener_key_t *)kh_key(table->id_by_key, k));
+  kh_del_lt_key(table->id_by_key, k);
+
+  pool_put(table->listeners, listener);
+}
+
+/**
+ * @brief Returns the length of the listener table, the number of active
+ * listeners.
+ *
+ * @param[in] table The listener table for which we retrieve the length.
+ *
+ * @return size_t The length of the listener table.
+ *
+ * NOTE:
+ *  - The length of the listener table, that is the number of currently active
+ *  listeners.
+ */
+#define listener_table_len(table) (pool_len(table->listeners))
+
+/**
+ * @brief Validate an index in the listener table.
+ *
+ * @param[in] table The listener table in which to validate an index.
+ * @param[in] id The index of the listener to validate.
+ *
+ * @return bool A flag indicating whether the listener index is valid or not.
+ */
+#define listener_table_validate_id(table, id) \
+  pool_validate_id(table->listeners, id)
+
+/**
+ * @brief Return the listener corresponding to the specified index in the
+ * listener table.
+ *
+ * @param[in] table The listener table for which to retrieve the listener.
+ * @param[in] id The index for which to retrieve the listener.
+ *
+ * @return listener_t * The listener correponding to the specified index in
+ * the listener table.
+ *
+ * @see listener_table_get_by_id
+ *
+ * NOTE:
+ *  - In this function, the index is not validated.
+ */
+#define listener_table_at(table, id) ((table)->listeners + id)
+
+/**
+ * @brief Return the listener corresponding to the specified and validated
+ * index in the listener table.
+ *
+ * @param[in] table The listener table for which to retrieve the listener.
+ * @param[in] id The index for which to retrieve the listener.
+ *
+ * @return listener_t * The listener correponding to the specified index in
+ * the listener table.
+ *
+ * @see listener_table_get_by_id
+ *
+ * NOTE:
+ *  - In this function, the index is validated.
+ */
+#define listener_table_get_by_id(table, id) \
+  listener_table_validate_id(table, id) ? listener_table_at(table, id) : NULL
+
+/**
+ * @brief Helper function to avoid macro expansion in c++ tests. Wrapper around
+ * 'listener_table_get_by_id'.
+ */
+listener_t *_listener_table_get_by_id(listener_table_t *table, off_t id);
+
+/**
+ * @brief Returns the index of a given listener in the listener table.
+ *
+ * @param[in] table The listener table from which to retrieve the index.
+ * @param[in] conn The listener for which to retrieve the index.
+ *
+ * @return off_t The index of the specified listener in the listener table.
+ */
+#define listener_table_get_listener_id(table, listener) \
+  (listener - table->listeners)
+
+#define listener_table_foreach(table, listener, BODY) \
+  pool_foreach(                                       \
+      table->listeners, listener, do { BODY } while (0))
+
+#define listener_table_enumerate(table, i, conn, BODY) \
+  pool_enumerate(table->listeners, (i), (conn), BODY)
+
+/**
+ * @brief Create a new listener table (extended parameters)
+ *
+ * @param[in] init_size Initially allocated size (hint, 0 = use default value)
+ * @param[in] max_size Maximum size (0 = unlimited)
+ *
+ * @return listener_table_t* - The newly created listener table
+ */
+listener_table_t *_listener_table_create(size_t init_size, size_t max_size);
+
+/**
+ * @brief Create a new listener table (minimal parameters)
+ *
+ * @return listener_table_t* - The newly created listener table
+ */
+#define listener_table_create() _listener_table_create(0, 0)
+
+/**
+ * @brief Free a listener table
+ *
+ * @param[in] table Listener table to free
+ */
+void listener_table_free(listener_table_t *table);
+
+/**
+ * @brief Retrieve a listener from the listener table by address.
+ *
+ * @param[in] table The listener table in which to search.
+ * @param[in] type The face type characterizing the listener to search for.
+ * @param[in] address The address to search for.
+ *
+ * @return listener_t * The listener matching the specified address, or
+ * NULL if not found.
+ */
+listener_t *listener_table_get_by_address(listener_table_t *table,
+                                          face_type_t type,
+                                          const address_t *address);
+
+/**
+ * @brief Retrieve a listener from the listener table by listener key (i.e.
+ * address + face type).
+ *
+ * @param[in] table The listener table in which to search.
+ * @param[in] key The listener key characterizing the listener to search for.
+ *
+ * @return listener_t * The listener matching the specified address, or
+ * NULL if not found.
+ */
+listener_t *listener_table_get_by_key(listener_table_t *table,
+                                      const listener_key_t *key);
+
+/**
+ * @brief Return a listener index from the listener table by name.
+ *
+ * @param[in] table The listener table in which to search.
+ * @param[in] name The name to search for.
+ *
+ * @return off_t The index of the listener matching the name, or
+ * LISTENER_ID_UNDEFINED if not found.
+ */
+off_t listener_table_get_id_by_name(const listener_table_t *table,
+                                    const char *name);
+
+/**
+ * @brief Return a listener from the listener table by name.
+ *
+ * @param[in] table The listener table in which to search.
+ * @param[in] name The name to search for.
+ *
+ * @return listener_t * The listener matching the name, or NULL if not
+ * found.
+ */
+listener_t *listener_table_get_by_name(listener_table_t *table,
+                                       const char *name);
+
+/**
+ * @brief Remove a listener from the listener table by its index.
+ *
+ * @param[in] table The listener table from which to delete the listener.
+ * @param[in] id The index of the listener to remove.
+ */
+void listener_table_remove_by_id(listener_table_t *table, off_t id);
+
+/**
+ * @brief Print the listener table content.
+ *
+ * @param[in] table The listener table to print.
+ */
+void listener_table_print_by_key(const listener_table_t *table);
+
+void listener_table_print_by_name(const listener_table_t *table);
+
+#endif /* HICNLIGHT_LISTENER_TABLE_H */
diff --git a/hicn-light/src/hicn/core/listener_vft.c b/hicn-light/src/hicn/core/listener_vft.c
new file mode 100644
index 000000000..600c9482f
--- /dev/null
+++ b/hicn-light/src/hicn/core/listener_vft.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file listener_vft.c
+ * @brief Implementation of listener VFT
+ */
+
+#include "listener_vft.h"
+
+#ifdef __linux__
+extern listener_ops_t listener_hicn;
+#endif
+extern listener_ops_t listener_tcp;
+extern listener_ops_t listener_udp;
+
+const listener_ops_t* listener_vft[] = {
+#ifdef __linux__
+    [FACE_PROTOCOL_HICN] = &listener_hicn,
+#endif
+
+    [FACE_PROTOCOL_TCP] = &listener_tcp,
+    [FACE_PROTOCOL_UDP] = &listener_udp,
+};
diff --git a/hicn-light/src/hicn/core/listener_vft.h b/hicn-light/src/hicn/core/listener_vft.h
new file mode 100644
index 000000000..97f08778c
--- /dev/null
+++ b/hicn-light/src/hicn/core/listener_vft.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file listener_vft.h
+ * @brief Listener VFT
+ */
+
+#ifndef HICNLIGHT_LISTENER_VFT_H
+#define HICNLIGHT_LISTENER_VFT_H
+
+#include <hicn/core/address_pair.h>
+#include <hicn/core/connection.h>
+#include <hicn/core/listener.h>
+#include <hicn/face.h>
+
+typedef struct {
+  int (*initialize)(listener_t* listener);
+  void (*finalize)(listener_t* listener);
+  int (*punt)(const listener_t* listener, const char* prefix_s);
+  int (*get_socket)(const listener_t* listener, const address_t* local,
+                    const address_t* remote, const char* interface_name);
+  int (*send)(const connection_t* connection, const address_t* dummy,
+              msgbuf_t* msgbuf, bool queue);
+  int (*send_packet)(const connection_t* connection, const uint8_t* packet,
+                     size_t size);
+  ssize_t (*read_single)(int fd, msgbuf_t* msgbuf, address_t* address);
+  ssize_t (*read_batch)(int fd, msgbuf_t** msgbuf, address_t** address,
+                        size_t len);
+  size_t data_size;
+} listener_ops_t;
+
+#define DECLARE_LISTENER(NAME)                       \
+  const listener_ops_t listener_##NAME = {           \
+      .initialize = listener_##NAME##_initialize,    \
+      .finalize = listener_##NAME##_finalize,        \
+      .punt = listener_##NAME##_punt,                \
+      .get_socket = listener_##NAME##_get_socket,    \
+      .read_single = listener_##NAME##_read_single,  \
+      .read_batch = listener_##NAME##_read_batch,    \
+      .data_size = sizeof(listener_##NAME##_data_t), \
+  }
+
+extern const listener_ops_t* listener_vft[];
+
+#endif /* HICNLIGHT_LISTENER_VFT_H */
diff --git a/hicn-light/src/hicn/core/logger.c b/hicn-light/src/hicn/core/logger.c
deleted file mode 100644
index 0b9bb264c..000000000
--- a/hicn-light/src/hicn/core/logger.c
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * 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 _WIN32
-#include <unistd.h>
-#endif
-
-#include <errno.h>
-#include <hicn/hicn-light/config.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Object.h>
-
-#include <parc/logging/parc_Log.h>
-
-#include <hicn/core/forwarder.h>
-#include <hicn/core/logger.h>
-
-struct logger {
-  PARCClock *clock;
-
-  PARCLogReporter *reporter;
-  PARCLog *loggerArray[LoggerFacility_END];
-};
-
-static const struct facility_to_string {
-  LoggerFacility facility;
-  const char *string;
-} _facilityToString[] = {
-    {.facility = LoggerFacility_Config, .string = "Config"},
-    {.facility = LoggerFacility_Core, .string = "Core"},
-    {.facility = LoggerFacility_IO, .string = "IO"},
-    {.facility = LoggerFacility_Message, .string = "Message"},
-    {.facility = LoggerFacility_Processor, .string = "Processor"},
-    {.facility = LoggerFacility_Strategy, .string = "Strategy"},
-    {.facility = 0, .string = NULL}};
-
-const char *logger_FacilityString(LoggerFacility facility) {
-  for (int i = 0; _facilityToString[i].string != NULL; i++) {
-    if (_facilityToString[i].facility == facility) {
-      return _facilityToString[i].string;
-    }
-  }
-  return "Unknown";
-}
-
-static void _allocateLoggers(Logger *logger, PARCLogReporter *reporter) {
-  parcTrapUnexpectedStateIf(
-      logger->reporter != NULL,
-      "Trying to allocate a reporter when the previous one is not null");
-  logger->reporter = parcLogReporter_Acquire(reporter);
-
-  char hostname[255];
-  int gotHostName = gethostname(hostname, 255);
-  if (gotHostName < 0) {
-    snprintf(hostname, 255, "unknown");
-  }
-
-  for (int i = 0; i < LoggerFacility_END; i++) {
-    logger->loggerArray[i] = parcLog_Create(hostname, logger_FacilityString(i),
-                                            "forwarder", logger->reporter);
-    parcLog_SetLevel(logger->loggerArray[i], PARCLogLevel_Error);
-  }
-}
-
-static void _releaseLoggers(Logger *logger) {
-  for (int i = 0; i < LoggerFacility_END; i++) {
-    parcLog_Release(&logger->loggerArray[i]);
-  }
-  parcLogReporter_Release(&logger->reporter);
-}
-
-static void _destroyer(Logger **loggerPtr) {
-  Logger *logger = *loggerPtr;
-  _releaseLoggers(logger);
-  parcClock_Release(&(*loggerPtr)->clock);
-}
-
-parcObject_ExtendPARCObject(Logger, _destroyer, NULL, NULL, NULL, NULL, NULL,
-                            NULL);
-
-parcObject_ImplementAcquire(logger, Logger);
-
-parcObject_ImplementRelease(logger, Logger);
-
-Logger *logger_Create(PARCLogReporter *reporter, const PARCClock *clock) {
-  parcAssertNotNull(reporter, "Parameter reporter must be non-null");
-  parcAssertNotNull(clock, "Parameter clock must be non-null");
-
-  Logger *logger = parcObject_CreateAndClearInstance(Logger);
-  if (logger) {
-    logger->clock = parcClock_Acquire(clock);
-    _allocateLoggers(logger, reporter);
-  }
-
-  return logger;
-}
-
-void logger_SetReporter(Logger *logger, PARCLogReporter *reporter) {
-  parcAssertNotNull(logger, "Parameter logger must be non-null");
-
-  // save the log level state
-  PARCLogLevel savedLevels[LoggerFacility_END];
-  for (int i = 0; i < LoggerFacility_END; i++) {
-    savedLevels[i] = parcLog_GetLevel(logger->loggerArray[i]);
-  }
-
-  _releaseLoggers(logger);
-
-  _allocateLoggers(logger, reporter);
-
-  // restore log level state
-  for (int i = 0; i < LoggerFacility_END; i++) {
-    parcLog_SetLevel(logger->loggerArray[i], savedLevels[i]);
-  }
-}
-
-void logger_SetClock(Logger *logger, PARCClock *clock) {
-  parcAssertNotNull(logger, "Parameter logger must be non-null");
-  parcClock_Release(&logger->clock);
-  logger->clock = parcClock_Acquire(clock);
-}
-
-static void _assertInvariants(const Logger *logger, LoggerFacility facility) {
-  parcAssertNotNull(logger, "Parameter logger must be non-null");
-  parcTrapOutOfBoundsIf(facility >= LoggerFacility_END, "Invalid facility %d",
-                        facility);
-}
-
-void logger_SetLogLevel(Logger *logger, LoggerFacility facility,
-                        PARCLogLevel minimumLevel) {
-  _assertInvariants(logger, facility);
-  PARCLog *log = logger->loggerArray[facility];
-  parcLog_SetLevel(log, minimumLevel);
-}
-
-bool logger_IsLoggable(const Logger *logger, LoggerFacility facility,
-                       PARCLogLevel level) {
-  _assertInvariants(logger, facility);
-  PARCLog *log = logger->loggerArray[facility];
-  return parcLog_IsLoggable(log, level);
-}
-
-void logger_Log(Logger *logger, LoggerFacility facility, PARCLogLevel level,
-                const char *module, const char *format, ...) {
-  if (logger_IsLoggable(logger, facility, level)) {
-    // this is logged as the messageid
-    uint64_t logtime = parcClock_GetTime(logger->clock);
-
-    // logger_IsLoggable asserted invariants so we know facility is in bounds
-    PARCLog *log = logger->loggerArray[facility];
-
-    va_list va;
-    va_start(va, format);
-
-    parcLog_MessageVaList(log, level, logtime, format, va);
-
-    va_end(va);
-  }
-}
diff --git a/hicn-light/src/hicn/core/logger.h b/hicn-light/src/hicn/core/logger.h
deleted file mode 100644
index 8ab741f40..000000000
--- a/hicn-light/src/hicn/core/logger.h
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * 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 logger.h
- * @brief Logger for the hicn-light forwarder
- *
- * A facility based logger to allow selective logging from different parts of
- * hicn-light
- *
- */
-
-#ifndef logger_h
-#define logger_h
-
-#ifndef _WIN32
-#include <sys/time.h>
-#endif
-#include <parc/algol/parc_Buffer.h>
-#include <parc/algol/parc_Clock.h>
-#include <parc/logging/parc_LogLevel.h>
-#include <parc/logging/parc_LogReporter.h>
-#include <stdarg.h>
-
-struct logger;
-typedef struct logger Logger;
-
-/**
- * CONFIG faciilty concerns anything in the /config directory
- * CORE concerns anything in the /core directory
- * IO concerns anything in the /io directory (listeners, connectors, tcp,
- * ethernet, etc.) PROCESSOR concerns FIB, PIT, CS MESSAGE concerns message
- * events, like parsing
- */
-typedef enum {
-  LoggerFacility_Config,
-  LoggerFacility_Core,
-  LoggerFacility_IO,
-  LoggerFacility_Processor,
-  LoggerFacility_Message,
-  LoggerFacility_Strategy,
-  LoggerFacility_END  // sentinel value
-} LoggerFacility;
-
-/**
- * Returns a string representation of a facility
- *
- * Do not free the returned value.
- *
- * @param [in] facility The facility to change to a string
- *
- * @retval string A string representation of the facility
- */
-const char *logger_FacilityString(LoggerFacility facility);
-
-/**
- * Returns a string representation of a log level
- *
- * Do not free the returned value.
- *
- * @param [in] level The level to change to a string
- *
- * @retval string A string representation of the level
- */
-const char *logger_LevelString(PARCLogLevel level);
-
-/**
- * Create a logger that uses a given writer and clock
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [in] writer The output writer
- * @param [in] clock The clock to use for log messages
- *
- * @retval non-null An allocated logger
- * @retval null An error
- */
-Logger *logger_Create(PARCLogReporter *reporter, const PARCClock *clock);
-
-/**
- * Release logger
- */
-void logger_Release(Logger **loggerPtr);
-
-/**
- * Acquire logger
- */
-Logger *logger_Acquire(const Logger *logger);
-
-/**
- * Sets the minimum log level for a facility
- *
- * The default log level is ERROR.  For a message to be logged, it must be of
- * equal or higher log level.
- *
- * @param [in] logger An allocated logger
- * @param [in] facility The facility to set the log level for
- * @param [in] The minimum level to log
- *
- */
-void logger_SetLogLevel(Logger *logger, LoggerFacility facility,
-                        PARCLogLevel minimumLevel);
-
-/**
- * Tests if the log level would be logged
- *
- * If the facility would log the given level, returns true.  May be used as a
- * guard around expensive logging functions.
- *
- * @param [in] logger An allocated logger
- * @param [in] facility The facility to test
- * @param [in] The level to test
- *
- * @retval true The given facility would log the given level
- * @retval false A message of the given level would not be logged
- *
- */
-bool logger_IsLoggable(const Logger *logger, LoggerFacility facility,
-                       PARCLogLevel level);
-
-/**
- * Log a message
- *
- * The message will only be logged if it is loggable (logger_IsLoggable returns
- * true).
- *
- * @param [in] logger An allocated Logger
- * @param [in] facility The facility to log under
- * @param [in] level The log level of the message
- * @param [in] module The specific module logging the message
- * @param [in] format The message with varargs
- *
- */
-void logger_Log(Logger *logger, LoggerFacility facility, PARCLogLevel level,
-                const char *module, const char *format, ...);
-
-/**
- * Switch the logger to a new reporter
- *
- * Will close the old reporter and re-setup the internal loggers to use the new
- * reporter. All current log level settings are preserved.
- *
- * @param [in] logger An allocated Logger
- * @param [in] reporter An allocated PARCLogReporter
- */
-void logger_SetReporter(Logger *logger, PARCLogReporter *reporter);
-
-/**
- * Set a new clock to use with the logger
- *
- * The logger will start getting the time (logged as the messageid) from the
- * specified clock
- *
- * @param [in] logger An allocated Logger
- * @param [in] clock An allocated PARCClock
- */
-void logger_SetClock(Logger *logger, PARCClock *clock);
-#endif  // logger_h
diff --git a/hicn-light/src/hicn/core/mapme.c b/hicn-light/src/hicn/core/mapme.c
index 3a1c9777b..dfb30da5c 100644
--- a/hicn-light/src/hicn/core/mapme.c
+++ b/hicn-light/src/hicn/core/mapme.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,6 +16,98 @@
 /**
  * @file mapme.c
  * @brief MAP-Me : AnchorLess Producer Mobility Management.
+ *
+ * TODO:
+ *  - review notification code with to integration of VPP implementation
+ *  - reflect changes back in VPP
+ *  - implement heuristic for update/notification selection
+ *
+ * MAP-Me hooks in forwarder
+ *
+ * A) Face table changes
+ *
+ *  - face added
+ *
+ *    * new local/producer face : this is a new prefix that we need to advertise
+ *      on existing connections.
+ *
+ *      We go over non-local connections an advertise the prefix through an IU
+ *      provided that the connection satisfies the policy associated to the FIB
+ *      entry. MAP-Me assumes the prefix already exists in the network, and the
+ *      IU shall be discarded if the entry does not exist at the next hop. Three
+ *      possibilities:
+ *      . a bootstrap mechanism
+ *      . we allow subprefixes of a prefix that is not empty by duplicating the
+ *        FIB entry
+ *      . we allow prefix creation in all circumstances : this is problematic
+ *        since we might be creating spurious entries in routers for which we
+ *        don't expect entries to be created.
+ *
+ *     NOTE: because in general we will not allow for FIB entry creation, we
+ *     cannot let the forwarder remove FIB entries with no nexthop (for instance
+ *     after the producer leaves a point-of-attachment). This might creates
+ *     permanent state in router's tables, but we assume it is the role of the
+ *     routing plane to take care of routing entries.
+ *
+ *    * new non-local face : a new face is available (eg. thanks to the face
+ *      manager, after the node has connection to a new WiFi/LTE access point),
+ *      and we thus need to advertise all local/producer prefixes onto this
+ *      interface.
+ *
+ *      For this, we currently scan the FIB for entries that have at least one
+ *      local/producer face in nexthops, advertise the prefix on this new
+ *      connection provided that it satisfies the associated policy.
+ *
+ *  - face removed
+ *
+ *    Currently, we take no action when a face is removed. It might however be a
+ *    signal that a producer application is no more running at a given node, and
+ *    that we can temporarily disable the forwarding towards that path.
+ *
+ *  - face up / down
+ *
+ *  - face nexthop added
+ *
+ *  - face changed priority/tags
+ *
+ * B) Interest and Data forwarder path
+ *
+ *   mapme_on_interest
+ *
+ *   mapme_on_data
+ *
+ *
+ *   EVENTS
+ *      NH_SET
+ *      NH_ADD
+ *      PH_ADD
+ *      PH_DEL
+ *
+ * C) Retransmission management
+ *
+ *   Data structure
+ *
+ *   mapme_on_timeout
+ *
+ *
+ * This allows us to define a convenient API for implementing MAP-Me:
+ *
+ * mapme_on_face_event XXX rename
+ *
+ * mapme_set_all_adjacencies(const mapme_t *mapme, fib_entry_t *entry)
+ *  This function is used to update all the adjacencies. It needs to be called
+ *  in case of face add/delete/change (priority/tas) and polocy
+ *
+ * mapme_set_adjacencies(const mapme_t *mapme, fib_entry_t *entry,
+ *                        nexthops_t *nexthops)
+ *  This function updates only the nexthops and clear the tfib. It
+ *  needs to be called by the forwarding strategy in case of path switch
+ *
+ * mapme_update_adjacencies(const mapme_t *mapme, fib_entry_t *entry,
+ *                          bool inc_iu_seq)
+ *  This function is called to propagate the IU and it propagates the IU using
+ *  the nexthops in the tfib. It needs to be used for mapme prcessing, IU
+ *  forwarding, NATs and in case of timeouts
  */
 
 #ifdef WITH_MAPME
@@ -24,236 +116,184 @@
 #include <hicn/core/mapme.h>
 #include <stdio.h>  // printf
 
+#include <hicn/base/loop.h>
 #include <hicn/core/connection.h>
-#include <hicn/core/connectionList.h>
 #include <hicn/core/forwarder.h>
-#include <hicn/core/logger.h>
-#include <hicn/core/message.h>
-#include <hicn/core/messagePacketType.h>  // packet types
+#include <hicn/core/msgbuf.h>
 #include <hicn/core/ticks.h>
-#include <hicn/processor/fibEntry.h>
-#include <hicn/processor/pitEntry.h>
-
-#include <parc/algol/parc_HashMap.h>
-#include <parc/algol/parc_Iterator.h>
-#include <parc/algol/parc_Unsigned.h>
-#include <parc/assert/parc_Assert.h>
+#include <hicn/core/fib_entry.h>
+#include <hicn/core/pit.h>
+#include <hicn/base/loop.h>
+#include <hicn/util/log.h>
 
 #define MS2NS(x) x * 1000000
 #define T2NS(x) forwarder_TicksToNanos(x)
 
+//#define MAPME_ALLOW_NONEXISTING_FIB_ENTRY
 #define MAPME_DEFAULT_TU 5000  /* ms */
 #define MAPME_DEFAULT_RETX 500 /* ms */
-#define MAX_RETX 3
+#define MAPME_DEFAULT_DISCOVERY false
+#define MAPME_DEFAULT_PROTOCOL IPPROTO_IPV6
+#define MAPME_MAX_RETX 3
+#define MTU 1500  // XXX TODO Mutualize this define
 
-#define NOT_A_NOTIFICATION false
-#define NO_INGRESS 0
+#define DONT_QUEUE false
 #define TIMER_NO_REPEAT false
 
-#define DO_DISCOVERY 1
 #define MAPME_INVALID_DICOVERY_SEQ -1
+#define INIT_SEQ 0
 
-#define LOG_FACILITY LoggerFacility_Core
+#define foreach_mapme_event \
+  _(UNDEFINED)              \
+  _(FACE_ADD)               \
+  _(FACE_DEL)               \
+  _(NH_SET)                 \
+  _(NH_ADD)                 \
+  _(PH_ADD)                 \
+  _(PH_DEL)                 \
+  _(N)
+
+typedef enum {
+#define _(x) MAPME_EVENT_##x,
+  foreach_mapme_event
+#undef _
+} mapme_event_t;
 
-#define LOG(mapme, log_level, fmt, ...)                          \
-  do {                                                           \
-    Logger *logger = forwarder_GetLogger(mapme->forwarder);      \
-    if (logger_IsLoggable(logger, LOG_FACILITY, log_level)) {    \
-      logger_Log(logger, LOG_FACILITY, log_level, __func__, fmt, \
-                 ##__VA_ARGS__);                                 \
-    }                                                            \
-  } while (0)
+/*
+ * We need a retransmission pool holding all necessary information for crafting
+ * special interests, thus including both the DPO and the prefix associated to
+ * it.
+ */
+#define NUM_RETX_ENTRIES 100
+#define NUM_RETX_SLOT 2
 
-#define WARN(mapme, fmt, ...) \
-  LOG(mapme, PARCLogLevel_Warning, fmt, ##__VA_ARGS__)
-#define ERR(mapme, fmt, ...) LOG(mapme, PARCLogLevel_Error, fmt, ##__VA_ARGS__)
-#define INFO(mapme, fmt, ...) LOG(mapme, PARCLogLevel_Info, fmt, ##__VA_ARGS__)
-#define DEBUG(mapme, fmt, ...) \
-  LOG(mapme, PARCLogLevel_Debug, fmt, ##__VA_ARGS__)
+typedef struct {
+  hicn_prefix_t prefix;
+  fib_entry_t *entry;
+  uint8_t retx_count;  // Number of retransmissions since last tfib addition
+} mapme_retx_t;
 
 /**
  * MAP-Me state data structure
  */
-struct mapme {
-  uint32_t retx; /* ms */
-  uint32_t Tu;   /* ms */
-  bool removeFibEntries;
+struct mapme_s {
+  /* Options XXX mapme_conf_t ! */
+  uint32_t retx;      /* retx timeout (in ms) */
+  uint32_t timescale; /* timescale (in ms) */
+  bool discovery;     /* discovery flag */
+  int protocol;
+  bool enabled; /* mapme enabled/disabled */
 
-  Forwarder *forwarder;
+  /*
+   * Retransmissions
+   * Lite calendar queue with NUM_RETX_SLOT slots
+   */
+  event_t *timer;
+  mapme_retx_t retx_array[NUM_RETX_SLOT][NUM_RETX_ENTRIES];
+  uint8_t retx_len[NUM_RETX_SLOT];
+  uint8_t cur;
+  uint8_t idle;
+
+  forwarder_t *forwarder;
 };
 
-static MapMe MapMeDefault = {.retx = MAPME_DEFAULT_RETX,
-                             .Tu = MAPME_DEFAULT_TU,
-                             .removeFibEntries = false};
+#define NEXT_SLOT(CUR) (1 - CUR)
+#define CUR mapme->retx_array[mapme->cur]
+#define NXT mapme->retx_array[NEXT_SLOT(mapme->cur)]
+#define CURLEN mapme->retx_len[mapme->cur]
+#define NXTLEN mapme->retx_len[NEXT_SLOT(mapme->cur)]
+
+static mapme_t mapme_default = {
+    .retx = MAPME_DEFAULT_RETX,
+    .timescale = MAPME_DEFAULT_TU,
+    .discovery = MAPME_DEFAULT_DISCOVERY,
+    .protocol = MAPME_DEFAULT_PROTOCOL,
+    .enabled = true,
+    .timer = NULL,
+    //    .retx_array = {{ 0 }}, // memset
+    .retx_len = {0},
+    .cur = 0, /* current slot */
+    .idle = 0,
+};
 
 /******************************************************************************/
 
-bool mapme_create(MapMe **mapme, Forwarder *forwarder) {
-  *mapme = malloc(sizeof(MapMe));
-  if (!mapme) goto ERR_MALLOC;
+int mapme_on_timeout(void *mapme_arg, int fd, void *data);
 
-  /* Internal state : set default values */
-  memcpy(*mapme, &MapMeDefault, sizeof(MapMe));
-
-  (*mapme)->forwarder = forwarder;
+mapme_t *mapme_create(void *forwarder) {
+  mapme_t *mapme = malloc(sizeof(mapme_t));
+  if (!mapme) return NULL;
 
-  /* As there is no face table and no related events, we need to install hooks
-   * in various places in the forwarder, where both control commands and
-   * signalization are processed.
-   */
+  /* Internal state : set default values */
+  memcpy(mapme, &mapme_default, sizeof(mapme_t));
+  memset(mapme->retx_array, 0, NUM_RETX_SLOT * NUM_RETX_ENTRIES);
 
-  return true;
+  mapme->forwarder = forwarder;
+  loop_timer_create(&mapme->timer, MAIN_LOOP, mapme, mapme_on_timeout, NULL);
+  if (!mapme->timer) {
+    ERROR("Error allocating mapme timer.");
+    free(mapme);
+    return NULL;
+  }
 
-ERR_MALLOC:
-  return false;
+  return mapme;
 }
 
-void mapme_free(MapMe *mapme)
-{
-    free(mapme);
+void mapme_free(mapme_t *mapme) {
+  loop_event_free(mapme->timer);
+  free(mapme);
 }
 
 /******************************************************************************
  * TFIB
  ******************************************************************************/
 
-#define INVALID_SEQ 0
-#define INIT_SEQ 0
-
 typedef struct {
+  // XXX We need magic number to know whether the TFIB was initialized or not
+  // ... or merge it inside the real data structure.
+  // NOTE: in VPP we reuse the nexthops in opposite order to gain room
+  // XXX need enough space in user_data !!
   uint32_t seq;
-  PARCHashMap *nexthops;
+  nexthops_t nexthops;  // XXX useless shadow structure
   /* Update/Notification heuristic */
-  Ticks lastAckedUpdate;
-} MapMeTFIB;
+  Ticks last_acked_update;
+} mapme_tfib_t;
+
+#define TFIB(FIB_ENTRY) ((mapme_tfib_t *)fib_entry_get_user_data(FIB_ENTRY))
+
+static mapme_tfib_t *mapme_tfib_create() {
+  mapme_tfib_t *tfib;
+  tfib = malloc(sizeof(mapme_tfib_t));
+  if (!tfib) return NULL;
 
-static MapMeTFIB *mapmeTFIB_Create() {
-  MapMeTFIB *tfib;
-  tfib = malloc(sizeof(MapMeTFIB));
-  if (!tfib) goto ERR_MALLOC;
+  // init
   tfib->seq = INIT_SEQ;
-  tfib->lastAckedUpdate = 0;
-  tfib->nexthops = parcHashMap_Create();
-  if (!tfib->nexthops) goto ERR_HASHMAP;
+  tfib->last_acked_update = 0;
+  nexthops_set_len(&tfib->nexthops, 0);
 
   return tfib;
-
-ERR_HASHMAP:
-  free(tfib);
-ERR_MALLOC:
-  return NULL;
 }
 
-static PARCIterator *mapmeTFIB_CreateKeyIterator(const MapMeTFIB *tfib) {
-  /*
-   * Creating an iterator on an empty HashMap seems to raise an exception
-   * due to :
-   *   parcTrapOutOfMemoryIf(state->listIterator == NULL,
-   *     "Cannot create parcLinkedList_CreateIterator");
-   * in : _parcHashMap_Init
-   *
-   * All buckets are empty, as they are after creation, and as they should be,
-   * but the error is triggered.
-   */
-  if (parcHashMap_Size(tfib->nexthops) == 0)
-      return NULL;
-  return parcHashMap_CreateKeyIterator(tfib->nexthops);
+void mapme_release_tfib(mapme_tfib_t **tfibPtr) {
+  mapme_tfib_t *tfib = *tfibPtr;
+  free(tfib);
+  tfibPtr = NULL;
 }
 
-void mapmeTFIB_Release(const MapMe * mapme, MapMeTFIB **tfibPtr);
-
 /**
- * @function mapme_CreateTFIB
- * @abstract Associate a new TFIB entry to a FIB entry.
+ * @function mapme_create_tfib
+ * @abstract Associate a new TFIB entry to a FIB entry. If a TFIB already exists
+ * the new one will be used
  * @param [in] - Pointer to the FIB entry.
  * @return Boolean indicating the success of the operation.
  */
-static void mapme_CreateTFIB(const MapMe * mapme, FibEntry *fibEntry) {
-  MapMeTFIB *tfib;
-
-  /* Make sure we don't already have an associated TFIB entry */
-  tfib = fibEntry_getUserData(fibEntry);
-  // assertNull(tfib);
+static void mapme_create_tfib(const mapme_t *mapme, fib_entry_t *entry) {
+  mapme_tfib_t *tfib;
 
-  tfib = mapmeTFIB_Create();
-  fibEntry_setUserData(fibEntry, mapme, tfib, (void (*)(const void*, void**))mapmeTFIB_Release);
-}
-
-#define TFIB(fibEntry) ((MapMeTFIB *)fibEntry_getUserData(fibEntry))
-
-static const PARCEventTimer *mapmeTFIB_Get(const MapMeTFIB *tfib,
-                                           unsigned conn_id) {
-  const PARCEventTimer *timer;
-  const PARCBuffer *buffer;
-  PARCUnsigned *cid = parcUnsigned_Create(conn_id);
-  buffer = parcHashMap_Get(tfib->nexthops, cid);
-  if (!buffer) {
-    timer = NULL;
-    goto END;
-  }
-  PARCByteArray *array = parcBuffer_Array(buffer);
-  timer = *((PARCEventTimer **)parcByteArray_Array(array));
-END:
-  parcUnsigned_Release(&cid);
-  return timer;
+  tfib = mapme_tfib_create();
+  fib_entry_set_user_data(entry, tfib, (void (*)(void **))mapme_release_tfib);
 }
 
-static void mapmeTFIB_Put(MapMeTFIB *tfib, unsigned conn_id,
-                          const PARCEventTimer *timer) {
-  /* NOTE: Timers are not objects (the only class not being an object in
-   * fact), and as such, we cannot use them as values for the HashMap.
-   * Just like for unsigned we needed the PARC wrapper.
-   * There is no wrapper for pointers, so we use Arrays, which has an ubly
-   * syntax...
-   */
-  PARCUnsigned *cid = parcUnsigned_Create(conn_id);
-  PARCBuffer *buffer = parcBuffer_CreateFromArray(&timer, sizeof(PARCEventTimer *));
-  parcHashMap_Put(tfib->nexthops, cid, buffer);
-
-  parcUnsigned_Release(&cid);
-  parcBuffer_Release(&buffer);
-}
-
-static void mapmeTFIB_Remove(const MapMe * mapme, MapMeTFIB *tfib, unsigned conn_id) {
-  PARCUnsigned *cid = parcUnsigned_Create(conn_id);
-
-  /* Release timer */
-  const PARCBuffer *buffer = parcHashMap_Get(tfib->nexthops, cid);
-  if (buffer) {
-    PARCByteArray *array = parcBuffer_Array(buffer);
-    PARCEventTimer * timer = *((PARCEventTimer **)parcByteArray_Array(array));
-    if (timer) {
-      parcEventTimer_Stop(timer);
-      Dispatcher *dispatcher = forwarder_GetDispatcher(mapme->forwarder);
-      dispatcher_DestroyTimerEvent(dispatcher, &timer);
-    }
-  }
-
-  parcHashMap_Remove(tfib->nexthops, cid);
-  parcUnsigned_Release(&cid);
-}
-
-void mapmeTFIB_Release(const MapMe * mapme, MapMeTFIB **tfibPtr) {
-  MapMeTFIB *tfib = *tfibPtr;
-
-  /* Release all TFIB entries, incl. timers */
-  PARCIterator *iterator = mapmeTFIB_CreateKeyIterator(tfib);
-  if (iterator) {
-    /* No iterator is created if the TFIB is empty */
-    while (parcIterator_HasNext(iterator)) {
-      PARCUnsigned *cid = parcIterator_Next(iterator);
-      unsigned conn_id = parcUnsigned_GetUnsigned(cid);
-      mapmeTFIB_Remove(mapme, tfib, conn_id);
-    }
-    parcIterator_Release(&iterator);
-  }
-
-  parcHashMap_Release(&tfib->nexthops);
-  free(tfib);
-  *tfibPtr = NULL;
-}
-
-
 int hicn_prefix_from_name(const Name *name, hicn_prefix_t *prefix) {
   NameBitvector *bv = name_GetContentName(name);
   ip_prefix_t ip_prefix;
@@ -263,500 +303,554 @@ int hicn_prefix_from_name(const Name *name, hicn_prefix_t *prefix) {
   return hicn_prefix_create_from_ip_prefix(&ip_prefix, prefix);
 }
 
-static Message *mapme_createMessage(const MapMe *mapme, const Name *name,
-                                    mapme_params_t *params) {
-  Ticks now = forwarder_GetTicks(mapme->forwarder);
-  Logger *logger = forwarder_GetLogger(mapme->forwarder);
-
-  INFO(mapme, "[MAP-Me] CreateMessage type=%d seq=%d", params->type,
-       params->seq);
-
-  hicn_prefix_t prefix;
-  int rc = hicn_prefix_from_name(name, &prefix);
-  if (rc < 0) {
-    ERR(mapme, "[MAP-Me] Failed to create lib's name");
-    goto ERR_NAME;
-  }
-
-
-  size_t size = (params->protocol == IPPROTO_IPV6) ? HICN_MAPME_V6_HDRLEN
-                                                   : HICN_MAPME_V4_HDRLEN;
-  uint8_t *icmp_pkt = parcMemory_AllocateAndClear(size);
-
-  INFO(mapme, "[MAP-Me] Creating MAP-Me packet");
-  size_t len = hicn_mapme_create_packet(icmp_pkt, &prefix, params);
-  if (len == 0) {
-    ERR(mapme, "[MAP-Me] Failed to create mapme packet through lib");
-    goto ERR_CREATE;
-  }
-
-  // hicn_packet_dump(icmp_pkt, MAPME_HDRLEN);
-
-  return message_CreateFromByteArray(NO_INGRESS, icmp_pkt,
-                                     MessagePacketType_Interest, now, logger);
-
-ERR_CREATE:
-  parcMemory_Deallocate(&icmp_pkt);
-ERR_NAME:
-  return NULL;
-}
-
-static Message *mapme_createAckMessage(const MapMe *mapme,
-                                       const uint8_t *msgBuffer,
-                                       const mapme_params_t *params) {
-  Ticks now = forwarder_GetTicks(mapme->forwarder);
-  Logger *logger = forwarder_GetLogger(mapme->forwarder);
-
-  size_t size = (params->protocol == IPPROTO_IPV6) ? HICN_MAPME_V6_HDRLEN
-                                                   : HICN_MAPME_V4_HDRLEN;
-  uint8_t *icmp_pkt = parcMemory_AllocateAndClear(size);
-  memcpy(icmp_pkt, msgBuffer, size);
-
-  size_t len = hicn_mapme_create_ack(icmp_pkt, params);
-  if (len != size) {
-    ERR(mapme, "[MAP-Me] Failed to create mapme ack packet through lib");
-    goto ERR;
-  }
-
-  return message_CreateFromByteArray(
-      NO_INGRESS, icmp_pkt, MessagePacketType_ContentObject, now, logger);
-
-ERR:
-  parcMemory_Deallocate(&icmp_pkt);
-  return NULL;
-}
-
-struct setFacePendingArgs {
-  const MapMe *mapme;
-  const Name *name;
-  FibEntry *fibEntry;
-  unsigned conn_id;
-  bool send;
-  bool is_producer;
-  uint32_t num_retx;
-};
-
-static bool mapme_setFacePending(const MapMe *mapme, const Name *name,
-                                 FibEntry *fibEntry, unsigned conn_id,
-                                 bool send, bool is_producer, bool clear_tfib, uint32_t num_retx);
-
-static void mapme_setFacePendingCallback(int fd, PARCEventType which_event,
-                                         void *data) {
-  struct setFacePendingArgs *args = (struct setFacePendingArgs *)data;
-
-  parcAssertTrue(which_event & PARCEventType_Timeout,
-                 "Event incorrect, expecting %X set, got %X",
-                 PARCEventType_Timeout, which_event);
-
-  INFO(args->mapme, "Timeout during retransmission. Re-sending");
-  mapme_setFacePending(args->mapme, args->name, args->fibEntry, args->conn_id,
-                       args->send, args->is_producer, false, args->num_retx);
-  free(args);
-}
-
 /**
  * @brief Update/Notification heuristic:
  *
  * NOTE: IN are currently disabled until the proper placeholder is agreed in the
  * interest header.
  */
-static hicn_mapme_type_t mapme_getTypeFromHeuristic(const MapMe *mapme,
-                                                    FibEntry *fibEntry) {
+static hicn_mapme_type_t mapme_get_type_from_heuristic(const mapme_t *mapme,
+                                                       fib_entry_t *entry) {
+  if (fib_entry_has_local_nexthop(entry))
+    /* We are a producer for this entry, send update */
+    return UPDATE;
+
 #if 0 /* interplay of IU/IN */
-    if (TFIB(fibEntry)->lastAckedUpdate == 0) {
+    if (TFIB(fib_entry)->lastAckedUpdate == 0) {
         return UPDATE;
     } else {
-        Ticks interval = now - TFIB(fibEntry)->lastAckedUpdate;
-        return (T2NS(interval) > MS2NS(mapme->Tu)) ? UPDATE : NOTIFICATION;
+        Ticks interval = now - TFIB(fib_entry)->lastAckedUpdate;
+        return (T2NS(interval) > MS2NS(mapme->timescale)) ? UPDATE : NOTIFICATION;
     }
 #else /* Always send IU */
   return UPDATE;
 #endif
 }
 
-static bool mapme_setFacePending(const MapMe *mapme, const Name *name,
-                                 FibEntry *fibEntry, unsigned conn_id,
-                                 bool send, bool is_producer, bool clear_tfib, uint32_t num_retx) {
-  int rc;
+/**
+ *
+ * Here nexthops is not necessarily FIB nexthops as we might advertise given FIB
+ * entries on various other connections.
+ */
+/* NOTE: if the face is pending an we receive an IN, maybe we should not cancel
+ * the timer
+ */
+// XXX Make sure this function is never called for Notifications
+// XXX overall review notification code and integrate it in VPP
+int mapme_send_to_nexthops(const mapme_t *mapme, fib_entry_t *entry,
+                           const nexthops_t *nexthops) {
+  if (mapme->enabled == false) {
+    WARN("MAP-Me is NOT enabled");
+    return -1;
+  }
 
-  INFO(mapme, "[MAP-Me] SetFacePending connection=%d prefix=XX retx=%d",
-       conn_id, num_retx);
+  mapme_tfib_t *tfib = TFIB(entry);
+  if (tfib == NULL) {
+    mapme_create_tfib(mapme, entry);
+    tfib = TFIB(entry);
+  }
 
-  /* NOTE: if the face is pending an we receive an IN, maybe we should not
-   * cancel the timer
-   */
-  Dispatcher *dispatcher = forwarder_GetDispatcher(mapme->forwarder);
-  PARCEventTimer *timer;
+  const Name *name = fib_entry_get_prefix(entry);
 
-  /* Safeguard during retransmissions */
-  if (!TFIB(fibEntry))
-      return true;
+  WITH_DEBUG({
+    char *name_str = name_ToString(name);
+    DEBUG("sending IU/IN for name %s on all nexthops", name_str);
+    free(name_str);
+  })
 
-  /*
-   * On the producer side, we have to clear the TFIB everytime we change the list
-   * of adjacencies, otherwise retransmissions will occur to preserve them.
-   */
-  if (clear_tfib) {
-    /*
-     * It is likely we cannot iterator and remove elements from the hashmap at
-     * the same time, so we proceed in two steps
-     */
-    if (parcHashMap_Size(TFIB(fibEntry)->nexthops) > 0) {
+  mapme_params_t params = {
+      .protocol = mapme->protocol,
+      .type = mapme_get_type_from_heuristic(mapme, entry),
+      .seq = tfib->seq,
+  };
 
-      NumberSet * conns = numberSet_Create();
+  hicn_prefix_t prefix;
+  if (hicn_prefix_from_name(name, &prefix) < 0) {
+    ERROR("Failed to create lib's name");
+    return -1;
+  }
 
-      PARCIterator *it = parcHashMap_CreateKeyIterator(TFIB(fibEntry)->nexthops);
-      while (parcIterator_HasNext(it)) {
-        PARCUnsigned *cid = parcIterator_Next(it);
-        unsigned conn_id = parcUnsigned_GetUnsigned(cid);
-        numberSet_Add(conns, conn_id);
-      }
-      parcIterator_Release(&it);
+  uint8_t packet[MTU];
+  size_t size = hicn_mapme_create_packet(packet, &prefix, &params);
+  if (size <= 0) {
+    ERROR("Could not create MAP-Me packet");
+    return -1;
+  }
 
-      for (size_t i = 0; i < numberSet_Length(conns); i++) {
-        unsigned conn_id = numberSet_GetItem(conns, i);
-        mapmeTFIB_Remove(mapme, TFIB(fibEntry), conn_id);
-      }
+  connection_table_t *table = forwarder_get_connection_table(mapme->forwarder);
 
-      numberSet_Release(&conns);
-    }
-  }
+  unsigned nexthop;
+  nexthops_foreach(nexthops, nexthop, {
+    INFO("sending mapme packet on connection %d", nexthop);
+    const connection_t *conn = connection_table_get_by_id(table, nexthop);
+    connection_send_packet(conn, packet, size);
+  });
 
-  // NOTE
-  // - at producer, send always true, we always send something reliably so we
-  // set the timer.
-  // - in the network, we always forward an IU, and never an IN
-  //if (is_producer || send) {
-  if (send) {
-    mapme_params_t params = {
-        .protocol = IPPROTO_IPV6,
-        .type = is_producer ? mapme_getTypeFromHeuristic(mapme, fibEntry) : UPDATE,
-        .seq = TFIB(fibEntry)->seq};
-    Message *special_interest = mapme_createMessage(mapme, name, &params);
-    if (!special_interest) {
-      INFO(mapme, "[MAP-Me] Could not create special interest");
-      return false;
-    }
+  return 0;
+}
 
-    const ConnectionTable *table =
-        forwarder_GetConnectionTable(mapme->forwarder);
-    const Connection *conn =
-        connectionTable_FindById((ConnectionTable *)table, conn_id);
-    if (conn) {
-      const Name * name = message_GetName(special_interest);
-      char * name_str = name_ToString(name);
-      INFO(mapme, "[MAP-Me] Sending MAP-Me packet name=%s seq=%d conn=%d",
-              name_str, params.seq, conn_id);
-      free(name_str);
-      connection_ReSend(conn, special_interest, NOT_A_NOTIFICATION);
-    } else {
-      INFO(mapme, "[MAP-Me] Stopped retransmissions as face went down");
-    }
-    message_Release(&special_interest);
-
-    if (num_retx < MAX_RETX) {
-      INFO(mapme, "[MAP-Me]   - Scheduling retransmission\n");
-      /* Schedule retransmission */
-      struct setFacePendingArgs *args =
-          malloc(sizeof(struct setFacePendingArgs));
-      if (!args)
-          goto ERR_MALLOC;
-      args->mapme = mapme;
-      args->name = name;
-      args->fibEntry = fibEntry;
-      args->conn_id = conn_id;
-      args->send = send;
-      args->is_producer = is_producer;
-      args->num_retx = num_retx + 1;
-
-      timer = dispatcher_CreateTimer(dispatcher, TIMER_NO_REPEAT,
-                                     mapme_setFacePendingCallback, args);
-      struct timeval timeout = {mapme->retx / 1000,
-                                (mapme->retx % 1000) * 1000};
-      rc = parcEventTimer_Start(timer, &timeout);
-      if (rc < 0) {
-          free(args);
-          goto ERR_TIMER;
-      }
-    } else {
-      INFO(mapme, "[MAP-Me] Last retransmission.");
-      timer = NULL;
-    }
-  } else {
-    INFO(mapme, "[MAP-Me]  - not forwarding as send is False");
-    timer = NULL;
+/**
+ *
+ * Here nexthops is not necessarily FIB nexthops as we might advertise given FIB
+ * entries on various other connections.
+ */
+void mapme_maybe_send_to_nexthops(const mapme_t *mapme, fib_entry_t *fib_entry,
+                                  const nexthops_t *nexthops) {
+  if (mapme->enabled == false) {
+    WARN("MAP-Me is NOT enabled");
+    return;
   }
 
-  mapmeTFIB_Remove(mapme, TFIB(fibEntry), conn_id);
-  mapmeTFIB_Put(TFIB(fibEntry), conn_id, timer);
+  /* Detect change */
+  if (!fib_entry_nexthops_changed(fib_entry)) {
+    INFO("No change in nexthops");
+    return;
+  }
+  fib_entry_set_prev_nexthops(fib_entry);
+
+  mapme_send_to_nexthops(mapme, fib_entry, nexthops);
+}
+
+/******************************************************************************
+ * MAPME API
+ ******************************************************************************/
+
+int mapme_set_all_adjacencies(const mapme_t *mapme, fib_entry_t *entry) {
+  if (mapme->enabled == false) {
+    WARN("MAP-Me is NOT enabled");
+    return -1;
+  }
 
-  return true;
+  /* Apply the policy of the fib_entry over all neighbours */
+  nexthops_t new_nexthops = NEXTHOPS_EMPTY;
+  nexthops_t *nexthops =
+      fib_entry_get_available_nexthops(entry, ~0, &new_nexthops);
 
-ERR_TIMER:
-  dispatcher_DestroyTimerEvent(dispatcher, &timer);
-ERR_MALLOC:
-  return false;
+  /* We set force to true to avoid overriding the FIB cache */
+  return mapme_set_adjacencies(mapme, entry, nexthops, true);
 }
 
-/*------------------------------------------------------------------------------
- * Event handling
- *----------------------------------------------------------------------------*/
+int mapme_set_adjacencies(const mapme_t *mapme, fib_entry_t *entry,
+                          nexthops_t *nexthops, bool force) {
+  if (mapme->enabled == false) {
+    WARN("MAP-Me is NOT enabled");
+    return -1;
+  }
 
-/*
- * Return true if we have at least one local connection as next hop
- */
-static bool mapme_hasLocalNextHops(const MapMe *mapme,
-                                   const FibEntry *fibEntry) {
-  const NumberSet *nexthops = fibEntry_GetNexthops(fibEntry);
-  const ConnectionTable *table = forwarder_GetConnectionTable(mapme->forwarder);
-
-  for (size_t j = 0; j < fibEntry_NexthopCount(fibEntry); j++) {
-    /* Retrieve Nexthop #j */
-    unsigned conn_id = numberSet_GetItem(nexthops, j);
-    const Connection *conn =
-        connectionTable_FindById((ConnectionTable *)table, conn_id);
-
-    /* Ignore non-local connections */
-    if (!connection_IsLocal(conn)) continue;
-    /* We don't need to test against conn_added since we don't
-     * expect it to have any entry in the FIB */
+  if (!fib_entry_has_local_nexthop(entry)) return -1;
 
-    return true;
+  /* Advertise prefix on all available next hops (if needed) */
+  mapme_tfib_t *tfib = TFIB(entry);
+  if (tfib == NULL) {
+    mapme_create_tfib(mapme, entry);
+    tfib = TFIB(entry);
   }
-  return false;
-}
 
-void
-mapme_send_updates(const MapMe * mapme, FibEntry * fibEntry, const NumberSet * nexthops)
-{
-  if (!TFIB(fibEntry)) /* Create TFIB associated to FIB entry */
-    mapme_CreateTFIB(mapme, fibEntry);
-  TFIB(fibEntry)->seq++;
-
-  const Name *name = fibEntry_GetPrefix(fibEntry);
-  char *name_str = name_ToString(name);
-  bool clear_tfib = true;
-
-  INFO(mapme, "[MAP-Me] Candidate next hops changed");
-  for (size_t j = 0; j < numberSet_Length(nexthops); j++) {
-      unsigned nexthop_id = numberSet_GetItem(nexthops, j);
-
-      /* We extract the nexthop type based on tags */
-      const char * nexthop_type;
-      ConnectionTable * table = forwarder_GetConnectionTable(mapme->forwarder);
-      const Connection * conn = connectionTable_FindById(table, nexthop_id);
-      if (connection_HasTag(conn, POLICY_TAG_WIRED)) {
-          nexthop_type = "WIRED";
-      } else if (connection_HasTag(conn, POLICY_TAG_WIFI)) {
-          nexthop_type = "WIFI";
-      } else if (connection_HasTag(conn, POLICY_TAG_CELLULAR)) {
-          nexthop_type = "CELLULAR";
-      } else {
-          nexthop_type = "UNKNOWN";
-      }
+  nexthops_clear(&tfib->nexthops);
+  tfib->seq++;
 
-      INFO(mapme, "[MAP-Me] sending IU/IN for name %s on connection %d - %s (%s)", name_str,
-           nexthop_id, connection_GetInterfaceName(conn), nexthop_type);
-      mapme_setFacePending(mapme, name, fibEntry, nexthop_id, true, true, clear_tfib, 0);
-      clear_tfib = false;
+  if (force) {
+    mapme_send_to_nexthops(mapme, entry, nexthops);
+    return 0;
   }
-  INFO(mapme, "[MAP-Me] Done sending MAP-Me update");
-  free(name_str);
+
+  mapme_maybe_send_to_nexthops(mapme, entry, nexthops);
+  return 0;
 }
 
+int mapme_update_adjacencies(const mapme_t *mapme, fib_entry_t *entry,
+                             bool inc_iu_seq) {
+  if (mapme->enabled == false) {
+    WARN("MAP-Me is NOT enabled");
+    return -1;
+  }
 
-void
-mapme_maybe_send_updates(const MapMe * mapme, FibEntry * fibEntry, const NumberSet * nexthops)
-{
-  /* Detect change */
-  NumberSet * previous_nexthops = fibEntry_GetPreviousNextHops(fibEntry);
-  if (numberSet_Equals(nexthops, previous_nexthops)) {
-      INFO(mapme, "[MAP-Me] No change in nexthops");
-      return;
+  mapme_tfib_t *tfib = TFIB(entry);
+  if (tfib == NULL) {
+    mapme_create_tfib(mapme, entry);
+    tfib = TFIB(entry);
   }
-  fibEntry_SetPreviousNextHops(fibEntry, nexthops);
 
-  mapme_send_updates(mapme, fibEntry, nexthops);
+  if (inc_iu_seq) tfib->seq++;
+
+  mapme_maybe_send_to_nexthops(mapme, entry, &tfib->nexthops);
+  return 0;
 }
 
-void
-mapme_reconsiderFibEntry(const MapMe *mapme, FibEntry * fibEntry)
-{
-  /*
-   * Skip entries that do not correspond to a producer ( / have a locally
-   * served prefix / have no local connection as next hop)
-   */
-  if (!mapme_hasLocalNextHops(mapme, fibEntry))
-      return;
+int mapme_send_to_nexthop(const mapme_t *mapme, fib_entry_t *entry,
+                          unsigned nexthop) {
+  if (mapme->enabled == false) {
+    WARN("MAP-Me is NOT enabled");
+    return -1;
+  }
 
-  /* Apply the policy of the fibEntry over all neighbours */
-  NumberSet * available_nexthops = fibEntry_GetAvailableNextHops(fibEntry, ~0);
+  nexthops_t nexthops = NEXTHOPS_EMPTY;
+  nexthops_add(&nexthops, nexthop);
 
-  /* Advertise prefix on all available next hops (if needed) */
-  mapme_send_updates(mapme, fibEntry, available_nexthops);
-
-  numberSet_Release(&available_nexthops);
+  return mapme_send_to_nexthops(mapme, entry, &nexthops);
 }
 
 /*
  * Callback called everytime a new connection is created by the control protocol
  */
-void
-mapme_onConnectionEvent(const MapMe *mapme, const Connection *conn_added, connection_event_t event) {
+void mapme_on_connection_event(const mapme_t *mapme,
+                               const connection_t *conn_added,
+                               connection_event_t event) {
+  if (mapme->enabled == false) {
+    WARN("MAP-Me is NOT enabled");
+    return;
+  }
+
   /* Does the priority change impacts the default route selection; if so,
    * advertise the prefix on this default route. If there are many default
    * routes, either v4 v6, or many connections as next hops on this default
    * route, then send to all.
    */
   if (conn_added) {
-    if (connection_IsLocal(conn_added))
-        return;
+    if (connection_is_local(conn_added)) return;
 
-    unsigned conn_added_id = connection_GetConnectionId(conn_added);
-    switch(event) {
+    unsigned conn_added_id = connection_get_id(conn_added);
+    switch (event) {
       case CONNECTION_EVENT_CREATE:
-          INFO(mapme, "[MAP-Me] Connection %d got created", conn_added_id);
-          break;
+        INFO("Connection %d got created", conn_added_id);
+        break;
       case CONNECTION_EVENT_DELETE:
-          INFO(mapme, "[MAP-Me] Connection %d got deleted", conn_added_id);
-          break;
+        INFO("Connection %d got deleted", conn_added_id);
+        break;
       case CONNECTION_EVENT_UPDATE:
-          INFO(mapme, "[MAP-Me] Connection %d got updated", conn_added_id);
-          break;
+        INFO("Connection %d got updated", conn_added_id);
+        break;
       case CONNECTION_EVENT_SET_UP:
-          INFO(mapme, "[MAP-Me] Connection %d went up", conn_added_id);
-          break;
+        INFO("Connection %d went up", conn_added_id);
+        break;
       case CONNECTION_EVENT_SET_DOWN:
-          INFO(mapme, "[MAP-Me] Connection %d went down", conn_added_id);
-          break;
+        INFO("Connection %d went down", conn_added_id);
+        break;
       case CONNECTION_EVENT_TAGS_CHANGED:
-          INFO(mapme, "[MAP-Me] Connection %d changed tags", conn_added_id);
-          break;
+        INFO("Connection %d changed tags", conn_added_id);
+        break;
       case CONNECTION_EVENT_PRIORITY_CHANGED:
-          INFO(mapme, "[MAP-Me] Connection %d changed priority to %d",
-                  conn_added_id, connection_GetPriority(conn_added));
-          break;
+        INFO("Connection %d changed priority to %d", conn_added_id,
+             connection_get_priority(conn_added));
+        break;
     }
   }
 
   /* We need to send a MapMe update on the newly selected connections for
-   * each concerned fibEntry : connection is involved, or no more involved */
-  FibEntryList *fiblist = forwarder_GetFibEntries(mapme->forwarder);
-
-  /* Iterate a first time on the FIB to get the locally served prefixes */
-  for (size_t i = 0; i < fibEntryList_Length(fiblist); i++) {
-    FibEntry *fibEntry = (FibEntry *)fibEntryList_Get(fiblist, i);
-    mapme_reconsiderFibEntry(mapme, fibEntry);
-  }
-
-  fibEntryList_Destroy(&fiblist);
-
-  INFO(mapme, "[MAP-Me] Done");
+   * each concerned fib_entry : connection is involved, or no more involved */
+  const fib_t *fib = forwarder_get_fib(mapme->forwarder);
+  fib_entry_t *entry;
+  fib_foreach_entry(fib, entry, { mapme_set_all_adjacencies(mapme, entry); });
 }
 
 /*------------------------------------------------------------------------------
  * Special Interest handling
  *----------------------------------------------------------------------------*/
 
-/**
- * @discussion This function is way too long and should be cut out
- */
-static bool mapme_onSpecialInterest(const MapMe *mapme,
-                                    const uint8_t *msgBuffer,
-                                    unsigned conn_in_id, hicn_prefix_t *prefix,
-                                    mapme_params_t *params) {
-  const ConnectionTable *table = forwarder_GetConnectionTable(mapme->forwarder);
-  /* The cast is needed since connectionTable_FindById miss the
-   * const qualifier for the first parameter */
-  const Connection *conn_in =
-      connectionTable_FindById((ConnectionTable *)table, conn_in_id);
-  seq_t fibSeq, seq = params->seq;
-  bool send = (params->type == UPDATE);
-  bool rv;
-
-  Name *name = name_CreateFromPacket(msgBuffer, MessagePacketType_Interest);
-  name_setLen(name, prefix->len);
-  char *name_str = name_ToString(name);
-  INFO(mapme,
-       "[MAP-Me] Ack'ed Special Interest on connection %d - prefix=%s type=XX "
-       "seq=%d",
-       conn_in_id, name_str, seq);
-  free(name_str);
+// XXX this code has not been updated
+#ifdef MAPME_ALLOW_NONEXISTING_FIB_ENTRY
+int mapme_create_fib_entry(const mapme_t *mapme, const Name *name,
+                           unsigned ingress_id) {
+  INFO("  - Re-creating FIB entry with next hop on connection %d", ingress_id);
+  /*
+   * This might happen for a node hosting a producer which has moved.
+   * Destroying the face has led to removing all corresponding FIB
+   * entries. In that case, we need to correctly restore the FIB entries.
+   */
+  strategy_type fwdStrategy = LAST_STRATEGY_VALUE;
 
   /*
-   * Immediately send an acknowledgement back on the ingress connection
-   * We always ack, even duplicates.
+   * It might also be due to the announcement of a more specific prefix. In
+   * that case we need to perform a FIB lookup to find the next hops to which
+   * the message should be propagated.
    */
-  Message *ack = mapme_createAckMessage(mapme, msgBuffer, params);
-  if (!ack) {
-    name_Release(&name);
-    return false;
+#ifdef WITH_POLICY
+  entry = fib_entry_Create(name, fwdStrategy, mapme->forwarder);
+#else
+  entry = fib_entry_Create(name, fwdStrategy);
+#endif /* WITH_POLICY */
+  fib_entry_t *lpm = fib_MatchName(fib, name);
+  fib_Add(fib, entry);
+  if (!lpm) {
+    TFIB(entry)->seq = seq;
+    fib_entry_AddNexthop(entry, ingress_id);
+    return true;
   }
-  rv = connection_ReSend(conn_in, ack, NOT_A_NOTIFICATION);
-  message_Release(&ack);
 
-  if (!rv) {
-    name_Release(&name);
-    return false;
+  /*
+   * We make a clone of the FIB entry (zero'ing the sequence number ?) with
+   * the more specific name, and proceed as usual. Worst case we clone the
+   * default route...
+   */
+  const NumberSet *lpm_nexthops = fib_entry_nexthops_get(lpm);
+  for (size_t i = 0; i < numberSet_Length(lpm_nexthops); i++) {
+    fib_entry_AddNexthop(entry, numberSet_GetItem(lpm_nexthops, i));
   }
+  return 0;
+}
+#endif
 
-  /* EPM on FIB */
-  /* only the processor has access to the FIB */
-  FIB *fib = forwarder_getFib(mapme->forwarder);
+int mapme_on_timeout(void *mapme_arg, int fd, void *data) {
+  mapme_t *mapme = mapme_arg;
+  assert(mapme);
+  assert(!data);
+  /* Timeout occurred, we have to retransmit IUs for all pending
+   * prefixes having entries in TFIB
+   *
+   * timeouts are slotted
+   *    |     |     |     |
+   *
+   *      ^
+   *      +- event occurred
+   *            new face, wait for the second next
+   *            (having two arrays and swapping cur and next)
+   *         retx : put in next
+   */
+  mapme->idle += 1;
 
-  FibEntry *fibEntry = fib_Contains(fib, name);
+  for (uint8_t pos = 0; pos < CURLEN; pos++) {
+    mapme_retx_t *retx = &CUR[pos];
 
-  name_Release(&name);
+    if (!retx->entry) /* deleted entry */
+      continue;
 
-  if (!fibEntry) {
-    INFO(mapme, "Ignored update with no FIB entry");
-    return 0;
-#if 0
-    INFO(mapme,
-         "[MAP-Me]   - Re-creating FIB entry with next hop on connection %d",
-         conn_in_id);
-    /*
-     * This might happen for a node hosting a producer which has moved.
-     * Destroying the face has led to removing all corresponding FIB
-     * entries. In that case, we need to correctly restore the FIB entries.
-     */
-    strategy_type fwdStrategy = LAST_STRATEGY_VALUE;
+    mapme_tfib_t *tfib = TFIB(retx->entry);
+    assert(tfib);
 
-    /*
-     * It might also be due to the announcement of a more specific prefix. In
-     * that case we need to perform a FIB lookup to find the next hops to which
-     * the message should be propagated.
+    /* Re-send interest for all entries */
+    mapme_update_adjacencies(mapme, retx->entry, false);
+
+    retx->retx_count++;
+    /* If we exceed the numver of retransmittion it means that all tfib
+     * entries have seens at least HICN_PARAM_RETX_MAX of retransmission
      */
-#ifdef WITH_POLICY
-    fibEntry = fibEntry_Create(name, fwdStrategy, mapme->forwarder);
-#else
-    fibEntry = fibEntry_Create(name, fwdStrategy);
-#endif /* WITH_POLICY */
-    FibEntry *lpm = fib_MatchName(fib, name);
-    mapme_CreateTFIB(mapme, fibEntry);
-    fib_Add(fib, fibEntry);
-    if (!lpm) {
-      TFIB(fibEntry)->seq = seq;
-      fibEntry_AddNexthop(fibEntry, conn_in_id);
-      return true;
+    if (retx->retx_count < MAPME_MAX_RETX) {
+      /*
+       * We did some retransmissions, so let's reschedule a check in the
+       * next slot
+       */
+      NXT[NXTLEN++] = CUR[pos];
+      mapme->idle = 0;
+    } else {
+      WARN("Maximum retransmissions exceeded");
+      /* If we exceed the numver of retransmission it means that all TFIB
+       * entries have seens at least HICN_PARAM_RTX_MAX retransmissions.
+       * (Deletion might be slightly late).
+       *
+       * XXX document: when adding an entry in TFIB, we might exceed max
+       * retransmissions for previous entries that started retransmitting
+       * beforehand.
+       */
+      nexthops_clear(&tfib->nexthops);
     }
+  }
 
-    /*
-     * We make a clone of the FIB entry (zero'ing the sequence number ?) with
-     * the more specific name, and proceed as usual. Worst case we clone the
-     * default route...
-     */
-    const NumberSet *lpm_nexthops = fibEntry_GetNexthops(lpm);
-    for (size_t i = 0; i < numberSet_Length(lpm_nexthops); i++) {
-        fibEntry_AddNexthop(fibEntry, numberSet_GetItem(lpm_nexthops, i));
+  /* Reset events in this slot and prepare for next one */
+  CURLEN = 0;
+  mapme->cur = NEXT_SLOT(mapme->cur);
+
+  /* After two empty slots, we disable the timer */
+  if (mapme->idle > 1) {
+    loop_event_unregister(mapme->timer);
+  }
+
+  return 0;
+}
+
+static void mapme_on_event(mapme_t *mapme, mapme_event_t event,
+                           fib_entry_t *entry, unsigned ingress_id) {
+  switch (event) {
+#if 0
+        case HICN_MAPME_EVENT_FACE_ADD:
+        {
+            /*
+             * A face has been added:
+             *  - In case of a local app face, we need to advertise a new prefix
+             *  - For another local face type, we need to advertise local
+             *  prefixes and schedule retransmissions
+             */
+            mapme_retx_t *retx_events = event_data;
+            for (uint8_t i = 0; i < vec_len (retx_events); i++) {
+                hicn_mapme_on_face_added(mapme, retx_events[i].dpo);
+            }
+
+            if (mapme->timer_fd == -1)
+                mapme->timer_fd = loop_register_timer(MAIN_LOOP,
+                        mapme->retx, mapme, mapme_on_timeout, NULL);
+            mapme->idle = 0;
+            break;
+        }
+        case HICN_MAPME_EVENT_FACE_DEL:
+            if (mapme->timer_fd == -1)
+                mapme->timer_fd = loop_register_timer(MAIN_LOOP,
+                        DEFAULT_TIMEOUT, mapme, mapme_on_timeout, NULL);
+            mapme->idle = 0;
+            break;
+#endif
+
+    case MAPME_EVENT_NH_SET:
+      /*
+       * An hICN FIB entry has been modified. All operations so far
+       * have been procedded in the nodes. Here we need to track
+       * retransmissions upon timeout: we mark the FIB entry as pending in
+       * the second-to-next slot
+       */
+
+      /*
+       * XXX Move this in doc
+       *
+       * The FIB entry has a new next hop, and its TFIB section has:
+       *  - eventually previous prev hops for which a IU with a
+       *  lower seqno has been sent
+       *  - the prev hops that have just been added.
+       *
+       * We don't distinguish any and just send an updated IU to all
+       * of them. The retransmission of the latest IU to all
+       * facilitates the matching of ACKs to a single seqno which is
+       * the one stored in the FIB.
+       *
+       * Since we retransmit to all prev hops, we can remove this
+       * (T)FIB entry for the check at the end of the current slot.
+       */
+
+      /* Mark FIB entry as pending for second-to-next slot */
+      /*
+       * Transmit IU for all TFIB entries with latest seqno (we have
+       * at least one for sure!)
+       */
+      mapme_update_adjacencies(mapme, entry, false);
+
+      /* Delete entry_id from retransmissions in the current slot (if present)
+       * ... */
+      /* ... and schedule it for next slot (if not already) */
+      uint8_t j;
+      for (j = 0; j < CURLEN; j++) {
+        if (CUR[j].entry == entry) CUR[j].entry = NULL; /* sufficient */
+      }
+      for (j = 0; j < NXTLEN; j++) {
+        if (NXT[j].entry == entry) break;
+      }
+      if (j == NXTLEN) /* not found */
+        NXT[NXTLEN++] = (mapme_retx_t){
+            .entry = entry,
+            .retx_count = 0,
+        };
+
+      if (!loop_timer_is_enabled(mapme->timer)) {
+        if (loop_timer_register(mapme->timer, mapme->retx) < 0) {
+          ERROR("Error setting mapme timer.");
+          break;
+        }
+      }
+      mapme->idle = 0;
+      break;
+
+    case MAPME_EVENT_NH_ADD:
+      /*
+       * XXX move this in doc
+       *
+       * As per the description of states, this event should add the face
+       * to the list of next hops, and eventually remove it from TFIB.
+       * This corresponds to the multipath case.
+       *
+       * In all cases, we assume the propagation was already done when the first
+       * interest with the same sequence number was received, so we stop here
+       * No change in TFIB = no IU to send
+       *
+       * No change in timers.
+       */
+
+      // XXX useless
+#if 0
+            /* Add ingress face as next hop */
+            idle = 0;
+#endif
+      break;
+
+    case MAPME_EVENT_PH_ADD:
+      /* Back-propagation, interesting even for IN (desync) */
+      mapme_send_to_nexthop(mapme, entry, ingress_id);
+
+      mapme->idle = 0;
+      if (!loop_timer_is_enabled(mapme->timer))
+        loop_timer_register(mapme->timer, mapme->retx);
+      break;
+
+    case MAPME_EVENT_PH_DEL:
+      /* Ack : remove an element from TFIB */
+      break;
+
+    case MAPME_EVENT_FACE_ADD:
+    case MAPME_EVENT_FACE_DEL:
+
+    case MAPME_EVENT_UNDEFINED:
+    case MAPME_EVENT_N:
+      ERROR("Unexpected event");
+      break;
+  }
+}
+
+static void mapme_on_interest(mapme_t *mapme, msgbuf_t *msgbuf,
+                              unsigned ingress_id, hicn_prefix_t *prefix,
+                              mapme_params_t *params) {
+  connection_table_t *table = forwarder_get_connection_table(mapme->forwarder);
+
+  /* The cast is needed since connectionTable_FindById miss the
+   * const qualifier for the first parameter */
+  const connection_t *conn_in = connection_table_get_by_id(table, ingress_id);
+
+  /*
+   * Immediately send an acknowledgement back on the ingress connection
+   * We always ack, even duplicates. Clone mgsbuf to avoid to overwrite the
+   * received message
+   */
+  msgbuf_t *ack;
+  msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(mapme->forwarder);
+  off_t interest_offset = msgbuf_pool_get_id(msgbuf_pool, (msgbuf_t *)msgbuf);
+  msgbuf_pool_clone(msgbuf_pool, &ack, interest_offset);
+
+  uint8_t *ack_packet = msgbuf_get_packet(ack);
+  size_t size = hicn_mapme_create_ack(ack_packet, params);
+  if (connection_send_packet(conn_in, ack_packet, size) < 0) {
+    /* We accept the packet knowing we will get a retransmit */
+    ERROR("Failed to send ACK packet");
+  }
+
+  msgbuf_pool_put(msgbuf_pool, ack);
+
+  /* process received interest */
+  uint8_t *packet = msgbuf_get_packet(msgbuf);
+  name_create_from_interest(packet, msgbuf_get_name(msgbuf));
+  Name name = EMPTY_NAME;
+  name_Copy(msgbuf_get_name(msgbuf), &name);
+  name_setLen(&name, prefix->len);
+
+  WITH_DEBUG({
+    char *name_str = name_ToString(&name);
+    DEBUG("Ack'ed interest : connection=%d  prefix=%s seq=%d", ingress_id,
+          name_str, params->seq);
+    free(name_str);
+  });
+
+  /* EPM on FIB */
+  const fib_t *fib = forwarder_get_fib(mapme->forwarder);
+  fib_entry_t *entry = fib_contains(fib, &name);
+  if (!entry) {
+#ifdef HICN_MAPME_ALLOW_NONEXISTING_FIB_ENTRY
+    if (mapme_create_fib_entry(mapme, &name, ingress_id) < 0) {
+      ERROR("Failed to create FIB entry");
+      return;
     }
+#else
+    INFO("Ignored update with no FIB entry");
+    return;
 #endif
+  }
 
-  } else if (!TFIB(fibEntry)) {
-    /* Create TFIB associated to FIB entry */
-    INFO(mapme,
-         "[MAP-Me]   - Creating TFIB entry with default sequence number");
-    mapme_CreateTFIB(mapme, fibEntry);
+  mapme_tfib_t *tfib = TFIB(entry);
+  if (tfib == NULL) {
+    mapme_create_tfib(mapme, entry);
+    tfib = TFIB(entry);
   }
 
   /*
@@ -767,102 +861,40 @@ static bool mapme_onSpecialInterest(const MapMe *mapme,
    * Detection: we receive a message initially sent by ourselves, ie a message
    * for which the prefix has a local next hop in the FIB.
    */
-  if (mapme_hasLocalNextHops(mapme, fibEntry)) {
-    INFO(mapme, "[MAP-Me]   - Received original interest... Update complete");
-    return true;
+  // XXX NOT IN VPP ?
+  if (fib_entry_has_local_nexthop(entry)) {
+    INFO("Received original interest... Update complete");
+    return;
   }
 
-  fibSeq = TFIB(fibEntry)->seq;
-  if (seq > fibSeq) {
-    INFO(mapme,
-         "[MAP-Me]   - Higher sequence number than FIB %d, updating seq and "
-         "next hops",
-         fibSeq);
-    /* This has to be done first to allow processing SpecialInterestAck's */
-    TFIB(fibEntry)->seq = seq;
-
-    /* Reliably forward the IU on all prevHops */
-    INFO(mapme, "[MAP-Me]   - (1/3) processing prev hops");
-    if (params->type == UPDATE) {
-      PARCIterator *iterator = mapmeTFIB_CreateKeyIterator(TFIB(fibEntry));
-      if (iterator) {
-        /* No iterator is created if the TFIB is empty */
-        while (parcIterator_HasNext(iterator)) {
-          PARCUnsigned *cid = parcIterator_Next(iterator);
-          unsigned conn_id = parcUnsigned_GetUnsigned(cid);
-          INFO(mapme, "[MAP-Me]   - Re-sending IU to pending connection %d",
-               conn_id);
-          mapme_setFacePending(mapme, fibEntry_GetPrefix(fibEntry), fibEntry,
-                               conn_id, false, false, false, 0);
-        }
-        parcIterator_Release(&iterator);
-      }
-    }
-
-    /* nextHops -> prevHops
-     *
-     * We add to the list of pendingUpdates the current next hops, and
-     * eventually forward them an IU too.
-     *
-     * Exception: nextHops -> nextHops
-     *   Because of retransmission issues, it is possible that a second interest
-     *   (with same of higher sequence number) is receive from a next-hop
-     *   interface. In that case, the face remains a next hop.
-     */
-    const NumberSet *nexthops_old = fibEntry_GetNexthops(fibEntry);
-
-    /* We make a copy to be able to send IU _after_ updating next hops */
-    NumberSet *nexthops = numberSet_Create();
-    numberSet_AddSet(nexthops, nexthops_old);
+  mapme_event_t event = MAPME_EVENT_UNDEFINED;
+  if (params->seq > tfib->seq) {
+    INFO(
+        "MAPME IU seq %d > fib_seq %d, updating seq and next hops, new "
+        "nexthop=%d",
+        params->seq, tfib->seq, ingress_id);
+    /* This has to be done first to allow processing ack */
+    // XXX this should even be done before sending ack, as in VPP.
+    tfib->seq = params->seq;
 
-    /* We are considering : * -> nextHops
-     *
-     * If inFace was a previous hop, we need to cancel the timer and remove
-     * the entry. Also, the face should be added to next hops.
+    /*
+     * Move nexthops to TFIB... but ingress_id that lands in nexthops
      *
-     * Optimization : nextHops -> nextHops
-     *  - no next hop to add
-     *  - we know that inFace was not a previous hop since it was a next hop and
-     *  this forms a partition. No need for a search
-     */
-
-    INFO(mapme, "[MAP-Me]   - (3/3) next hops ~~> prev hops");
-    mapmeTFIB_Remove(mapme, TFIB(fibEntry), conn_in_id);
+     * This could might optimized for situations where nothing changes, but
+     * this is very unlikely if not impossible...
+     * */
+    unsigned prevhop;
+    nexthops_foreach(&entry->nexthops, prevhop,
+                     { nexthops_add(&tfib->nexthops, prevhop); });
+    nexthops_remove(&tfib->nexthops, ingress_id);
+    nexthops_clear(&entry->nexthops);
+    nexthops_add(&entry->nexthops, ingress_id);
 
-    /* Remove all next hops */
-    for (size_t k = 0; k < numberSet_Length(nexthops); k++) {
-      unsigned conn_id = numberSet_GetItem(nexthops, k);
-      INFO(mapme, "[MAP-Me]   - Replaced next hops by connection %d", conn_id);
-      fibEntry_RemoveNexthopByConnectionId(fibEntry, conn_id);
-    }
-    fibEntry_AddNexthop(fibEntry, conn_in_id);
-
-    INFO(mapme, "[MAP-Me]   - (2/3) processing next hops");
-    bool complete = true;
-    for (size_t k = 0; k < numberSet_Length(nexthops); k++) {
-      unsigned conn_id = numberSet_GetItem(nexthops, k);
-      INFO(mapme, " - Next hop connection %d", conn_id);
-      if (conn_id == conn_in_id) {
-        INFO(mapme, "   . Ignored this next hop since equal to ingress face");
-        continue;
-      }
+    event = MAPME_EVENT_NH_SET;
 
-      INFO(mapme, "[MAP-Me]   - Sending IU on current next hop connection %d",
-           conn_id);
-      mapme_setFacePending(mapme, fibEntry_GetPrefix(fibEntry), fibEntry,
-                           conn_id, send, false, false, 0);
-      complete = false;
-    }
+    // XXX tell things are complete if we have no IU to send
 
-    /*
-     * The update is completed when the IU could not be sent to any
-     * other next hop.
-     */
-    if (complete) INFO(mapme, "[MAP-Me]   - Update completed !");
-
-    numberSet_Release(&nexthops);
-
-  } else if (seq == fibSeq) {
+  } else if (params->seq == tfib->seq) {
     /*
      * Multipath, multihoming, multiple producers or duplicate interest
      *
@@ -873,142 +905,83 @@ static bool mapme_onSpecialInterest(const MapMe *mapme,
      * producer and that we received back our own IU. In that case, we just
      * need to Ack and ignore it.
      */
-#if 0
-    if (mapme_hasLocalNextHops(mapme, fibEntry)) {
-      INFO(mapme, "[MAP-Me]   - Received original interest... Update complete");
-      return true;
-    }
-#endif
+    DEBUG("params.seq %d == fib_seq %d, adding nethop %d", params->seq,
+          tfib->seq, ingress_id);
+
+    /* Move ingress to nexthops (and eventually remove it from TFIB) */
+    nexthops_add(&entry->nexthops, ingress_id);
+    nexthops_remove(&tfib->nexthops, ingress_id);
 
-    INFO(mapme, "[MAP-Me]   - Adding multipath next hop on connection %d",
-         conn_in_id);
-    fibEntry_AddNexthop(fibEntry, conn_in_id);
+    event = MAPME_EVENT_NH_ADD;
 
-  } else {  // seq < fibSeq
+  } else {  // params->seq < tfib->seq
     /*
      * Face is propagating outdated information, we can just
      * consider it as a prevHops. Send the special interest backwards with
      * the new sequence number to reconciliate this outdated part of the
      * arborescence.
      */
-    INFO(
-        mapme,
-        "[MAP-Me]   - Update interest %d -> %d sent backwards on connection %d",
-        seq, fibSeq, conn_in_id);
-    mapme_setFacePending(mapme, fibEntry_GetPrefix(fibEntry), fibEntry,
-                         conn_in_id, send, false, false, 0);
-  }
-
-  return true;
-}
-
-void mapme_onSpecialInterestAck(const MapMe *mapme, const uint8_t *msgBuffer,
-                                unsigned conn_in_id, hicn_prefix_t *prefix,
-                                mapme_params_t *params) {
-  INFO(mapme, "[MAP-Me] Receive IU/IN Ack on connection %d", conn_in_id);
+    if (nexthops_contains(&entry->nexthops, ingress_id)) {
+      INFO("Ignored seq %d < fib_seq %d from current nexthop on face %d",
+           params->seq, tfib->seq, ingress_id);
+      return;
+    } else {
+      DEBUG("Received seq %d < fib_seq %d, sending backwards on face %d",
+            params->seq, tfib->seq, ingress_id);
+      nexthops_add(&tfib->nexthops, ingress_id);
+    }
 
-  Name * name =
-      name_CreateFromPacket(msgBuffer, MessagePacketType_ContentObject);
-  name_setLen((Name*) name, prefix->len);
-  char * name_str = name_ToString(name);
-  INFO(mapme, "[MAP-Me] Received ack for name prefix=%s seq=%d on conn id=%d",
-          name_str, params->seq, conn_in_id);
-  free(name_str);
+    event = MAPME_EVENT_PH_ADD;
+  }
 
-  FIB *fib = forwarder_getFib(mapme->forwarder);
-  FibEntry *fibEntry = fib_Contains(fib, name);
+  /* Don't trigger events for notification unless we need to send interests
+   * backwards */
+  if ((params->type != UPDATE) && (event != MAPME_EVENT_PH_ADD)) return;
 
-  name_Release(&name);
+  mapme_on_event(mapme, event, entry, ingress_id);
+}
 
-  if (!fibEntry) {
+static void mapme_on_data(mapme_t *mapme, msgbuf_t *msgbuf, unsigned ingress_id,
+                          hicn_prefix_t *prefix, mapme_params_t *params) {
+  INFO("Receive IU/IN Ack on connection %d", ingress_id);
+
+  uint8_t *packet = msgbuf_get_packet(msgbuf);
+  name_create_from_data(packet, msgbuf_get_name(msgbuf));
+  Name name = EMPTY_NAME;
+  name_Copy(msgbuf_get_name(msgbuf), &name);
+  name_setLen(&name, prefix->len);
+
+  WITH_DEBUG({
+    char *name_str = name_ToString(&name);
+    DEBUG("Received ack for name prefix=%s seq=%d on conn id=%d", name_str,
+          params->seq, ingress_id);
+    free(name_str);
+  })
+
+  const fib_t *fib = forwarder_get_fib(mapme->forwarder);
+  fib_entry_t *entry = fib_contains(fib, &name);
+  if (!entry) {
+    INFO("Ignored ACK with no corresponding FIB entry");
     return;
   }
-  parcAssertNotNull(fibEntry,
-                    "No corresponding FIB entry for name contained in IU Ack");
-
-  /* Test if the latest pending update has been ack'ed, otherwise just ignore */
-  seq_t seq = params->seq;
-  if (seq != INVALID_SEQ) {
-    seq_t fibSeq = TFIB(fibEntry)->seq;
-
-    if (seq < fibSeq) {
-
-        /* If we receive an old ack:
-         *  - either the connection is still a next hop and we have to ignore
-         *  the ack until we receive a further update with higher seqno
-         *  - or the connection is no more to be informed and the ack is
-         *  sufficient and we can remove future retransmissions
-         */
-
-      INFO(mapme,
-           "[MAP-Me]   - Ignored special interest Ack with seq=%u, expected %u",
-           seq, fibSeq);
-      return;
-    }
-  }
+  mapme_tfib_t *tfib = TFIB(entry);
 
   /*
-   * Ignore the Ack if no TFIB is present, or it has no corresponding entry
-   * with the ingress face.
-   * Note: previously, we were creating the TFIB entry
+   * As we always retransmit IU with the latest seq, we are not interested in
+   * ACKs with inferior seq
    */
-  if (!TFIB(fibEntry)) {
-    INFO(mapme, "[MAP-Me]   - Ignored ACK for prefix with no TFIB entry");
-    return;
-  }
-
-  PARCEventTimer *timer =
-      (PARCEventTimer *)mapmeTFIB_Get(TFIB(fibEntry), conn_in_id);
-  if (!timer) {
-    INFO(mapme,
-         "[MAP-Me]   - Ignored ACK for prefix not having the Connection in "
-         "TFIB entry. Possible duplicate ?");
+  if (params->seq < tfib->seq) {
+    INFO("Ignored ACK with seq %d < %d", params->seq, tfib->seq);
     return;
   }
 
-  /* Stop timer and remove entry from TFIB */
-  mapmeTFIB_Remove(mapme, TFIB(fibEntry), conn_in_id);
-
-  INFO(mapme, "[MAP-Me]   - Removing TFIB entry for ack on connection %d",
-       conn_in_id);
+  nexthops_remove(&tfib->nexthops, ingress_id);
+  mapme_on_event(mapme, MAPME_EVENT_PH_DEL, entry, ingress_id);
 
   /* We need to update the timestamp only for IU Acks, not for IN Acks */
   if (params->type == UPDATE_ACK) {
-    INFO(mapme, "[MAP-Me]   - Updating LastAckedUpdate");
-    TFIB(fibEntry)->lastAckedUpdate = forwarder_GetTicks(mapme->forwarder);
-  }
-}
-
-/*-----------------------------------------------------------------------------
- * Overloaded functions
- *----------------------------------------------------------------------------*/
-
-/*
- * @abstract returns where to forward a normal interests(nexthops) defined by
- * mapme, it also set the sequnence number properly if needed
- */
-
-/******************************************************************************
- * Public functions (exposed in the .h)
- ******************************************************************************/
-
-/*
- * Returns true iif the message corresponds to a MAP-Me packet
- */
-bool mapme_isMapMe(const uint8_t *packet) {
-  hicn_mapme_header_t * mapme = (hicn_mapme_header_t*)packet;
-
-  switch(HICN_IP_VERSION(packet)) {
-    case 4:
-      if (mapme->v4.ip.protocol != IPPROTO_ICMP)
-        return false;
-      return HICN_IS_MAPME(mapme->v4.icmp_rd.type, mapme->v4.icmp_rd.code);
-    case 6:
-      if (mapme->v6.ip.nxt != IPPROTO_ICMPV6)
-        return false;
-      return HICN_IS_MAPME(mapme->v6.icmp_rd.type, mapme->v6.icmp_rd.code);
-    default:
-      return false;
+    INFO("  - Updating LastAckedUpdate");
+    tfib->last_acked_update = ticks_now();
   }
 }
 
@@ -1023,25 +996,68 @@ bool mapme_isMapMe(const uint8_t *packet) {
  * MAP-Me (eg. ICMP packets) and return higher level messages that can be
  * processed by MAP-Me core.
  */
-void mapme_Process(const MapMe *mapme, const uint8_t *msgBuffer,
-                   unsigned conn_id) {
+void mapme_process(mapme_t *mapme, msgbuf_t *msgbuf) {
+  if (mapme->enabled == false) {
+    WARN("MAP-Me is NOT enabled");
+    return;
+  }
+
   hicn_prefix_t prefix;
   mapme_params_t params;
-  hicn_mapme_parse_packet(msgBuffer, &prefix, &params);
 
+  uint8_t *packet = msgbuf_get_packet(msgbuf);
+  unsigned conn_id = msgbuf_get_connection_id(msgbuf);
+
+  int rc = hicn_mapme_parse_packet(packet, &prefix, &params);
+  if (rc < 0) return;
+
+  // XXX TYPE STR
+  DEBUG("Received interest type: %d seq: %d len:%d", params.type, params.seq,
+        prefix.len);
+
+  // XXX RENAME TYPES
   switch (params.type) {
     case UPDATE:
     case NOTIFICATION:
-      mapme_onSpecialInterest(mapme, msgBuffer, conn_id, &prefix, &params);
+      mapme_on_interest(mapme, msgbuf, conn_id, &prefix, &params);
       break;
     case UPDATE_ACK:
     case NOTIFICATION_ACK:
-      mapme_onSpecialInterestAck(mapme, msgBuffer, conn_id, &prefix, &params);
+      mapme_on_data(mapme, msgbuf, conn_id, &prefix, &params);
       break;
     default:
-      ERR(mapme, "[MAP-Me] Unknown message");
+      ERROR("Unknown message");
       break;
   }
 }
 
+/*
+ * Returns true iif the message corresponds to a MAP-Me packet
+ */
+bool mapme_match_packet(const uint8_t *packet) {
+  hicn_mapme_header_t *mapme = (hicn_mapme_header_t *)packet;
+
+  switch (HICN_IP_VERSION(packet)) {
+    case 4:
+      if (mapme->v4.ip.protocol != IPPROTO_ICMP) return false;
+      return HICN_IS_MAPME(mapme->v4.icmp_rd.type, mapme->v4.icmp_rd.code);
+    case 6:
+      if (mapme->v6.ip.nxt != IPPROTO_ICMPV6) return false;
+      return HICN_IS_MAPME(mapme->v6.icmp_rd.type, mapme->v6.icmp_rd.code);
+    default:
+      return false;
+  }
+}
+
+void mapme_set_enable(mapme_t *mapme, bool enable) { mapme->enabled = enable; }
+void mapme_set_discovery(mapme_t *mapme, bool enable) {
+  mapme->discovery = enable;
+}
+void mapme_set_timescale(mapme_t *mapme, uint32_t time) {
+  mapme->timescale = time;
+}
+void mapme_set_retransmision(mapme_t *mapme, uint32_t time) {
+  mapme->retx = time;
+}
+
 #endif /* WITH_MAPME */
diff --git a/hicn-light/src/hicn/core/mapme.h b/hicn-light/src/hicn/core/mapme.h
index 72f8d536a..8c2ca477f 100644
--- a/hicn-light/src/hicn/core/mapme.h
+++ b/hicn-light/src/hicn/core/mapme.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -26,29 +26,30 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+#include <hicn/ctrl/hicn-light-ng.h>
 #include <hicn/hicn.h>
-#include <hicn/core/forwarder.h>
-#include <hicn/core/connection.h>
-#include <hicn/utils/commands.h>
 
-struct mapme;
-typedef struct mapme MapMe;
+#include "connection.h"
+#include "fib_entry.h"
+#include "msgbuf.h"
+
+typedef struct mapme_s mapme_t;
 
 /**
  * @function mapme_create
  * @abstract Initializes MAP-Me state in the forwarder.
  * @return bool - Boolean informing about the success of MAP-Me initialization.
  */
-bool mapme_create(MapMe **mapme, Forwarder *Forwarder);
+mapme_t *mapme_create(void *Forwarder);
 
 /**
  * @function mapme_free
  * @abstract Free MAP-Me state in the forwarder.
  */
-void mapme_free(MapMe *mapme);
+void mapme_free(mapme_t *mapme);
 
 /**
- * @function messageHandler_isMapMe
+ * @function messageHandler_is_mapme
  * @abstract Identifies MAP-Me messages
  * @discussion This function can be used by the forwarder to dispatch MAP-Me
  * 	message to the appropriate processing function. Ideally this would be
@@ -56,48 +57,53 @@ void mapme_free(MapMe *mapme);
  * @param [in] msgBuffer - The buffer to match
  * @return A boolean indicating whether message is a MAP-Me control message.
  */
-bool mapme_isMapMe(const uint8_t *msgBuffer);
+bool mapme_match_packet(const uint8_t *msgBuffer);
 
 /**
- * @function mapme_handleMapMeMessage
+ * @function mapme_handlemapme_tMessage
  * @abstract Process a MAP-Me message.
  * @param [in] mapme - Pointer to the MAP-Me data structure.
  * @param [in] message - MAP-Me buffer
  * @param [in] conn_id - Ingress connection id
  */
-void mapme_Process(const MapMe *mapme, const uint8_t *msgBuffer,
-                   unsigned conn_id);
+void mapme_process(mapme_t *mapme, msgbuf_t *msgbuf);
 
+/* mapme API */
 /**
  * @function mapme_send_updates
- * @abstract Trigger (if needed) the update for specified FIB entry and nexthops
+ * @abstract sends an update to all adjacencies. Used for face
+ * add/delete/changes (priority.tag) and policy
  * @param [in] mapme - Pointer to the MAP-Me data structure.
- * @param [in] fibEntry - The FIB entry to consider
- * @param [in] nexthops - NumberSet holding the next hops on which to send the
- * update.
+ * @param [in] fib_entry - The FIB entry to consider
  */
-void mapme_send_updates(const MapMe * mapme, FibEntry * fibEntry, const NumberSet * nexthops);
+int mapme_set_all_adjacencies(const mapme_t *mapme, fib_entry_t *entry);
 
 /**
- * @function mapme_send_updates
- * @abstract Trigger the update for specified FIB entry and nexthops, only if needed
+ * @function mapme_set_adjacencies
+ * @abstract sends an update to the specified adjacencies. Used by forwarding
+ * strategies
  * @param [in] mapme - Pointer to the MAP-Me data structure.
- * @param [in] fibEntry - The FIB entry to consider
- * @param [in] nexthops - NumberSet holding the next hops on which to send the
- * update.
+ * @param [in] fib_entry - The FIB entry to consider
+ * @param [in] nexthops - next hops on which to send the update.
  */
-void mapme_maybe_send_updates(const MapMe * mapme, FibEntry * fibEntry, const NumberSet * nexthops);
+int mapme_set_adjacencies(const mapme_t *mapme, fib_entry_t *entry,
+                          nexthops_t *nexthops, bool force);
 
 /**
- * @function mapme_reconsiderFibEntry
- * @abstract Process a fib entry for changes that might trigger new updates
+ * @function mapme_update_adjacencies
+ * @abstract sends an update on previuos adjacencies. Used for IU forwarding,
+ * NAT and timeouts
+ * strategies
  * @param [in] mapme - Pointer to the MAP-Me data structure.
- * @param [in] fibEntry - The FIB entry to consider
+ * @param [in] fib_entry - The FIB entry to consider
+ * @param [in] inc_iu_seq - if true, the seq number of the tfib/mapme iu will be
+ * increased by one
  */
-void mapme_reconsiderFibEntry(const MapMe *mapme, FibEntry * fibEntry);
+int mapme_update_adjacencies(const mapme_t *mapme, fib_entry_t *entry,
+                             bool inc_iu_seq);
 
 /**
- * @function mapme_onConnectionEvent
+ * @function mapme_on_connection_event
  * @abstract Callback following the addition of the face though the control
  * protocol.
  * @discussion This callback triggers the sending of control packets by MAP-Me.
@@ -105,19 +111,21 @@ void mapme_reconsiderFibEntry(const MapMe *mapme, FibEntry * fibEntry);
  * @param [in] conn - The newly added connection.
  * @param [in] event - Connection event
  */
-void mapme_onConnectionEvent(const MapMe *mapme, const Connection *conn, connection_event_t event);
+void mapme_on_connection_event(const mapme_t *mapme, const connection_t *conn,
+                               connection_event_t event);
 
 /**
- * @function mapme_getNextHops
+ * @function mapme_get_nexthops
  * @abstract return the nexthops to forward interests defined by mapme, it
  *   covers also the case where local discovery mechanisms are trriggered.
  */
-NumberSet *mapme_getNextHops(const MapMe *mapme, FibEntry *fibEntry,
-                             const Message *interest);
-
-hicn_mapme_type_t mapme_PktType_To_LibHicnPktType(MessagePacketType type);
+// nexthops_t * mapme_get_nexthops(const mapme_t *mapme, fib_entry_t *fib_entry,
+//                              const msgbuf_t *interest);
 
-MessagePacketType mapme_LibHicnPktType_To_PktType(hicn_mapme_type_t type);
+void mapme_set_enable(mapme_t *mapme, bool enable);
+void mapme_set_discovery(mapme_t *mapme, bool enable);
+void mapme_set_timescale(mapme_t *mapme, uint32_t time);
+void mapme_set_retransmision(mapme_t *mapme, uint32_t time);
 
 #endif /* WITH_MAPME */
 
diff --git a/hicn-light/src/hicn/core/message.c b/hicn-light/src/hicn/core/message.c
deleted file mode 100644
index c28938320..000000000
--- a/hicn-light/src/hicn/core/message.c
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
- * 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 <errno.h>
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <hicn/core/forwarder.h>
-#include <hicn/core/message.h>
-#include <hicn/core/wldr.h>
-
-#include <hicn/core/messageHandler.h>
-
-#include <parc/algol/parc_Hash.h>
-#include <parc/algol/parc_Memory.h>
-#include <hicn/core/messagePacketType.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_EventBuffer.h>
-
-struct message {
-  Logger *logger;
-
-  Ticks receiveTime;
-  unsigned ingressConnectionId;
-
-  Name *name;
-
-  uint8_t *messageHead;
-
-  unsigned length;
-
-  uint8_t packetType;
-
-  unsigned refcount;
-};
-
-Message *message_Acquire(const Message *message) {
-  Message *copy = (Message *)message;
-  copy->refcount++;
-  return copy;
-}
-
-Message *message_CreateFromEventBuffer(PARCEventBuffer *data, size_t dataLength,
-                                       unsigned ingressConnectionId,
-                                       Ticks receiveTime, Logger *logger) {
-  // used by applications, we can get only interest or data packets
-  Message *message = parcMemory_AllocateAndClear(sizeof(Message));
-  parcAssertNotNull(message, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Message));
-
-  message->logger = logger_Acquire(logger);
-  message->receiveTime = receiveTime;
-  message->ingressConnectionId = ingressConnectionId;
-  message->length = (unsigned int)dataLength;
-
-  message->messageHead = parcMemory_AllocateAndClear(dataLength);
-  parcAssertNotNull(message->messageHead,
-                    "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    dataLength);
-
-  // copy the data because *data is destroyed in the connection.
-  int res = parcEventBuffer_Read(data, message->messageHead, dataLength);
-  if (res == -1) {
-    return NULL;
-  }
-
-  if (messageHandler_IsInterest(message->messageHead)) {
-    message->packetType = MessagePacketType_Interest;
-  } else if (messageHandler_IsData(message->messageHead)) {
-    message->packetType = MessagePacketType_ContentObject;
-  } else {
-    printf("Got a packet that is not a data nor an interest, drop it!\n");
-    return NULL;
-  }
-  message->name =
-      name_CreateFromPacket(message->messageHead, message->packetType);
-
-  message->refcount = 1;
-
-  return message;
-}
-
-Message *message_CreateFromByteArray(unsigned connid, uint8_t *pckt,
-                                     MessagePacketType type, Ticks receiveTime,
-                                     Logger *logger) {
-  Message *message = parcMemory_AllocateAndClear(sizeof(Message));
-  parcAssertNotNull(message, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Message));
-
-  message->logger = logger_Acquire(logger);
-  message->receiveTime = receiveTime;
-  message->ingressConnectionId = connid;
-  message->messageHead = pckt;
-  message->length = messageHandler_GetTotalPacketLength(pckt);
-  message->packetType = type;
-
-  if (messageHandler_IsWldrNotification(pckt)) {
-    message->name = NULL;
-  } else {
-    message->name =
-        name_CreateFromPacket(message->messageHead, message->packetType);
-  }
-
-  message->refcount = 1;
-
-  return message;
-}
-
-void message_Release(Message **messagePtr) {
-  parcAssertNotNull(messagePtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*messagePtr,
-                    "Parameter must dereference to non-null pointer");
-
-  Message *message = *messagePtr;
-  parcAssertTrue(
-      message->refcount > 0,
-      "Invalid state: message_Release called on message with 0 references %p",
-      (void *)message);
-
-  message->refcount--;
-  if (message->refcount == 0) {
-    if (logger_IsLoggable(message->logger, LoggerFacility_Message,
-                          PARCLogLevel_Debug)) {
-      logger_Log(message->logger, LoggerFacility_Message, PARCLogLevel_Debug,
-                 __func__, "Message %p destroyed", (void *)message);
-    }
-
-    logger_Release(&message->logger);
-    if (message->name != NULL) name_Release(&message->name);
-    parcMemory_Deallocate((void **)&message->messageHead);
-    parcMemory_Deallocate((void **)&message);
-  }
-  *messagePtr = NULL;
-}
-
-bool message_Write(PARCEventQueue *parcEventQueue, const Message *message) {
-  parcAssertNotNull(message, "Message parameter must be non-null");
-  parcAssertNotNull(parcEventQueue, "Buffer parameter must be non-null");
-
-  return parcEventQueue_Write(parcEventQueue, message->messageHead,
-                              message_Length(message));
-}
-
-size_t message_Length(const Message *message) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  return message->length;
-}
-
-bool message_HasWldr(const Message *message) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  return messageHandler_HasWldr(message->messageHead);
-}
-
-bool message_IsWldrNotification(const Message *message) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  return messageHandler_IsWldrNotification(message->messageHead);
-}
-
-void message_ResetWldrLabel(Message *message) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  messageHandler_ResetWldrLabel(message->messageHead);
-}
-
-unsigned message_GetWldrLabel(const Message *message) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  return messageHandler_GetWldrLabel(message->messageHead);
-}
-
-unsigned message_GetWldrExpectedLabel(const Message *message) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  return messageHandler_GetExpectedWldrLabel(message->messageHead);
-}
-
-unsigned message_GetWldrLastReceived(const Message *message) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  return messageHandler_GetWldrLastReceived(message->messageHead);
-}
-
-void message_SetWldrLabel(Message *message, uint16_t label) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  messageHandler_SetWldrLabel(message->messageHead, label);
-}
-
-Message *message_CreateWldrNotification(Message *original, uint16_t expected,
-                                        uint16_t lastReceived) {
-  parcAssertNotNull(original, "Parameter original must be non-null");
-  Message *message = parcMemory_AllocateAndClear(sizeof(Message));
-  parcAssertNotNull(message, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Message));
-  message->receiveTime = original->receiveTime;
-  message->ingressConnectionId = original->ingressConnectionId;
-  message->refcount = 1;
-  message->logger = logger_Acquire(original->logger);
-
-  message->length = (unsigned int)messageHandler_GetICMPPacketSize(
-      messageHandler_GetIPPacketType(original->messageHead));
-  message->messageHead = parcMemory_AllocateAndClear(message->length);
-  parcAssertNotNull(message->messageHead,
-                    "parcMemory_AllocateAndClear returned NULL");
-
-  message->packetType = MessagePacketType_WldrNotification;
-  message->name = NULL;  // nobody will use the name in a notification packet,
-                         // so we can simply set it to NULL
-
-  // set notification stuff.
-  messageHandler_SetWldrNotification(
-      message->messageHead, original->messageHead, expected, lastReceived);
-  return message;
-}
-
-unsigned message_GetIngressConnectionId(const Message *message) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  return message->ingressConnectionId;
-}
-
-void message_SetIngressConnectionId(Message *message, unsigned conn) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  message->ingressConnectionId = conn;
-}
-
-Ticks message_GetReceiveTime(const Message *message) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  return message->receiveTime;
-}
-
-uint32_t message_GetPathLabel(const Message *message) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  return messageHandler_GetPathLabel(message->messageHead);
-}
-
-void message_SetPathLabel(Message *message, uint32_t label) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  messageHandler_SetPathLabel(message->messageHead,
-        messageHandler_GetPathLabel(message->messageHead), label);
-}
-
-void message_UpdatePathLabel(Message *message, uint8_t outFace) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  messageHandler_UpdatePathLabel(message->messageHead, outFace);
-}
-
-void message_ResetPathLabel(Message *message) {
-  parcAssertNotNull(message, "Parameter must be non-null");
-  messageHandler_ResetPathLabel(message->messageHead);
-}
-
-MessagePacketType message_GetType(const Message *message) {
-  parcAssertNotNull(message, "Parameter message must be non-null");
-  return message->packetType;
-}
-
-Name *message_GetName(const Message *message) {
-  parcAssertNotNull(message, "Parameter message must be non-null");
-  return message->name;
-}
-
-bool message_HasInterestLifetime(const Message *message) {
-  parcAssertNotNull(message, "Parameter message must be non-null");
-  return messageHandler_HasInterestLifetime(message->messageHead);
-}
-
-uint64_t message_GetInterestLifetimeTicks(const Message *message) {
-  parcAssertNotNull(message, "Parameter message must be non-null");
-  uint64_t lifetime = messageHandler_GetInterestLifetime(message->messageHead);
-  return forwarder_NanosToTicks(lifetime * 1000000ULL);
-}
-
-bool message_HasContentExpiryTime(const Message *message) {
-  parcAssertNotNull(message, "Parameter message must be non-null");
-  return messageHandler_HasContentExpiryTime(message->messageHead);
-}
-
-uint64_t message_GetContentExpiryTimeTicks(const Message *message) {
-  parcAssertNotNull(message, "Parameter message must be non-null");
-  uint64_t expire = messageHandler_GetContentExpiryTime(message->messageHead);
-  if(expire == 0)
-    return message->receiveTime;
-  return message->receiveTime + forwarder_NanosToTicks(expire * 1000000ULL);
-}
-
-const uint8_t *message_FixedHeader(const Message *message) {
-  parcAssertNotNull(message, "Parameter message must be non-null");
-  return message->messageHead;
-}
diff --git a/hicn-light/src/hicn/core/message.h b/hicn-light/src/hicn/core/message.h
deleted file mode 100644
index e77dab2b5..000000000
--- a/hicn-light/src/hicn/core/message.h
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * 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 message.h
- * @brief Message is the unit of forwarding, i.e. the packets being switched
- *
- */
-#ifndef message_h
-#define message_h
-
-#include <hicn/hicn-light/config.h>
-#include <hicn/core/logger.h>
-#include <hicn/core/messagePacketType.h>
-#include <hicn/core/streamBuffer.h>
-
-#include <hicn/core/name.h>
-
-#include <parc/algol/parc_EventBuffer.h>
-#include <parc/algol/parc_EventQueue.h>
-
-#include <hicn/utils/address.h>
-
-#include <hicn/core/ticks.h>
-
-struct message;
-typedef struct message Message;
-
-/**
- * @function message_CreateFromBuffer
- * @abstract Takes ownership of the input buffer, which comprises one complete
- * message
- */
-
-Message *message_CreateFromEventBuffer(PARCEventBuffer *data, size_t dataLength,
-                                       unsigned ingressConnectionId,
-                                       Ticks receiveTime, Logger *logger);
-
-/**
- * @function message_CreateFromByteArray
- * @abstract create a message from a byte array
- */
-
-Message *message_CreateFromByteArray(unsigned connid, uint8_t *pckt,
-                                     MessagePacketType type, Ticks receiveTime,
-                                     Logger *logger);
-
-/**
- * @function message_Copy
- * @abstract Get a reference counted copy
- */
-
-Message *message_Acquire(const Message *message);
-
-/**
- * Releases the message and frees the memory
- */
-void message_Release(Message **messagePtr);
-
-/**
- * Writes the message to the queue
- */
-
-bool message_Write(PARCEventQueue *parcEventQueue, const Message *message);
-
-/**
- * Returns the total byte length of the message
- */
-size_t message_Length(const Message *message);
-
-bool message_HasWldr(const Message *message);
-
-bool message_IsWldrNotification(const Message *message);
-
-void message_ResetWldrLabel(Message *message);
-
-unsigned message_GetWldrLabel(const Message *message);
-
-unsigned message_GetWldrExpectedLabel(const Message *message);
-
-unsigned message_GetWldrLastReceived(const Message *message);
-
-void message_SetWldrLabel(Message *message, uint16_t label);
-
-Message *message_CreateWldrNotification(Message *original, uint16_t expected,
-                                        uint16_t lastReceived);
-/**
- * Returns the connection id of the packet input
- */
-unsigned message_GetIngressConnectionId(const Message *message);
-
-void message_SetIngressConnectionId(Message *message, unsigned conn);
-
-/**
- * Returns the receive time (in router ticks) of the message
- */
-Ticks message_GetReceiveTime(const Message *message);
-
-/**
- * Returns the PacketType
- */
-MessagePacketType message_GetType(const Message *message);
-
-uint32_t message_GetPathLabel(const Message *message);
-void message_SetPathLabel(Message *message, uint32_t label);
-void message_UpdatePathLabel(Message *message, uint8_t outFace);
-void message_ResetPathLabel(Message *message);
-
-// ===========================================================
-// Accessors used to index and compare messages
-
-/**
- * @function message_GetName
- * @abstract The name in the message
- * @discussion
- *   The name of the Interest or Content Object.  If the caller will store the
- *   name, he should make a reference counted copy.
- * @return The name as stored in the message object.
- */
-
-Name *message_GetName(const Message *message);
-
-/**
- * Determines if the message has an Interest Lifetime parameter
- *
- * @param [in] message An allocated and parsed Message
- *
- * @retval true If an Intrerest Lifetime field exists
- * @retval false If no Interest Lifetime exists
- */
-
-bool message_HasInterestLifetime(const Message *message);
-
-/**
- * Returns the Interest lifetime in hicn-light Ticks
- *
- * the interest expires after now + returned ticks
- *
- * @param [in] message An allocated and parsed Message
- *
- * @retval integer Lifetime in forwarder Ticks
- *
- */
-
-uint64_t message_GetInterestLifetimeTicks(const Message *message);
-
-/**
- * checks if the expiry time is set inside the content object
- */
-bool message_HasContentExpiryTime(const Message *message);
-
-/**
- * returns the moment (in hicn-light ticks) when the content object will expire
- */
-uint64_t message_GetContentExpiryTimeTicks(const Message *message);
-
-/**
- * Returns a pointer to the beginning of the FixedHeader
- *
- * @param [in] message An allocated and parsed Message
- *
- * @return non-null The fixed header memory
- * @return null No fixed header or an error
- */
-
-const uint8_t *message_FixedHeader(const Message *message);
-
-#endif  // message_h
diff --git a/hicn-light/src/hicn/core/messageHandler.h b/hicn-light/src/hicn/core/messageHandler.h
index b41c9a7f0..fe26d0579 100644
--- a/hicn-light/src/hicn/core/messageHandler.h
+++ b/hicn-light/src/hicn/core/messageHandler.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,16 +13,17 @@
  * limitations under the License.
  */
 
-#ifndef messageHandler
-#define messageHandler
+#ifndef HICNLIGHT_MESSAGE_HANDLER_H
+#define HICNLIGHT_MESSAGE_HANDLER_H
 
 #include <stdlib.h>
 #ifndef _WIN32
-#include <unistd.h> // close
-#endif
+#include <unistd.h>  // close
+#endif               /* _WIN32 */
 
 #include <hicn/hicn.h>
-#include <hicn/core/messagePacketType.h>
+
+//#include <hicn/core/connection_table.h>
 
 #define H(packet) ((hicn_header_t *)packet)
 #define H6(packet) (H(packet)->v6.ip)
@@ -49,21 +50,21 @@
 #define CONTROL_PORT 9695
 #define HTTP_PORT 8080
 
+#define MIN_PROBE_SUFFIX 0xefffffff
+#define MAX_PROBE_SUFFIX 0xffffffff - 1
+
+// XXX Hardcoded packet format HF_INET6_TCP
+
 #define IPV6_DEFAULT_VERSION 6
 #define IPV6_DEFAULT_TRAFFIC_CLASS 0
 #define IPV6_DEFAULT_FLOW_LABEL 0
 
-#define expected_lbl wldr_notification_lbl.expected_lbl
-#define received_lbl wldr_notification_lbl.received_lbl
+//#include <hicn/core/forwarder.h>
 
-#include <hicn/core/forwarder.h>
-
-#ifdef WITH_MAPME
-#include <hicn/core/mapme.h>
-#include <hicn/socket/api.h>
-#endif /* WITH_MAPME */
-
-#define CONNECTION_ID_UNDEFINED -1
+//#ifdef WITH_MAPME
+//#include <hicn/core/mapme.h>
+//#include <hicn/socket/api.h>
+//#endif /* WITH_MAPME */
 
 #define BFD_PORT 3784
 
@@ -157,6 +158,7 @@ static inline size_t messageHandler_GetIPHeaderLength(unsigned ipVersion) {
     return 0;
 }
 
+#if 0
 static inline bool messageHandler_IsValidHicnPacket(const uint8_t *message) {
   uint8_t version = messageHandler_GetIPPacketType(message);
   if (version == IPv6_TYPE || version == IPv4_TYPE) {
@@ -164,6 +166,7 @@ static inline bool messageHandler_IsValidHicnPacket(const uint8_t *message) {
   }
   return false;
 }
+#endif
 
 static inline uint8_t messageHandler_NextHeaderType(const uint8_t *message) {
   switch (messageHandler_GetIPPacketType(message)) {
@@ -176,155 +179,6 @@ static inline uint8_t messageHandler_NextHeaderType(const uint8_t *message) {
   }
 }
 
-/* Forward declarations */
-static inline void * messageHandler_GetSource(const uint8_t *message);
-static inline void *messageHandler_GetDestination(const uint8_t *message);
-
-static const
-AddressPair *
-_createRecvAddressPairFromPacket(const uint8_t *msgBuffer) {
-  Address *packetSrcAddr = NULL; /* This one is in the packet */
-  Address *localAddr = NULL; /* This one is to be determined */
-
-  if (messageHandler_GetIPPacketType(msgBuffer) == IPv6_TYPE) {
-    struct sockaddr_in6 addr_in6;
-    addr_in6.sin6_family = AF_INET6;
-    addr_in6.sin6_port = htons(1234);
-    addr_in6.sin6_flowinfo = 0;
-    addr_in6.sin6_scope_id = 0;
-    memcpy(&addr_in6.sin6_addr,
-           (struct in6_addr *)messageHandler_GetSource(msgBuffer), 16);
-    packetSrcAddr = addressCreateFromInet6(&addr_in6);
-
-    /* We now determine the local address used to reach the packet src address */
-    int sock = (int)socket (AF_INET6, SOCK_DGRAM, 0);
-    if (sock < 0)
-      goto ERR;
-
-    struct sockaddr_in6 remote, local;
-    memset(&remote, 0, sizeof(remote));
-    remote.sin6_family = AF_INET6;
-    remote.sin6_addr = addr_in6.sin6_addr;
-    remote.sin6_port = htons(1234);
-
-    socklen_t locallen = sizeof(local);
-    if (connect(sock, (const struct sockaddr*)&remote, sizeof(remote)) == -1)
-      goto ERR;
-    if (getsockname(sock, (struct sockaddr*) &local, &locallen) == -1)
-      goto ERR;
-
-    local.sin6_port = htons(1234);
-    localAddr = addressCreateFromInet6(&local);
-
-    close(sock);
-
-  } else if (messageHandler_GetIPPacketType(msgBuffer) == IPv4_TYPE) {
-    struct sockaddr_in addr_in;
-    addr_in.sin_family = AF_INET;
-    addr_in.sin_port = htons(1234);
-    memcpy(&addr_in.sin_addr,
-           (struct in_addr *)messageHandler_GetSource(msgBuffer), 4);
-    packetSrcAddr = addressCreateFromInet(&addr_in);
-
-    /* We now determine the local address used to reach the packet src address */
-
-    int sock = (int)socket (AF_INET, SOCK_DGRAM, 0);
-    if (sock < 0) {
-      perror("Socket error");
-      goto ERR;
-    }
-
-    struct sockaddr_in remote, local;
-    memset(&remote, 0, sizeof(remote));
-    remote.sin_family = AF_INET;
-    remote.sin_addr = addr_in.sin_addr;
-    remote.sin_port = htons(1234);
-
-    socklen_t locallen = sizeof(local);
-    if (connect(sock, (const struct sockaddr*)&remote, sizeof(remote)) == -1)
-      goto ERR;
-    if (getsockname(sock, (struct sockaddr*) &local, &locallen) == -1)
-      goto ERR;
-
-    local.sin_port = htons(1234);
-    localAddr = addressCreateFromInet(&local);
-
-    close(sock);
-  }
-  /* As this is a receive pair, we swap src and dst */
-  return addressPair_Create(localAddr, packetSrcAddr);
-
-ERR:
-  perror("Socket error");
-  return NULL;
-}
-
-/* Main hook handler */
-
-/**
- * \brief Handle incoming messages
- * \param [in] forwarder - Reference to the Forwarder instance
- * \param [in] packet - Packet buffer
- * \param [in] conn_id - A hint on the connection ID on which the packet
- *      was received
- * \return Flag indicating whether the packet matched a hook and was
- *      (successfully or not) processed.
- */
-static inline bool messageHandler_handleHooks(Forwarder * forwarder,
-        const uint8_t * packet, ListenerOps * listener, int fd, AddressPair * pair)
-{
-  bool is_matched = false;
-
-  /* BEGIN Match */
-
-#ifdef WITH_MAPME
-  bool is_mapme = mapme_isMapMe(packet);
-  is_matched |= is_mapme;
-#endif /* WITH_MAPME */
-
-  /* ... */
-
-  /* END Match */
-
-  if (!is_matched)
-    return false;
-
-  /*
-   * Find existing connection or create a new one (we assume all processing
-   * requires a valid connection.
-   */
-
-  if (!pair) {
-    /* The hICN listener does not provide any address pair while UDP does */
-    const AddressPair * pair = _createRecvAddressPairFromPacket(packet);
-    if (!pair)
-      return false;
-  }
-
-  /* Find connection and eventually create it */
-  const Connection * conn = connectionTable_FindByAddressPair(
-        forwarder_GetConnectionTable(forwarder), pair);
-  unsigned conn_id;
-  if (conn == NULL) {
-    conn_id = listener->createConnection(listener, fd, pair);
-  } else {
-    conn_id = connection_GetConnectionId(conn);
-  }
-
-  /* BEGIN Process */
-
-#ifdef WITH_MAPME
-  if (mapme_isMapMe(packet))
-    forwarder_ProcessMapMe(forwarder, packet, conn_id);
-#endif /* WITH_MAPME */
-
-  /* ... */
-
-  /* END Process */
-  parcMemory_Deallocate((void **)&packet);
-  return true;
-}
-
 static inline bool messageHandler_IsTCP(const uint8_t *message) {
   if (messageHandler_NextHeaderType(message) != IPPROTO_TCP) return false;
   return true;
@@ -432,7 +286,8 @@ static inline uint16_t messageHandler_GetExpectedWldrLabel(
       return 0;
   }
 
-  return ntohs(((_icmp_wldr_header_t *)icmp_ptr)->expected_lbl);
+  return ntohs(
+      ((_icmp_wldr_header_t *)icmp_ptr)->wldr_notification_lbl.expected_lbl);
 }
 
 static inline uint16_t messageHandler_GetWldrLastReceived(
@@ -449,7 +304,8 @@ static inline uint16_t messageHandler_GetWldrLastReceived(
       return 0;
   }
 
-  return ntohs(((_icmp_wldr_header_t *)icmp_ptr)->received_lbl);
+  return ntohs(
+      ((_icmp_wldr_header_t *)icmp_ptr)->wldr_notification_lbl.received_lbl);
 }
 
 static inline uint16_t messageHandler_GetWldrLabel(const uint8_t *message) {
@@ -524,6 +380,7 @@ static inline void messageHandler_UpdatePathLabel(uint8_t *message,
   uint32_t pl_new_32bit =
       (uint32_t)((((pl_old_8bit << 1) | (pl_old_8bit >> 7)) ^ outFace) << 24UL);
 
+  // XXX path label should be 8 bits now ?
   messageHandler_SetPathLabel(message, pl_old_32bit, pl_new_32bit);
 }
 
@@ -531,7 +388,7 @@ static inline void messageHandler_ResetPathLabel(uint8_t *message) {
   messageHandler_SetPathLabel(message, messageHandler_GetPathLabel(message), 0);
 }
 
-static inline uint16_t messageHandler_GetInterestLifetime(
+static inline uint32_t messageHandler_GetInterestLifetime(
     const uint8_t *message) {
   if (!messageHandler_IsTCP(message)) return 0;
 
@@ -541,6 +398,24 @@ static inline uint16_t messageHandler_GetInterestLifetime(
   return lifetime;
 }
 
+static inline bool messageHandler_SetInterestLifetime(uint8_t *message,
+                                                      u32 lifetime) {
+  if (!messageHandler_IsTCP(message)) return false;
+
+  int res = hicn_interest_set_lifetime((hicn_header_t *)message, lifetime);
+  if (res < 0) return false;
+  return true;
+}
+
+static inline bool messageHandler_SetDataExpiryTime(uint8_t *message,
+                                                    u32 lifetime) {
+  if (!messageHandler_IsTCP(message)) return false;
+
+  int res = hicn_data_set_expiry_time((hicn_header_t *)message, lifetime);
+  if (res < 0) return false;
+  return true;
+}
+
 static inline bool messageHandler_HasInterestLifetime(const uint8_t *message) {
   if (!messageHandler_IsTCP(message)) return false;
 
@@ -650,7 +525,7 @@ static inline void messageHandler_SetWldrNotification(uint8_t *notification,
     case IPv6_TYPE: {
       *h = (hicn_header_t){.v6 = {
                                .ip =
-                                   {
+                                   (_ipv6_header_t){
                                        .version_class_flow = htonl(
                                            (IPV6_DEFAULT_VERSION << 28) |
                                            (IPV6_DEFAULT_TRAFFIC_CLASS << 20) |
@@ -659,13 +534,17 @@ static inline void messageHandler_SetWldrNotification(uint8_t *notification,
                                        .nxt = IPPROTO_ICMPV6,
                                        .hlim = 5,
                                    },
+                               /*
                                .wldr =
                                    {
                                        .type = ICMP_WLDR_TYPE,
                                        .code = ICMP_WLDR_CODE,
-                                       .expected_lbl = htons(expected),
-                                       .received_lbl = htons(received),
-                                   },
+                                       .wldr_notification_lbl =
+                                           {
+                                               .expected_lbl = htons(expected),
+                                               .received_lbl = htons(received),
+                                           },
+                                   },*/
                            }};
       messageHandler_SetSource_IPv6(
           notification,
@@ -682,56 +561,78 @@ static inline void messageHandler_SetWldrNotification(uint8_t *notification,
   }
 }
 
-static inline uint8_t * messageHandler_CreateProbePacket(hicn_format_t format,
-    uint32_t probe_lifetime){
+static inline void messageHandler_ModifySuffix(uint8_t *packet,
+                                               uint32_t new_suffix) {
+  hicn_format_t format;
+  hicn_name_t name;
+  hicn_packet_get_format((hicn_header_t *)packet, &format);
+  hicn_interest_get_name(format, (hicn_header_t *)packet, &name);
+  hicn_name_set_seq_number(&name, new_suffix);
+  hicn_interest_set_name(format, (hicn_header_t *)packet, &name);
+}
+
+static inline uint8_t *messageHandler_CreateProbePacket(
+    hicn_format_t format, uint32_t probe_lifetime) {
   size_t header_length;
   hicn_packet_get_header_length_from_format(format, &header_length);
 
-  uint8_t *pkt = parcMemory_AllocateAndClear(header_length);
+  uint8_t *pkt = (uint8_t *)calloc(header_length, 1);
 
-  hicn_packet_init_header(format, (hicn_header_t *) pkt);
+  hicn_packet_init_header(format, (hicn_header_t *)pkt);
 
-  hicn_packet_set_dst_port(format, (hicn_header_t *) pkt, BFD_PORT);
-  hicn_interest_set_lifetime ((hicn_header_t *) pkt, probe_lifetime);
+  hicn_packet_set_dst_port(format, (hicn_header_t *)pkt, BFD_PORT);
+  hicn_interest_set_lifetime((hicn_header_t *)pkt, probe_lifetime);
 
   return pkt;
 }
 
-static inline void messageHandler_CreateProbeReply(uint8_t * probe,
-                                                      hicn_format_t format){
-
+static inline void messageHandler_CreateProbeReply(uint8_t *probe,
+                                                   hicn_format_t format) {
   hicn_name_t probe_name;
-  hicn_interest_get_name (format,
-          (const hicn_header_t *) probe, &probe_name);
+  hicn_interest_get_name(format, (const hicn_header_t *)probe, &probe_name);
   ip_address_t probe_locator;
-  hicn_interest_get_locator (format,
-             (const hicn_header_t *) probe, &probe_locator);
+  hicn_interest_get_locator(format, (const hicn_header_t *)probe,
+                            &probe_locator);
 
   uint16_t src_prt;
   uint16_t dst_prt;
-  hicn_packet_get_src_port(format, (const hicn_header_t *) probe, &src_prt);
-  hicn_packet_get_dst_port(format, (const hicn_header_t *) probe, &dst_prt);
-  hicn_packet_set_src_port(format, (hicn_header_t *) probe, dst_prt);
-  hicn_packet_set_dst_port(format, (hicn_header_t *) probe, src_prt);
+  hicn_packet_get_src_port(format, (const hicn_header_t *)probe, &src_prt);
+  hicn_packet_get_dst_port(format, (const hicn_header_t *)probe, &dst_prt);
+  hicn_packet_set_src_port(format, (hicn_header_t *)probe, dst_prt);
+  hicn_packet_set_dst_port(format, (hicn_header_t *)probe, src_prt);
 
-  hicn_data_set_name (format, (hicn_header_t *) probe, &probe_name);
-  hicn_data_set_locator (format, (hicn_header_t *) probe, &probe_locator);
-  hicn_data_set_expiry_time ((hicn_header_t *) probe, 0);
+  hicn_data_set_name(format, (hicn_header_t *)probe, &probe_name);
+  hicn_data_set_locator(format, (hicn_header_t *)probe, &probe_locator);
+  hicn_data_set_expiry_time((hicn_header_t *)probe, 0);
 }
 
-static inline hicn_name_t * messageHandler_CreateProbeName(const ip_prefix_t *address){
-  hicn_name_t * name = parcMemory_AllocateAndClear(sizeof(hicn_name_t));
+static inline hicn_name_t *messageHandler_CreateProbeName(
+    const ip_prefix_t *address) {
+  hicn_name_t *name = (hicn_name_t *)calloc(sizeof(hicn_name_t), 1);
   hicn_name_create_from_ip_prefix(address, 0, name);
   return name;
 }
 
-static inline void messageHandler_SetProbeName(uint8_t * probe, hicn_format_t format,
-                                               hicn_name_t * name, uint32_t seq){
-  hicn_name_set_seq_number (name, seq);
-  hicn_interest_set_name(format, (hicn_header_t *) probe, name);
+static inline void messageHandler_SetProbeName(uint8_t *probe,
+                                               hicn_format_t format,
+                                               hicn_name_t *name,
+                                               uint32_t seq) {
+  hicn_name_set_seq_number(name, seq);
+  hicn_interest_set_name(format, (hicn_header_t *)probe, name);
 }
 
-static inline bool messageHandler_IsAProbe(const uint8_t *packet){
+static inline bool messageHandler_IsAProbe(const uint8_t *packet) {
+  hicn_format_t format;
+  hicn_name_t name;
+  uint32_t seq;
+  hicn_packet_get_format((hicn_header_t *)packet, &format);
+  hicn_data_get_name(format, (hicn_header_t *)packet, &name);
+  hicn_name_get_seq_number(&name, &seq);
+  if (seq >= MIN_PROBE_SUFFIX && seq <= MAX_PROBE_SUFFIX) return true;
+  return false;
+
+#if 0
+  // old probe version
   uint16_t src_prt;
   uint16_t dst_prt;
   hicn_packet_get_src_port (HF_INET6_TCP, (const hicn_header_t *) packet, &src_prt);
@@ -753,6 +654,7 @@ static inline bool messageHandler_IsAProbe(const uint8_t *packet){
   }
 
   return false;
+#endif
 }
 
-#endif  // Metis_metis_MessageHandler
+#endif /* HICNLIGHT_MESSAGE_HANDLER_H */
diff --git a/hicn-light/src/hicn/core/messagePacketType.h b/hicn-light/src/hicn/core/messagePacketType.h
deleted file mode 100644
index dfbb12342..000000000
--- a/hicn-light/src/hicn/core/messagePacketType.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * 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 message_packet_type_h
- * @brief Defines the packet type for a HICN message
- *
- */
-
-#ifndef message_packet_type_h
-#define message_packet_type_h
-
-typedef enum message_type {
-  MessagePacketType_Unknown,
-  MessagePacketType_Interest,
-  MessagePacketType_ContentObject,
-  MessagePacketType_WldrNotification
-} MessagePacketType;
-
-#endif  // message_packet_type_h
diff --git a/hicn-light/src/hicn/strategies/rnd.h b/hicn-light/src/hicn/core/msgbuf.c
index 78fb34758..299b20f9b 100644
--- a/hicn-light/src/hicn/strategies/rnd.h
+++ b/hicn-light/src/hicn/core/msgbuf.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,14 +14,8 @@
  */
 
 /**
- * Forward randomly
+ * \file msgbuf.c
+ * \brief Implementation hICN message buffer
  */
 
-#ifndef rnd_h
-#define rnd_h
-
-#include <hicn/strategies/strategyImpl.h>
-
-StrategyImpl* strategyRnd_Create();
-
-#endif  // rnd_h
+#include "msgbuf.h"
diff --git a/hicn-light/src/hicn/core/msgbuf.h b/hicn-light/src/hicn/core/msgbuf.h
new file mode 100644
index 000000000..e437f1d09
--- /dev/null
+++ b/hicn-light/src/hicn/core/msgbuf.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file msgbuf.h
+ * \brief hICN message buffer
+ */
+
+#ifndef HICNLIGHT_MSGBUF
+#define HICNLIGHT_MSGBUF
+
+#include "name.h"
+#include "ticks.h"
+#include "messageHandler.h"
+#include <hicn/ctrl/hicn-light-ng.h>
+
+#define MTU 1500
+#define INVALID_MSGBUF_ID ~0ul
+
+#define msgbuf_id_is_valid(msgbuf_id) \
+  ((unsigned long)msgbuf_id != INVALID_MSGBUF_ID)
+
+#define foreach_msg_type \
+  _(UNDEFINED)           \
+  _(INTEREST)            \
+  _(DATA)                \
+  _(WLDR_NOTIFICATION)   \
+  _(MAPME)               \
+  _(COMMAND)             \
+  _(N)
+
+typedef enum {
+#define _(x) MSGBUF_TYPE_##x,
+  foreach_msg_type
+#undef _
+} msgbuf_type_t;
+#undef foreach_msg_type
+
+typedef struct {
+  unsigned length;
+  msgbuf_type_t type;
+  unsigned connection_id;
+  Ticks recv_ts;
+  unsigned refs;
+  unsigned path_label;
+  union {
+    /* Interest or data packet */
+    struct {
+      Name name;
+    } id;
+    /* Command packet */
+    struct {
+      command_type_t type;
+    } command;
+  };
+  uint8_t packet[MTU];
+} msgbuf_t;
+
+#define msgbuf_get_name(M) (&((M)->id.name))
+#define msgbuf_get_connection_id(M) ((M)->connection_id)
+#define msgbuf_get_type(M) ((M)->type)
+#define msgbuf_has_wldr(M) (messageHandler_HasWldr((M)->packet))
+#define msgbuf_get_len(M) ((M)->length)
+#define msgbuf_get_packet(M) ((M)->packet)
+#define msgbuf_get_command_type(M) ((M)->command.type)
+
+// XXX TODO EXPLAIN THE CONSTANT
+#define msgbuf_get_lifetime(M) \
+  (NSEC_TO_TICKS(messageHandler_GetInterestLifetime((M)->packet) * 1000000ULL))
+
+// Lifetimes/expiry times in milliseconds
+#define msgbuf_get_interest_lifetime(M) \
+  (messageHandler_GetInterestLifetime((M)->packet))
+#define msgbuf_get_data_expiry_time(M) \
+  (messageHandler_GetContentExpiryTime((M)->packet))
+
+static inline bool msgbuf_set_interest_lifetime(msgbuf_t *msgbuf,
+                                                u32 lifetime) {
+  return messageHandler_SetInterestLifetime(msgbuf->packet, lifetime);
+}
+static inline bool msgbuf_set_data_expiry_time(msgbuf_t *msgbuf, u32 lifetime) {
+  return messageHandler_SetDataExpiryTime(msgbuf->packet, lifetime);
+}
+
+#define msgbuf_is_probe(M) messageHandler_IsAProbe((M)->packet)
+
+/* Path label */
+
+#define msgbuf_init_pathlabel(M) \
+  ((M)->path_label = messageHandler_GetPathLabel((M)->packet))
+#define msgbuf_update_pathlabel(M, outface)                               \
+  {                                                                       \
+    messageHandler_SetPathLabel((M)->packet,                              \
+                                messageHandler_GetPathLabel((M)->packet), \
+                                (M)->path_label);                         \
+    messageHandler_UpdatePathLabel((M)->packet, outface);                 \
+  }
+#define msgbuf_reset_pathlabel(M)               \
+  {                                             \
+    (M)->path_label = 0;                        \
+    messageHandler_ResetPathLabel((M)->packet); \
+  }
+
+/* WLDR */
+
+#define msgbuf_reset_wldr_label(M) (messageHandler_ResetWldrLabel((M)->packet))
+#define msgbuf_get_wldr_label(M) (messageHandler_GetWldrLabel((M)->packet))
+#define msgbuf_get_wldr_expected_label(M) \
+  (messageHandler_GetWldrExpectedLabel((M)->packet))
+#define msgbuf_get_wldr_last_received(M) \
+  (messageHandler_GetWldrLastReceived((M)->packet))
+#define msgbuf_set_wldr_label(M, label) \
+  (messageHandler_GetWldrLabel((M)->packet, label))
+
+#endif /* HICNLIGHT_MSGBUF */
diff --git a/hicn-light/src/hicn/core/msgbuf_pool.c b/hicn-light/src/hicn/core/msgbuf_pool.c
new file mode 100644
index 000000000..fb5d0a07c
--- /dev/null
+++ b/hicn-light/src/hicn/core/msgbuf_pool.c
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file msgbuf_pool.c
+ * @brief Implementation of hICN packet pool.
+ */
+
+#include "../base/pool.h"
+#include "msgbuf_pool.h"
+#include "../core/name.h"  // name_Release
+
+msgbuf_pool_t *_msgbuf_pool_create(size_t init_size, size_t max_size) {
+  msgbuf_pool_t *msgbuf_pool = malloc(sizeof(msgbuf_pool_t));
+
+  if (init_size == 0) init_size = PACKET_POOL_DEFAULT_INIT_SIZE;
+
+  pool_init(msgbuf_pool->buffers, init_size, 0);
+
+  return msgbuf_pool;
+}
+
+void msgbuf_pool_free(msgbuf_pool_t *msgbuf_pool) {
+  pool_free(msgbuf_pool->buffers);
+  free(msgbuf_pool);
+}
+
+off_t msgbuf_pool_get(msgbuf_pool_t *msgbuf_pool, msgbuf_t **msgbuf) {
+  return pool_get(msgbuf_pool->buffers, *msgbuf);
+}
+
+void msgbuf_pool_put(msgbuf_pool_t *msgbuf_pool, msgbuf_t *msgbuf) {
+  pool_put(msgbuf_pool->buffers, msgbuf);
+}
+
+int msgbuf_pool_getn(msgbuf_pool_t *msgbuf_pool, msgbuf_t **msgbuf, size_t n) {
+  // CAVEAT: Resize at the beginning otherwise the resize can be
+  // triggered by an intermediate msgbuf_pool_put, making the
+  // buffers previously retrieved invalid
+  uint64_t remaining_pool_space =
+      pool_get_free_indices_size(msgbuf_pool->buffers);
+  while (remaining_pool_space < n) {
+    _pool_resize((void **)&(msgbuf_pool->buffers), sizeof(msgbuf_t));
+
+    remaining_pool_space = pool_get_free_indices_size(msgbuf_pool->buffers);
+  }
+
+  for (unsigned i = 0; i < n; i++) {
+    // If not able to get the msgbuf
+    if (msgbuf_pool_get(msgbuf_pool, &msgbuf[i]) < 0) {
+      // Release all the msgbufs retrieved so far
+      for (unsigned j = 0; j < i; j++) {
+        msgbuf_pool_put(msgbuf_pool, msgbuf[j]);
+      }
+      return -1;
+    }
+  }
+  return 0;
+}
+
+off_t msgbuf_pool_get_id(msgbuf_pool_t *msgbuf_pool, msgbuf_t *msgbuf) {
+  return msgbuf - msgbuf_pool->buffers;
+}
+
+msgbuf_t *msgbuf_pool_at(const msgbuf_pool_t *msgbuf_pool, off_t id) {
+  assert(msgbuf_id_is_valid(id));
+  return msgbuf_pool->buffers + id;
+}
+
+void msgbuf_pool_acquire(msgbuf_t *msgbuf) { msgbuf->refs++; };
+
+void msgbuf_pool_release(msgbuf_pool_t *msgbuf_pool, msgbuf_t **msgbuf_ptr) {
+  msgbuf_t *msgbuf = *msgbuf_ptr;
+  assert(msgbuf->refs > 0);
+  msgbuf->refs--;
+
+  if (msgbuf->refs == 0) {
+    WITH_TRACE({
+      off_t msgbuf_id = msgbuf_pool_get_id(msgbuf_pool, msgbuf);
+      if (msgbuf->type != MSGBUF_TYPE_INTEREST &&
+          msgbuf->type != MSGBUF_TYPE_DATA) {
+        TRACE("Msgbuf %d (%p) - put to msgbuf pool", msgbuf_id, msgbuf);
+      } else {
+        char *name_str = name_ToString(msgbuf_get_name(msgbuf));
+        const char *msgbuf_type_str =
+            msgbuf->type == MSGBUF_TYPE_INTEREST ? "interest" : "data";
+        TRACE("Msgbuf %d (%p) - %s (%s) put to msgbuf pool", msgbuf_id, msgbuf,
+              name_str, msgbuf_type_str);
+        free(name_str);
+      }
+    })
+
+    msgbuf_pool_put(msgbuf_pool, msgbuf);
+    *msgbuf_ptr = NULL;
+  }
+};
+
+off_t msgbuf_pool_clone(msgbuf_pool_t *msgbuf_pool, msgbuf_t **new_msgbuf,
+                        off_t orginal_msg_id) {
+  msgbuf_t *original_msgbuf = msgbuf_pool_at(msgbuf_pool, orginal_msg_id);
+  off_t offset = pool_get(msgbuf_pool->buffers, *new_msgbuf);
+  memcpy(*new_msgbuf, original_msgbuf, sizeof(msgbuf_t));
+  (*new_msgbuf)->refs = 0;
+  return offset;
+}
diff --git a/hicn-light/src/hicn/core/msgbuf_pool.h b/hicn-light/src/hicn/core/msgbuf_pool.h
new file mode 100644
index 000000000..b8a15fd84
--- /dev/null
+++ b/hicn-light/src/hicn/core/msgbuf_pool.h
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file msgbuf_pool.h
+ * @brief hICN msgbuf pool.
+ *
+ * The msgbuf pool is used to store packet payloads while the packets are in
+ * transit, as well as holding them into the packet cache (PIT, CSS), WLDR,
+ * mapme, etc.
+ *
+ * Control packets might receive a special treatment in that they are eventually
+ * transformed into a ack/nack, but this should not affect any part of this
+ * design.
+ *
+ * Do we need a reference count, or simply a lock ?
+ * What about weak references ?
+ * We need to be sure that a pool element is never referenced ever again after
+ * it is deleted from the pool as its ID might be reaffected.
+ *
+ * It might even be better to store references to msgbuf's as they might hold
+ * additional information of interest about the packet... a bit like a skbuff in
+ * linux. Is this relevant for the packet cache ?
+ */
+
+#ifndef HICNLIGHT_MSGBUF_POOL_H
+#define HICNLIGHT_MSGBUF_POOL_H
+
+#include "msgbuf.h"
+
+#define MTU 1500
+#define PACKET_POOL_DEFAULT_INIT_SIZE 1024
+
+typedef struct {
+  msgbuf_t *buffers;
+} msgbuf_pool_t;
+
+/**
+ * @brief Allocate and initialize a msgbuf pool structure (helper).
+ *
+ * @param[in] init_size Number of buffers that can be stored in msgbuf pool.
+ * @param[in] max_size Maximum size.
+ * @return msgbuf_pool_t* Pointer to the msgbuf pool created.
+ *
+ * @note
+ *  - 0 for init size means a default value (of 1024)
+ *  - 0 for max_size means no limit
+ */
+msgbuf_pool_t *_msgbuf_pool_create(size_t init_size, size_t max_size);
+
+/**
+ * @brief Allocate and initialize a msgbuf pool data structure.
+ *
+ * @return msgbuf_pool_t* Pointer to the msgbuf pool created.
+ */
+#define msgbuf_pool_create() _msgbuf_pool_create(0, 0)
+
+/**
+ * @brief Free a msgbuf pool data structure.
+ *
+ * @param[in] msgbuf_pool Pointer to the msgbuf pool data structure to free.
+ */
+void msgbuf_pool_free(msgbuf_pool_t *msgbuf_pool);
+
+/**
+ * @brief Get a free msgbuf from the msgbuf pool data structure.
+ *
+ * @param[in] msgbuf_pool Pointer to the msgbuf pool data structure to use.
+ * @param[in, out] msgbuf Empty msgbuf that will be used to return the
+ * allocated one from the msgbuf pool.
+ * @return off_t ID of the msgbuf requested.
+ */
+off_t msgbuf_pool_get(msgbuf_pool_t *msgbuf_pool, msgbuf_t **msgbuf);
+
+/**
+ * @brief Release a msgbuf previously obtained, making it available to the
+ * msgbuf pool.
+ *
+ * @param[in] msgbuf_pool Pointer to the msgbuf pool data structure to use.
+ * @param[in] msgbuf Pointer to the msgbuf to release.
+ */
+void msgbuf_pool_put(msgbuf_pool_t *msgbuf_pool, msgbuf_t *msgbuf);
+
+/**
+ * @brief Get multiple free msgbufs from the msgbuf pool data structure.
+ *
+ * @param[in] msgbuf_pool Pointer to the msgbuf pool data structure to use.
+ * @param[in, out] msgbuf Pointer to the first empty msgbuf that will be used to
+ * allocate the msgbufs.
+ * @param[in] n Number of msgbufs requested.
+ * @retval 0 Success.
+ * @retval -1 Error.
+ */
+int msgbuf_pool_getn(msgbuf_pool_t *msgbuf_pool, msgbuf_t **msgbuf, size_t n);
+
+/**
+ * @brief Get the ID corresponding to the msgbuf requested.
+ *
+ * @param[in] msgbuf_pool Pointer to the msgbuf pool data structure to use.
+ * @param[in] msgbuf Pointer to the msgbuf to retrieve the ID for.
+ * @return off_t ID of the msgbuf requested.
+ */
+off_t msgbuf_pool_get_id(msgbuf_pool_t *msgbuf_pool, msgbuf_t *msgbuf);
+
+/**
+ * @brief Get the msgbuf corresponding to the ID requested.
+ *
+ * @param[in] msgbuf_pool Pointer to the msgbuf pool data structure to use.
+ * @param[in] id Index of the msgbuf to retrieve.
+ * @return msgbuf_t* Pointer to the msgbuf corresponding to the ID requested.
+ */
+msgbuf_t *msgbuf_pool_at(const msgbuf_pool_t *msgbuf_pool, off_t id);
+
+/**
+ * @brief Acquire a buffer (by increasing its reference count).
+ *
+ * @param[in] msgbuf Pointer to the msgbuf to acquire
+ */
+void msgbuf_pool_acquire(msgbuf_t *msgbuf);
+
+/**
+ * @brief Release a buffer. The buffer is also put back into the msgbuf
+ *  pool if everyone who acquired it has released its possession.
+ *
+ * @param[in] msgbuf_pool Pointer to the msgbuf pool data structure to use
+ * @param[in, out] msgbuf Pointer that holds the pointer to the msgbuf
+ * to release; the double indirection is used to set the msgbuf pointer
+ * to NULL in case it is put into the msgbuf pool.
+ */
+void msgbuf_pool_release(msgbuf_pool_t *msgbuf_pool, msgbuf_t **msgbuf_ptr);
+
+/**
+ * @brief Copy the original msgbuf in new msgbuf taken from the pool. The ref
+ * count on new msgbuf is set to 0
+ *
+ * @param[in] msgbuf_pool Pointer to the msgbuf pool data structure to use
+ * @param[in,out] new__msgbuf Pointer that holds the replicatate msgbuf
+ * @param[in] original_msgbuf id. use id instead of the pointer becasue the
+ * pointer may becose invalid if the msgbuf_pool requires a resize
+ * @return off_t ID of the msgbuf requested.
+ */
+off_t msgbuf_pool_clone(msgbuf_pool_t *msgbuf_pool, msgbuf_t **new_msgbuf,
+                        off_t orginal_msg_id);
+
+#endif /* HICNLIGHT_MSGBUF_POOL_H */
diff --git a/hicn-light/src/hicn/core/name.c b/hicn-light/src/hicn/core/name.c
index b4a5e8d1b..8886cc929 100644
--- a/hicn-light/src/hicn/core/name.c
+++ b/hicn-light/src/hicn/core/name.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,201 +13,133 @@
  * limitations under the License.
  */
 
+#include <assert.h>
 #include <limits.h>
 #include <hicn/hicn-light/config.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 
-#include <parc/algol/parc_BufferComposer.h>
-#include <parc/algol/parc_Hash.h>
-#include <parc/algol/parc_Memory.h>
-
+#include <hicn/common.h>  // cumulative_hash32
 #include <hicn/core/messageHandler.h>
 #include <hicn/core/name.h>
-
-#include <parc/algol/parc_Hash.h>
-
-#include <parc/assert/parc_Assert.h>
+#include <hicn/util/log.h>
+#include <hicn/base/hash.h>
 
 #define IPv6_TYPE 6
 #define IPv4_TYPE 4
 
-// assumption: the IPv6 address is the name, the TCP segment number is the ICN
-// segment
-
-struct name {
-  NameBitvector *content_name;
-  uint32_t segment;
-  uint32_t name_hash;
-  // the refcount is shared between all copies
-  unsigned *refCountPtr;
-};
-
-// =====================================================
-
-static unsigned _getRefCount(const Name *name) { return *name->refCountPtr; }
-
-static void _incrementRefCount(Name *name) {
-  parcAssertTrue(*name->refCountPtr > 0,
-                 "Illegal State: Trying to increment a 0 refcount!");
-  (*name->refCountPtr)++;
-}
-
-static void _decrementRefCount(Name *name) {
-  parcAssertTrue(*name->refCountPtr > 0,
-                 "Illegal State: Trying to decrement a 0 refcount!");
-  (*name->refCountPtr)--;
-}
-
 static uint32_t _computeHash(Name *name) {
-  parcAssertNotNull(name, "Parameter must be non-null pointer");
+  assert(name);
 
-  uint32_t hash1 = nameBitvector_GetHash32(name->content_name);
-  return parcHash32_Data_Cumulative((const uint8_t *)&name->segment, 4, hash1);
+  uint32_t hash1 = nameBitvector_GetHash32(&(name->content_name));
+  return hashlittle(&name->segment, sizeof(name->segment), hash1);
 }
 
 // ============================================================================
 
-Name *name_CreateFromPacket(const uint8_t *packet, MessagePacketType type) {
-  Name *name = parcMemory_AllocateAndClear(sizeof(Name));
-  parcAssertNotNull(name, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Name));
+void name_create_from_interest(const uint8_t *packet, Name *name) {
+  assert(packet);
+  assert(name);
 
   if (messageHandler_GetIPPacketType(packet) == IPv6_TYPE) {
-    if (type == MessagePacketType_Interest) {
-      name->content_name = nameBitvector_CreateFromIn6Addr(
-          (struct in6_addr *)messageHandler_GetDestination(packet), 128);
-    } else if (type == MessagePacketType_ContentObject) {
-      name->content_name = nameBitvector_CreateFromIn6Addr(
-          (struct in6_addr *)messageHandler_GetSource(packet), 128);
-    } else {
-      parcMemory_Deallocate((void **)&name);
-      return NULL;
-    }
+    nameBitvector_CreateFromIn6Addr(
+        &(name->content_name),
+        (struct in6_addr *)messageHandler_GetDestination(packet), 128);
   } else if (messageHandler_GetIPPacketType(packet) == IPv4_TYPE) {
-    if (type == MessagePacketType_Interest) {
-      name->content_name = nameBitvector_CreateFromInAddr(
-          *((uint32_t *)messageHandler_GetDestination(packet)), 32);
-    } else if (type == MessagePacketType_ContentObject) {
-      name->content_name = nameBitvector_CreateFromInAddr(
-          *((uint32_t *)messageHandler_GetSource(packet)), 32);
-    } else {
-      parcMemory_Deallocate((void **)&name);
-      return NULL;
-    }
+    nameBitvector_CreateFromInAddr(
+        &(name->content_name),
+        *((uint32_t *)messageHandler_GetDestination(packet)), 32);
   } else {
-    printf("Error: unknown message type\n");
-    parcMemory_Deallocate((void **)&name);
-    return NULL;
+    ERROR("Error: unknown message type\n");
+    return;
   }
 
   name->segment = messageHandler_GetSegment(packet);
   name->name_hash = _computeHash(name);
-
-  name->refCountPtr = parcMemory_Allocate(sizeof(unsigned));
-  parcAssertNotNull(name->refCountPtr, "parcMemory_Allocate(%zu) returned NULL",
-                    sizeof(unsigned));
-  *name->refCountPtr = 1;
-  return name;
 }
 
-Name *name_CreateFromAddress(address_type addressType, ip_address_t addr,
-                             uint8_t len) {
-  Name *name = parcMemory_AllocateAndClear(sizeof(Name));
-  parcAssertNotNull(name, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Name));
-  if (addressType == ADDR_INET) {
-    name->content_name = nameBitvector_CreateFromInAddr(addr.v4.as_u32, len);
-  } else if (addressType == ADDR_INET6) {
-    name->content_name = nameBitvector_CreateFromIn6Addr(&addr.v6.as_in6addr, len);
+void name_create_from_data(const uint8_t *packet, Name *name) {
+  assert(packet);
+  assert(name);
+
+  if (messageHandler_GetIPPacketType(packet) == IPv6_TYPE) {
+    nameBitvector_CreateFromIn6Addr(
+        &(name->content_name),
+        (struct in6_addr *)messageHandler_GetSource(packet), 128);
+  } else if (messageHandler_GetIPPacketType(packet) == IPv4_TYPE) {
+    nameBitvector_CreateFromInAddr(
+        &(name->content_name), *((uint32_t *)messageHandler_GetSource(packet)),
+        32);
   } else {
-    parcTrapNotImplemented("Unkown packet type");
+    printf("Error: unknown message type\n");
+    return;
   }
 
-  name->segment = 0;
+  name->segment = messageHandler_GetSegment(packet);
   name->name_hash = _computeHash(name);
-
-  name->refCountPtr = parcMemory_Allocate(sizeof(unsigned));
-  parcAssertNotNull(name->refCountPtr, "parcMemory_Allocate(%zu) returned NULL",
-                    sizeof(unsigned));
-  *name->refCountPtr = 1;
-
-  return name;
 }
 
-void name_Release(Name **namePtr) {
-  parcAssertNotNull(namePtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*namePtr, "Parameter must dereference to non-null pointer");
-
-  Name *name = *namePtr;
-  _decrementRefCount(name);
-  if (_getRefCount(name) == 0) {
-    parcMemory_Deallocate((void **)&(name->refCountPtr));
-    nameBitvector_Destroy(&(name->content_name));
+void name_CreateFromAddress(Name *name, int family, ip_address_t addr,
+                            uint8_t len) {
+  assert(name);
+
+  switch (family) {
+    case AF_INET:
+      nameBitvector_CreateFromInAddr(&(name->content_name), addr.v4.as_u32,
+                                     len);
+      break;
+    case AF_INET6:
+      nameBitvector_CreateFromIn6Addr(&(name->content_name),
+                                      &addr.v6.as_in6addr, len);
+      break;
+    default:
+      return;
   }
-  parcMemory_Deallocate((void **)&name);
-  *namePtr = NULL;
-}
-
-Name *name_Acquire(const Name *original) {
-  parcAssertNotNull(original, "Parameter must be non-null");
-  Name *copy = parcMemory_AllocateAndClear(sizeof(Name));
-  parcAssertNotNull(copy, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Name));
 
-  memcpy(copy, original, sizeof(Name));
-  _incrementRefCount(copy);
-
-  return copy;
+  name->segment = 0;
+  name->name_hash = _computeHash(name);
 }
 
-Name *name_Copy(const Name *original) {
-  parcAssertNotNull(original, "Parameter must be non-null");
-  Name *copy = parcMemory_AllocateAndClear(sizeof(Name));
-  parcAssertNotNull(copy, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Name));
+void name_Copy(const Name *original, Name *copy) {
+  assert(original);
+  assert(copy);
 
-  copy->content_name = nameBitvector_Copy(original->content_name);
+  nameBitvector_Copy(&(original->content_name), &(copy->content_name));
   copy->segment = original->segment;
   copy->name_hash = original->name_hash;
-
-  copy->refCountPtr = parcMemory_Allocate(sizeof(unsigned));
-  parcAssertNotNull(copy->refCountPtr, "parcMemory_Allocate(%zu) returned NULL",
-                    sizeof(unsigned));
-  *copy->refCountPtr = 1;
-
-  return copy;
 }
 
 uint32_t name_HashCode(const Name *name) {
-  parcAssertNotNull(name, "Parameter must be non-null");
+  assert(name);
   return name->name_hash;
 }
 
 NameBitvector *name_GetContentName(const Name *name) {
-  parcAssertNotNull(name, "Parameter must be non-null");
-  return name->content_name;
+  assert(name);
+  return (NameBitvector *)&(name->content_name);
 }
 
-bool name_Equals(const Name *a, const Name *b) {
-  parcAssertNotNull(a, "Parameter a must be non-null");
-  parcAssertNotNull(b, "Parameter b must be non-null");
+uint32_t name_GetSegment(const Name *name) {
+  assert(name);
+  return name->segment;
+}
 
-  /* BEGIN: Workaround for HICN-400 */
-  if ((!a->content_name) || (!b->content_name))
-      return false;
-  /* END: Workaround for HICN-400 */
+void name_SetSegment(Name *name, uint32_t segment) { name->segment = segment; }
 
-  if ((nameBitvector_Equals(a->content_name, b->content_name) &&
+bool name_Equals(const Name *a, const Name *b) {
+  assert(a);
+  assert(b);
+
+  if ((nameBitvector_Equals(&(a->content_name), &(b->content_name)) &&
        a->segment == b->segment))
     return true;
   return false;
 }
 
 int name_Compare(const Name *a, const Name *b) {
-  parcAssertNotNull(a, "Parameter a must be non-null");
-  parcAssertNotNull(b, "Parameter b must be non-null");
+  assert(a);
+  assert(b);
 
   if (a == NULL && b == NULL) {
     return 0;
@@ -219,7 +151,7 @@ int name_Compare(const Name *a, const Name *b) {
     return +1;
   }
 
-  int res = nameBitvector_Compare(a->content_name, b->content_name);
+  int res = nameBitvector_Compare(&(a->content_name), &(b->content_name));
 
   if (res != 0) {
     return res;
@@ -235,30 +167,30 @@ int name_Compare(const Name *a, const Name *b) {
 }
 
 char *name_ToString(const Name *name) {
-  char *output = malloc(128);
+  char *output = malloc(NI_MAXHOST * 2);
+  address_t address;
+  nameBitvector_ToAddress(name_GetContentName(name), &address);
 
-  Address *packetAddr = nameBitvector_ToAddress(name_GetContentName(name));
+  char addr_str[NI_MAXHOST];
+  int err = address_to_string(&address, addr_str, NULL);
+  _ASSERT(!err);
 
-  char * address_str = addressToString(packetAddr);
-  sprintf(output, "name: %s seq: %u", address_str, name->segment);
-  parcMemory_Deallocate((void **)&address_str);
-
-  addressDestroy(&packetAddr);
+  int chars_written =
+      snprintf(output, NI_MAXHOST * 2, "name=%s|%u", addr_str, name->segment);
+  _ASSERT(chars_written > 0);
 
   return output;
 }
 
 void name_setLen(Name *name, uint8_t len) {
-  nameBitvector_setLen(name->content_name, len);
+  nameBitvector_setLen(&(name->content_name), len);
   name->name_hash = _computeHash(name);
 }
 
 #ifdef WITH_POLICY
-uint32_t name_GetSuffix(const Name * name) {
-    return name->segment;
-}
+uint32_t name_GetSuffix(const Name *name) { return name->segment; }
 
-uint8_t name_GetLen(const Name * name) {
-    return nameBitvector_GetLength(name->content_name);
+uint8_t name_GetLen(const Name *name) {
+  return nameBitvector_GetLength(&(name->content_name));
 }
 #endif /* WITH_POLICY */
diff --git a/hicn-light/src/hicn/core/name.h b/hicn-light/src/hicn/core/name.h
index db9438150..23505243b 100644
--- a/hicn-light/src/hicn/core/name.h
+++ b/hicn-light/src/hicn/core/name.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -19,50 +19,52 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
-#include <hicn/core/messagePacketType.h>
-#include <hicn/core/nameBitvector.h>
-#include <hicn/utils/address.h>
+#include "nameBitvector.h"
 
-#include <hicn/utils/commands.h>
+typedef struct {
+  NameBitvector content_name;
+  uint32_t segment;
+  uint32_t name_hash;
+} Name;
 
-struct name;
-typedef struct name Name;
+#define EMPTY_NAME \
+  (Name) { .content_name = EMPTY_NAME_BITVECTOR, .segment = 0, .name_hash = 0, }
 
 /**
  * Creates a name from packet
  *
  */
-Name *name_CreateFromPacket(const uint8_t *memory, MessagePacketType type);
+void name_create_from_interest(const uint8_t *packet, Name *name);
+void name_create_from_data(const uint8_t *packet, Name *name);
 
 /**
- * Releases one reference count, and frees memory after last reference
+ * returns a copy of the name
  */
-void name_Release(Name **namePtr);
+void name_Copy(const Name *original, Name *copy);
 
 /**
- * Acquires a reference to the name so that a reference count increments.
- * Notice however that this * function is used only when a new fib entry is
- * created (mostly configuration time) probably here performance are not
- * critical.
+ * A hash value for use in hash tables
+ *
  */
-Name *name_Acquire(const Name *original);
+uint32_t name_HashCode(const Name *name);
 
 /**
- * returns a copy of the name
+ * Returns the content name without the segment value
+ *
  */
-Name *name_Copy(const Name *original);
+NameBitvector *name_GetContentName(const Name *name);
 
 /**
- * A hash value for use in hash tables
+ * Returns the segment value
  *
  */
-uint32_t name_HashCode(const Name *name);
+uint32_t name_GetSegment(const Name *name);
 
 /**
- * Returns the content name without the segment value
+ * Set the sequence number of the name provided
  *
  */
-NameBitvector *name_GetContentName(const Name *name);
+void name_SetSegment(Name *name, uint32_t segment);
 
 /**
  * Determine if two HicnName instances are equal.
@@ -93,12 +95,12 @@ void name_setLen(Name *name, uint8_t len);
  * Creates a name from a Address
  *
  */
-Name *name_CreateFromAddress(address_type addressType, ip_address_t addr,
-                             uint8_t len);
+void name_CreateFromAddress(Name *name, int family, ip_address_t addr,
+                            uint8_t len);
 
 #ifdef WITH_POLICY
-uint32_t name_GetSuffix(const Name * name);
-uint8_t name_GetLen(const Name * name);
+uint32_t name_GetSuffix(const Name *name);
+uint8_t name_GetLen(const Name *name);
 #endif /* WITH_POLICY */
 
 #endif  // name_h
diff --git a/hicn-light/src/hicn/core/nameBitvector.c b/hicn-light/src/hicn/core/nameBitvector.c
index 653560750..1314671db 100644
--- a/hicn-light/src/hicn/core/nameBitvector.c
+++ b/hicn-light/src/hicn/core/nameBitvector.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -17,17 +17,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-
 #include <hicn/core/messageHandler.h>
 #include <hicn/core/nameBitvector.h>
 
-#include <parc/algol/parc_Hash.h>
-
-#include <hicn/utils/commands.h>
+#include <hicn/base/hash.h>
+#include <hicn/ctrl/hicn-light-ng.h>
 
-#define NAME_LEN 2
+#define DEFAULT_PORT 1234
 
 const uint64_t BV_SIZE = 64;
 const uint64_t WIDTH = 128;
@@ -37,19 +33,12 @@ const uint64_t ONE = 0x1;
 // [bits[0] uint64_t       ] [bits[1] unit64_t       ]
 // ^                       ^ ^                       ^
 // 63                      0 127                     64
-// [1000 0000 ... 0000 1101] [1000 0000 ... 0000 0011] //binary
+// [1000 0000 ... 0000 1011] [1000 0000 ... 0000 0011] //binary
 //    1                  b     1                  c    //hex
 
-struct name_bitvector {
-  uint64_t bits[NAME_LEN];
-  uint8_t len;
-  uint8_t IPversion;
-};
-
-NameBitvector *nameBitvector_CreateFromInAddr(uint32_t addr, uint8_t len) {
-  NameBitvector *bitvector = parcMemory_AllocateAndClear(sizeof(NameBitvector));
-  parcAssertNotNull(bitvector, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(NameBitvector));
+void nameBitvector_CreateFromInAddr(NameBitvector *bitvector, uint32_t addr,
+                                    uint8_t len) {
+  assert(bitvector);
 
   bitvector->bits[0] = 0;
   bitvector->bits[1] = 0;
@@ -68,17 +57,12 @@ NameBitvector *nameBitvector_CreateFromInAddr(uint32_t addr, uint8_t len) {
   bitvector->len = len;
 
   bitvector->IPversion = IPv4_TYPE;
-
-  return bitvector;
 }
 
-NameBitvector *nameBitvector_CreateFromIn6Addr(struct in6_addr *addr,
-                                               uint8_t len) {
-  parcAssertNotNull(addr, "addr cannot be null");
-
-  NameBitvector *bitvector = parcMemory_AllocateAndClear(sizeof(NameBitvector));
-  parcAssertNotNull(bitvector, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(NameBitvector));
+void nameBitvector_CreateFromIn6Addr(NameBitvector *bitvector,
+                                     struct in6_addr *addr, uint8_t len) {
+  assert(addr);
+  assert(bitvector);
 
   bitvector->bits[0] = 0;
   bitvector->bits[1] = 0;
@@ -94,69 +78,26 @@ NameBitvector *nameBitvector_CreateFromIn6Addr(struct in6_addr *addr,
   bitvector->len = len;
 
   bitvector->IPversion = IPv6_TYPE;
-
-  return bitvector;
 }
 
-NameBitvector *nameBitvector_CreateFromAddress(const Address *prefix,
-                                               uint8_t len) {
-  parcAssertNotNull(prefix, "prefix cannot be null");
-
-  NameBitvector *bitvector = NULL;
-  switch (addressGetType(prefix)) {
-    case ADDR_INET: {
-      struct sockaddr_in addr;
-      addressGetInet(prefix, &addr);
-      bitvector = nameBitvector_CreateFromInAddr(addr.sin_addr.s_addr, len);
-      break;
-    }
-    case ADDR_INET6: {
-      struct sockaddr_in6 addr;
-      addressGetInet6(prefix, &addr);
-      bitvector = nameBitvector_CreateFromIn6Addr(&addr.sin6_addr, len);
-      break;
-    }
-    default:
-      parcTrapNotImplemented("Unkown packet type");
-      break;
-  }
-
-  return bitvector;
-}
-
-NameBitvector *nameBitvector_Copy(const NameBitvector *original) {
-  parcAssertNotNull(original, "original cannot be null");
-
-  NameBitvector *copy = parcMemory_AllocateAndClear(sizeof(NameBitvector));
-  parcAssertNotNull(copy, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(NameBitvector));
+void nameBitvector_Copy(const NameBitvector *original, NameBitvector *copy) {
+  assert(original);
+  assert(copy);
 
   copy->bits[0] = original->bits[0];
   copy->bits[1] = original->bits[1];
   copy->len = original->len;
-
-  return copy;
-}
-
-void nameBitvector_Destroy(NameBitvector **bitvectorPtr) {
-  parcAssertNotNull(bitvectorPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*bitvectorPtr,
-                    "Parameter must dereference to non-null pointer");
-
-  NameBitvector *bv = *bitvectorPtr;
-  parcMemory_Deallocate((void **)&(bv));
-  *bitvectorPtr = NULL;
+  copy->IPversion = original->IPversion;
 }
 
 uint8_t nameBitvector_GetLength(const NameBitvector *name) { return name->len; }
 
 uint32_t nameBitvector_GetHash32(const NameBitvector *name) {
-  return parcHash32_Data_Cumulative((const uint8_t *)name->bits, 16, 0);
+  return hash(&name->bits, 16);
 }
 
 bool nameBitvector_Equals(const NameBitvector *a, const NameBitvector *b) {
-  if (a->bits[0] == b->bits[0] && a->bits[1] == b->bits[1] && a->len == b->len)
-    return true;
+  if (nameBitvector_Compare(a, b) == 0) return true;
   return false;
 }
 
@@ -189,14 +130,15 @@ int nameBitvector_Compare(const NameBitvector *a, const NameBitvector *b) {
 }
 
 int nameBitvector_testBit(const NameBitvector *name, uint8_t pos, bool *bit) {
-  if(pos >= name->len  || pos > (WIDTH -1))
-    return -1;
+  if (pos >= name->len || pos > (WIDTH - 1)) return -1;
 
-  *bit = (name->bits[pos / BV_SIZE] & (ONE << ((BV_SIZE - 1) - (pos % BV_SIZE))));
+  *bit =
+      (name->bits[pos / BV_SIZE] & (ONE << ((BV_SIZE - 1) - (pos % BV_SIZE))));
 
   return 0;
 }
 
+// TODO XXX use ffs(ll)
 uint64_t _diff_bit_log2(uint64_t val) {
   // base 2 log of an uint64_t. This is the same as get the position of
   // the highest bit set (or most significant bit set, MSB)
@@ -229,8 +171,7 @@ uint64_t _diff_bit_log2(uint64_t val) {
   return result;
 }
 
-uint32_t nameBitvector_lpm(const NameBitvector *a,
-                          const NameBitvector *b) {
+uint32_t nameBitvector_lpm(const NameBitvector *a, const NameBitvector *b) {
   uint32_t limit;
   uint32_t prefix_len;
   if (a->len < b->len)
@@ -239,32 +180,30 @@ uint32_t nameBitvector_lpm(const NameBitvector *a,
     limit = b->len;
 
   uint64_t diff = a->bits[0] ^ b->bits[0];
-  if(diff){
+  if (diff) {
     prefix_len = (uint32_t)(BV_SIZE - (_diff_bit_log2(diff) + 1));
-    //printf("if 1 diff = %lu plen = %d\n", diff, prefix_len);
-  }else{
-    prefix_len = (uint32_t)BV_SIZE;
+    // printf("if 1 diff = %lu plen = %d\n", diff, prefix_len);
+  } else {
+    prefix_len = BV_SIZE;
     diff = a->bits[1] ^ b->bits[1];
-    if(diff){
-      prefix_len +=   (uint32_t)(BV_SIZE - (_diff_bit_log2(diff) + 1));
-      //printf("if 2 diff = %lu plen = %d\n", diff, prefix_len);
-    }else{
-      prefix_len +=  (uint32_t)BV_SIZE;
+    if (diff) {
+      prefix_len += (BV_SIZE - (_diff_bit_log2(diff) + 1));
+      // printf("if 2 diff = %lu plen = %d\n", diff, prefix_len);
+    } else {
+      prefix_len += BV_SIZE;
     }
   }
 
-  if(prefix_len < limit)
-    return prefix_len;
+  if (prefix_len < limit) return prefix_len;
   return limit;
 }
 
-void nameBitvector_clear(NameBitvector *a, uint8_t start_from){
-  for(uint8_t pos = start_from; pos < WIDTH; pos++)
-      a->bits[pos / BV_SIZE] &= ~(ONE << ((BV_SIZE - 1) - (pos % BV_SIZE)));
+void nameBitvector_clear(NameBitvector *a, uint8_t start_from) {
+  for (uint8_t pos = start_from; pos < WIDTH; pos++)
+    a->bits[pos / BV_SIZE] &= ~(ONE << ((BV_SIZE - 1) - (pos % BV_SIZE)));
 }
 
-int nameBitvector_ToIPAddress(const NameBitvector *name,
-                              ip_prefix_t *prefix) {
+int nameBitvector_ToIPAddress(const NameBitvector *name, ip_prefix_t *prefix) {
   if (name->IPversion == IPv4_TYPE) {
     struct in_addr *addr = (struct in_addr *)(&prefix->address.v4.buffer);
     prefix->family = AF_INET;
@@ -302,11 +241,11 @@ int nameBitvector_ToIPAddress(const NameBitvector *name,
 
 void nameBitvector_setLen(NameBitvector *name, uint8_t len) { name->len = len; }
 
-Address *nameBitvector_ToAddress(const NameBitvector *name) {
+void nameBitvector_ToAddress(const NameBitvector *name, address_t *address) {
   if (name->IPversion == IPv4_TYPE) {
-    struct sockaddr_in addr;
-    addr.sin_family = AF_INET;
-    addr.sin_port = htons(1234);
+    struct sockaddr_in *sin = address4(address);
+    sin->sin_family = AF_INET;
+    sin->sin_port = htons(DEFAULT_PORT);
 
     uint32_t tmp_addr = name->bits[0] >> 32ULL;
     uint8_t addr_1 = (tmp_addr & 0xff000000) >> 24;
@@ -314,51 +253,44 @@ Address *nameBitvector_ToAddress(const NameBitvector *name) {
     uint8_t addr_3 = (tmp_addr & 0x0000ff00) >> 8;
     uint8_t addr_4 = (tmp_addr & 0x000000ff);
 
-    addr.sin_addr.s_addr = 0;
-    addr.sin_addr.s_addr = (addr.sin_addr.s_addr | addr_4) << 8;
-    addr.sin_addr.s_addr = (addr.sin_addr.s_addr | addr_3) << 8;
-    addr.sin_addr.s_addr = (addr.sin_addr.s_addr | addr_2) << 8;
-    addr.sin_addr.s_addr = (addr.sin_addr.s_addr | addr_1);
-
-    Address *packetAddr = addressCreateFromInet(&addr);
-
-    return packetAddr;
-
+    sin->sin_addr.s_addr = 0;
+    sin->sin_addr.s_addr = (sin->sin_addr.s_addr | addr_4) << 8;
+    sin->sin_addr.s_addr = (sin->sin_addr.s_addr | addr_3) << 8;
+    sin->sin_addr.s_addr = (sin->sin_addr.s_addr | addr_2) << 8;
+    sin->sin_addr.s_addr = (sin->sin_addr.s_addr | addr_1);
   } else {
-    struct sockaddr_in6 addr;
-    addr.sin6_family = AF_INET6;
-    addr.sin6_port = htons(1234);
-    addr.sin6_scope_id = 0;
-    addr.sin6_flowinfo = 0;
+    struct sockaddr_in6 *sin6 = address6(address);
+    sin6->sin6_family = AF_INET6;
+    sin6->sin6_port = htons(DEFAULT_PORT);
+    sin6->sin6_scope_id = 0;
+    sin6->sin6_flowinfo = 0;
 
     for (int i = 0; i < 8; i++) {
-      addr.sin6_addr.s6_addr[i] =
+      sin6->sin6_addr.s6_addr[i] =
           (uint8_t)((name->bits[0] >> 8 * (7 - i)) & 0xFF);
     }
 
     int x = 0;
     for (int i = 8; i < 16; ++i) {
-      addr.sin6_addr.s6_addr[i] =
+      sin6->sin6_addr.s6_addr[i] =
           (uint8_t)((name->bits[1] >> 8 * (7 - x)) & 0xFF);
       x++;
     }
-
-    Address *packetAddr = addressCreateFromInet6(&addr);
-
-    return packetAddr;
   }
 }
 
 char *nameBitvector_ToString(const NameBitvector *name) {
   char *output = malloc(WIDTH);
 
-  Address *packetAddr = nameBitvector_ToAddress(name);
-
-  char * str = addressToString(packetAddr);
-  sprintf(output, "prefix: %s len: %u", str, name->len);
-  parcMemory_Deallocate((void **)&str);
+  address_t address;
+  nameBitvector_ToAddress(name, &address);
 
-  addressDestroy(&packetAddr);
+  // XXX TODO
+#if 0
+    sprintf(output, "prefix: %s len: %u", addressToString(packetAddr), name->len);
+#else
+  snprintf(output, WIDTH, "%s", "ENOIMPL");
+#endif
 
   return output;
 }
diff --git a/hicn-light/src/hicn/core/nameBitvector.h b/hicn-light/src/hicn/core/nameBitvector.h
index 19944778c..e3cc108ac 100644
--- a/hicn-light/src/hicn/core/nameBitvector.h
+++ b/hicn-light/src/hicn/core/nameBitvector.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -20,19 +20,25 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-#include <hicn/utils/address.h>
+#include "address.h"
 
-struct name_bitvector;
-typedef struct name_bitvector NameBitvector;
+#define NAME_LEN 2
+typedef struct {
+  uint64_t bits[NAME_LEN];
+  uint8_t len;
+  uint8_t IPversion;
+} NameBitvector;
 
-NameBitvector *nameBitvector_CreateFromInAddr(uint32_t addr, uint8_t len);
+#define EMPTY_NAME_BITVECTOR \
+  (NameBitvector) { .bits[0] = 0, .bits[1] = 0, .len = 0, .IPversion = 0, }
 
-NameBitvector *nameBitvector_CreateFromIn6Addr(struct in6_addr *addr,
-                                               uint8_t len);
+void nameBitvector_CreateFromInAddr(NameBitvector *bitvector, uint32_t addr,
+                                    uint8_t len);
 
-NameBitvector *nameBitvector_Copy(const NameBitvector *original);
+void nameBitvector_CreateFromIn6Addr(NameBitvector *bitvector,
+                                     struct in6_addr *addr, uint8_t len);
 
-void nameBitvector_Destroy(NameBitvector **bitvectorPtr);
+void nameBitvector_Copy(const NameBitvector *original, NameBitvector *copy);
 
 uint8_t nameBitvector_GetLength(const NameBitvector *name);
 
@@ -51,7 +57,7 @@ void nameBitvector_clear(NameBitvector *a, uint8_t start_from);
 int nameBitvector_ToIPAddress(const NameBitvector *name, ip_prefix_t *prefix);
 void nameBitvector_setLen(NameBitvector *name, uint8_t len);
 
-Address *nameBitvector_ToAddress(const NameBitvector *name);
+void nameBitvector_ToAddress(const NameBitvector *name, address_t *address);
 
 char *nameBitvector_ToString(const NameBitvector *name);
 
diff --git a/hicn-light/src/hicn/core/nexthops.c b/hicn-light/src/hicn/core/nexthops.c
new file mode 100644
index 000000000..190f09ab0
--- /dev/null
+++ b/hicn-light/src/hicn/core/nexthops.c
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file nexthops.c
+ * \brief Nexthops implementation
+ */
+
+#include "nexthops.h"
+
+int nexthops_disable(nexthops_t *nexthops, off_t offset) {
+  if (offset >= nexthops->num_elts) return -1;
+  nexthops->flags |= (1 << offset);
+  nexthops->cur_elts--;
+  return 0;
+}
+
+void nexthops_reset(nexthops_t *nexthops) {
+  nexthops->flags = 0;
+  nexthops->cur_elts = nexthops->num_elts;
+}
+
+off_t nexthops_add(nexthops_t *nexthops, nexthop_t nexthop) {
+  off_t id;
+  unsigned i, n;
+  nexthops_enumerate(nexthops, i, n, {
+    if (n == nexthop) return i;
+  });
+  id = nexthops->num_elts++;
+  nexthops->elts[id] = nexthop;
+  nexthops_reset(nexthops);
+  return id;
+}
+
+off_t nexthops_remove(nexthops_t *nexthops, nexthop_t nexthop) {
+  unsigned i, n;
+  nexthops_enumerate(nexthops, i, n, {
+    if (n == nexthop) {
+      nexthops->num_elts--;
+      nexthops->elts[i] = nexthops->elts[nexthops->num_elts];
+      nexthops->state[i] = nexthops->state[nexthops->num_elts];
+      nexthops_reset(nexthops);
+      return i;
+    }
+  });
+  return INVALID_NEXTHOP;
+}
+
+bool nexthops_contains(nexthops_t *nexthops, unsigned nexthop) {
+  unsigned n;
+  nexthops_foreach(nexthops, n, {
+    if (n == nexthop) return true;
+  });
+  return false;
+}
+
+off_t nexthops_find(nexthops_t *nexthops, unsigned nexthop) {
+  unsigned i, n;
+  nexthops_enumerate(nexthops, i, n, {
+    if (n == nexthop) return i;
+  });
+  return INVALID_NEXTHOP;
+}
+
+unsigned nexthops_get_one(nexthops_t *nexthops) {
+  unsigned n;
+  nexthops_foreach(nexthops, n, { return n; });
+  return INVALID_NEXTHOP;
+}
+
+int nexthops_select(nexthops_t *nexthops, off_t i) {
+  if (i >= nexthops->num_elts) return -1;
+  nexthops->flags = ~0; /* all 1, could be limited to num_elts */
+  nexthops->flags &= ~(1 << (i));
+  nexthops->cur_elts = 1;
+  return 0;
+}
+
+#ifdef WITH_POLICY
+
+void nexthops_set_priority(nexthops_t *nexthops, nexthop_t nexthop,
+                           int priority) {
+  unsigned i;
+  nexthop_t nh;
+  nexthops_enumerate(nexthops, i, nh, {
+    if (nexthop == nh) nexthops_set_priority_by_id(nexthops, i, priority);
+  });
+}
+
+void nexthops_set_priority_by_id(nexthops_t *nexthops, off_t i, int priority) {
+  nexthops->state[i].priority = priority;
+}
+
+void nexthops_reset_priority(nexthops_t *nexthops, nexthop_t nexthop) {
+  nexthops_set_priority(nexthops, nexthop, DEFAULT_PRIORITY);
+}
+
+void nexthops_reset_priority_by_id(nexthops_t *nexthops, off_t i) {
+  nexthops_set_priority_by_id(nexthops, i, DEFAULT_PRIORITY);
+}
+
+void nexthops_reset_priorities(nexthops_t *nexthops) {
+  unsigned i;
+  nexthop_t nh;
+  nexthops_enumerate(nexthops, i, nh, {
+    (void)nh;
+    nexthops_reset_priority(nexthops, i);
+  });
+}
+
+bool nexthops_equal(nexthops_t *a, nexthops_t *b) {
+  unsigned n;
+  if (nexthops_get_len(a) != nexthops_get_len(b)) return false;
+  nexthops_foreach(a, n, {
+    if (!nexthops_contains(b, n)) return false;
+  });
+  return true;
+}
+
+void nexthops_copy(nexthops_t *src, nexthops_t *dst) {
+  for (unsigned i = 0; i < MAX_NEXTHOPS; i++) {
+    dst->elts[i] = src->elts[i];
+    dst->state[i] = src->state[i];
+  }
+  dst->num_elts = src->num_elts;
+  dst->flags = src->flags;
+  dst->cur_elts = src->cur_elts;
+}
+
+#endif /* WITH_POLICY */
diff --git a/hicn-light/src/hicn/core/nexthops.h b/hicn-light/src/hicn/core/nexthops.h
new file mode 100644
index 000000000..2a7fc0b32
--- /dev/null
+++ b/hicn-light/src/hicn/core/nexthops.h
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file nexthops.h
+ * \brief Nexthops
+ *
+ * An implementation of the nexthop data structure for the FIB entry.
+ *
+ * Note that the position of nexthops in this structure can be reordered. This
+ * is not an issue for the strategy state since the state if bound to the
+ * nexthop information, but an external module should not keep any reference to
+ * the offset of the nexthop.
+ */
+
+#ifndef HICNLIGHT_NEXTHOPS_H
+#define HICNLIGHT_NEXTHOPS_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include <hicn/util/log.h>
+
+#include "connection.h"
+#include "strategy_vft.h"
+
+#define _nexthops_var(x) _nexthops_##x
+
+typedef unsigned nexthop_t;
+#define NEXTHOP(x) ((nexthop_t)x)
+
+#define INVALID_NEXTHOP NEXTHOP(CONNECTION_ID_UNDEFINED)
+
+/*
+ * This allows storage within a single integer
+ * 32 or 64 nexthops should be sufficient
+ * Eventually replace this with a resizeable vector
+ */
+#define MAX_NEXTHOPS (sizeof(uint_fast32_t) * 8)
+
+typedef struct nexthops_s {
+  unsigned elts[MAX_NEXTHOPS];
+  strategy_nexthop_state_t state[MAX_NEXTHOPS];
+  size_t num_elts;
+
+  /*
+   * flags is used during the processing of nexthops by the policy framework,
+   * and its meaning is local to the related functions.
+   * It is a mask where a bit set to 1 in position N indicates that the Nth
+   * elements in the elts array (elts[N]) is disabled.
+   * The number of enabled next hops is reflected in cur_elts, and it is equal
+   * to num_elts if no nexthop is disabled. This could be replaced by an
+   * efficient function counting the number of 1 bits in flags.
+   */
+  uint_fast32_t flags;
+  size_t cur_elts;
+} nexthops_t;
+
+#define NEXTHOPS_EMPTY                                                   \
+  (nexthops_t) {                                                         \
+    .elts = {0}, .state = {STRATEGY_NEXTHOP_STATE_EMPTY}, .num_elts = 0, \
+    .flags = 0, .cur_elts = 0,                                           \
+  }
+
+#define nexthops_state(NH, i) ((NH)->state[(i)])
+
+#define nexthops_get_len(NH) ((NH)->num_elts)
+
+#define nexthops_set_len(NH, LEN) \
+  do {                            \
+    (NH)->num_elts = LEN;         \
+    (NH)->cur_elts = LEN;         \
+  } while (0)
+
+#define nexthops_get_curlen(NH) ((NH)->cur_elts)
+
+#define nexthops_inc(NH) \
+  do {                   \
+    (NH)->num_elts++;    \
+    (NH)->cur_elts++;    \
+  } while (0)
+
+int nexthops_disable(nexthops_t *nexthops, off_t offset);
+
+#define nexthops_disable_if(NH, i, condition) \
+  do {                                        \
+    if (condition) {                          \
+      nexthops_disable((NH), (i));            \
+    }                                         \
+  } while (0)
+
+#define nexthops_is_disabled(NH, i) ((NH)->flags & (1 << (i)))
+
+void nexthops_reset(nexthops_t *nexthops);
+
+#define nexthops_enumerate(NH, i, X, BODY)             \
+  do {                                                 \
+    for ((i) = 0; (i) < nexthops_get_len(NH); (i)++) { \
+      if (nexthops_is_disabled((NH), (i))) continue;   \
+      X = (NH)->elts[(i)];                             \
+      do {                                             \
+        BODY                                           \
+      } while (0);                                     \
+    }                                                  \
+  } while (0)
+
+#define nexthops_foreach(NH, X, BODY)                        \
+  do {                                                       \
+    unsigned _nexthops_var(i);                               \
+    nexthops_enumerate((NH), _nexthops_var(i), (X), {BODY}); \
+  } while (0)
+
+off_t nexthops_add(nexthops_t *nexthops, nexthop_t nexthop);
+
+off_t nexthops_remove(nexthops_t *nexthops, nexthop_t nexthop);
+
+#define nexthops_clear(NH)   \
+  do {                       \
+    nexthops_set_len(NH, 0); \
+    (NH)->flags = 0;         \
+  } while (0)
+
+bool nexthops_contains(nexthops_t *nexthops, unsigned nexthop);
+
+off_t nexthops_find(nexthops_t *nexthops, unsigned nexthop);
+
+unsigned nexthops_get_one(nexthops_t *nexthops);
+
+int nexthops_select(nexthops_t *nexthops, off_t i);
+
+/*
+ * This selects the first available element, irrespective of the current state
+ * of flags
+ */
+#define nexthops_select_first(NH) nexthops_select((NH), 0)
+
+#ifdef WITH_POLICY
+
+#define DEFAULT_PRIORITY 0
+#define DISABLED_PRIORITY -1
+
+void nexthops_set_priority(nexthops_t *nexthops, nexthop_t nexthop,
+                           int priority);
+
+void nexthops_set_priority_by_id(nexthops_t *nexthops, off_t i, int priority);
+
+void nexthops_reset_priority_by_id(nexthops_t *nexthops, off_t i);
+
+void nexthops_reset_priority(nexthops_t *nexthops, nexthop_t nexthop);
+
+void nexthops_reset_priorities(nexthops_t *nexthops);
+
+/*
+ * returns true if the list of next hops contained in a is the same of b
+ * returns false otherwise
+ */
+bool nexthops_equal(nexthops_t *a, nexthops_t *b);
+
+void nexthops_copy(nexthops_t *src, nexthops_t *dst);
+
+#endif /* WITH_POLICY */
+
+#endif /* HICNLIGHT_NEXTHOPS_H */
diff --git a/hicn-light/src/hicn/core/numberSet.c b/hicn-light/src/hicn/core/numberSet.c
deleted file mode 100644
index 106e13be6..000000000
--- a/hicn-light/src/hicn/core/numberSet.c
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * 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 <parc/algol/parc_ArrayList.h>
-#include <parc/algol/parc_Memory.h>
-#include <hicn/hicn-light/config.h>
-#include <hicn/core/numberSet.h>
-#include <stdio.h>
-
-#include <parc/assert/parc_Assert.h>
-
-struct number_set {
-  Number *arrayOfNumbers;
-  size_t length;
-  size_t limit;
-  unsigned refcount;
-};
-
-static void numberSet_Expand(NumberSet *set);
-
-NumberSet *numberSet_Create() {
-  NumberSet *set = parcMemory_AllocateAndClear(sizeof(NumberSet));
-  parcAssertNotNull(set, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(NumberSet));
-  set->arrayOfNumbers = parcMemory_AllocateAndClear(sizeof(Number) * 16);
-  parcAssertNotNull((set->arrayOfNumbers),
-                    "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Number) * 16);
-  set->length = 0;
-  set->limit = 16;
-  set->refcount = 1;
-  return set;
-}
-
-NumberSet *numberSet_Acquire(const NumberSet *original) {
-  parcAssertNotNull(original, "Parameter original must be non-null");
-  NumberSet *copy = (NumberSet *)original;
-  copy->refcount++;
-  return copy;
-}
-
-void numberSet_Release(NumberSet **setPtr) {
-  parcAssertNotNull(setPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*setPtr, "Parameter must dereference to non-null pointer");
-
-  NumberSet *set = *setPtr;
-  parcAssertTrue(
-      set->refcount > 0,
-      "Invalid state: calling destroy on an object with 0 reference count");
-  set->refcount--;
-
-  if (set->refcount == 0) {
-    parcMemory_Deallocate((void **)&(set->arrayOfNumbers));
-    parcMemory_Deallocate((void **)&set);
-    *setPtr = NULL;
-  }
-}
-
-/**
- * @function numberSet_AddNoChecks
- * @abstract Add a number we know is not already in the set
- * @discussion
- *   Used by other functions that already know the number is unique in the set,
- *   Does not do the expensive Contains check.
- */
-static void numberSet_AddNoChecks(NumberSet *set, Number number) {
-  if (set->length == set->limit) {
-    numberSet_Expand(set);
-  }
-
-  set->arrayOfNumbers[set->length] = number;
-  set->length++;
-}
-
-bool numberSet_Add(NumberSet *set, Number number) {
-  parcAssertNotNull(set, "Parameter set must be non-null");
-  if (numberSet_Contains(set, number)) {
-    return false;
-  }
-
-  numberSet_AddNoChecks(set, number);
-  return true;
-}
-
-size_t numberSet_Length(const NumberSet *set) {
-  parcAssertNotNull(set, "Parameter set must be non-null");
-  return set->length;
-}
-
-Number numberSet_GetItem(const NumberSet *set, size_t ordinalIndex) {
-  parcAssertNotNull(set, "Parameter set must be non-null");
-  parcAssertTrue(ordinalIndex < set->length,
-                 "Limit beyond end of set, length %zu got %zu", set->length,
-                 ordinalIndex);
-
-  return set->arrayOfNumbers[ordinalIndex];
-}
-
-bool numberSet_Contains(const NumberSet *set, Number number) {
-  parcAssertNotNull(set, "Parameter set must be non-null");
-  for (size_t i = 0; i < set->length; i++) {
-    if (set->arrayOfNumbers[i] == number) {
-      return true;
-    }
-  }
-  return false;
-}
-
-void numberSet_AddSet(NumberSet *destinationSet, const NumberSet *setToAdd) {
-  parcAssertNotNull(destinationSet,
-                    "Parameter destinationSet must be non-null");
-  parcAssertNotNull(setToAdd, "Parameter setToAdd must be non-null");
-
-  for (size_t i = 0; i < setToAdd->length; i++) {
-    numberSet_Add(destinationSet, setToAdd->arrayOfNumbers[i]);
-  }
-}
-
-NumberSet *numberSet_Subtract(const NumberSet *minuend,
-                              const NumberSet *subtrahend) {
-  // because the underlying ADT is not sorted, this is pretty ineffient, could
-  // be O(n^2).
-
-  NumberSet *difference = numberSet_Create();
-
-  for (size_t i = 0; i < minuend->length; i++) {
-    bool unique = true;
-    for (size_t j = 0; j < subtrahend->length && unique; j++) {
-      if (minuend->arrayOfNumbers[i] == subtrahend->arrayOfNumbers[j]) {
-        unique = false;
-      }
-    }
-
-    if (unique) {
-      numberSet_AddNoChecks(difference, minuend->arrayOfNumbers[i]);
-    }
-  }
-  return difference;
-}
-
-bool numberSet_Equals(const NumberSet *a, const NumberSet *b) {
-  if (a == NULL && b == NULL) {
-    return true;
-  }
-
-  if (a == NULL || b == NULL) {
-    return false;
-  }
-
-  if (a->length == b->length) {
-    for (size_t i = 0; i < a->length; i++) {
-      bool found = false;
-      for (size_t j = 0; j < b->length && !found; j++) {
-        if (a->arrayOfNumbers[i] == b->arrayOfNumbers[j]) {
-          found = true;
-        }
-      }
-      if (!found) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  return false;
-}
-
-void numberSet_Remove(NumberSet *set, Number number) {
-  parcAssertNotNull(set, "Parameter set must be non-null");
-  for (size_t i = 0; i < set->length; i++) {
-    if (set->arrayOfNumbers[i] == number) {
-      set->length--;
-      if (set->length > 0) {
-        // move the last element to the removed element to keep the array
-        // packed.
-        set->arrayOfNumbers[i] = set->arrayOfNumbers[set->length];
-      }
-      return;
-    }
-  }
-}
-
-// =====================================================
-
-static void numberSet_Expand(NumberSet *set) {
-  size_t newlimit = set->limit * 2;
-  size_t newbytes = newlimit * sizeof(Number);
-
-  set->arrayOfNumbers = parcMemory_Reallocate(set->arrayOfNumbers, newbytes);
-  set->limit = newlimit;
-}
diff --git a/hicn-light/src/hicn/core/numberSet.h b/hicn-light/src/hicn/core/numberSet.h
deleted file mode 100644
index 91a965d7b..000000000
--- a/hicn-light/src/hicn/core/numberSet.h
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * @brief Stores a set of numbers.
- *
- * Useful for things like the reverse path of a PIT
- * or the forward paths of a FIB.  Does not allow duplicates.
- *
- */
-
-#ifndef numberSet_h
-#define numberSet_h
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-struct number_set;
-typedef struct number_set NumberSet;
-
-typedef uint32_t Number;
-
-/**
- * @function numberList_Create
- * @abstract A new list of numbers
- */
-NumberSet *numberSet_Create(void);
-
-/**
- * Obtains a reference counted copy of the original
- * The reference count is increased by one.  It must be released with
- * NumberSet_Release().
- * @param [in] original An allocated NumberSet
- * @return non-null The reference counted copy
- */
-NumberSet *numberSet_Acquire(const NumberSet *original);
-
-/**
- * Releases one reference count and destroys the memory after last release
- * The pointer will be NULLed after release regardless if the memory was
- * destroyed.
- * @param [in,out] setPtr A pointer to a NumberSet.  Will be NULL'd after
- * release.
- */
-void numberSet_Release(NumberSet **setPtr);
-
-/**
- * @function numberList_Append
- * @abstract Add a number to the end of the list
- * @discussion
- *   No check for duplicates is done
- * @return true if added, false if a duplicate
- */
-bool numberSet_Add(NumberSet *set, Number number);
-
-/**
- * @function numberList_Length
- * @abstract The count of numbers in the list
- */
-size_t numberSet_Length(const NumberSet *set);
-
-/**
- * @function numberSet_GetItem
- * @abstract Retrieves an item based on the ordinal index
- * @discussion
- *   Will assert if the ordinalIndex is out of bounds.
- */
-Number numberSet_GetItem(const NumberSet *set, size_t ordinalIndex);
-
-/**
- * @function numberSet_Contains
- * @abstract Checks for set membership
- * @return true if the set contains the number, false otherwise
- */
-bool numberSet_Contains(const NumberSet *set, Number number);
-
-/**
- * @function numberSet_AddSet
- * @abstract Adds one set to another set
- * @discussion
- *   Adds <code>setToAdd</code> to <code>destinationSet</code>
- * @return true if the set contains the number, false otherwise
- */
-void numberSet_AddSet(NumberSet *destinationSet, const NumberSet *setToAdd);
-
-/**
- * @function numberSet_Subtract
- * @abstract Computes set difference <code>difference = minuend -
- * subtrahend</code>, returns a new number set.
- * @discussion
- *   <code>minuend</code> and <code>subtrahend</code> are not modified.  A new
- * difference set is created.
- *
- *   Returns the elements in <code>minuend</code> that are not in
- * <code>subtrahend</code>.
- *
- * @param minuend The set from which to subtract
- * @param subrahend The set begin removed from minuend
- * @return The set difference.  May be empty, but will not be NULL.
- */
-NumberSet *numberSet_Subtract(const NumberSet *minuend,
-                              const NumberSet *subtrahend);
-
-/**
- * Determine if two NumberSet instances are equal.
- *
- * Two NumberSet instances are equal if, and only if,
- *   they are the same size and contain the same elements.  Empty sets are
- * equal. NULL equals NULL, but does not equal non-NULL.
- *
- * The following equivalence relations on non-null `NumberSet` instances are
- * maintained:
- *
- *  * It is reflexive: for any non-null reference value x, `NumberSet_Equals(x,
- * x)` must return true.
- *
- *  * It is symmetric: for any non-null reference values x and y,
- *    `numberSet_Equals(x, y)` must return true if and only if
- *        `numberSet_Equals(y, x)` returns true.
- *
- *  * It is transitive: for any non-null reference values x, y, and z, if
- *        `numberSet_Equals(x, y)` returns true and
- *        `numberSet_Equals(y, z)` returns true,
- *        then  `numberSet_Equals(x, z)` must return true.
- *
- *  * It is consistent: for any non-null reference values x and y, multiple
- *      invocations of `numberSet_Equals(x, y)` consistently return true or
- *      consistently return false.
- *
- *  * For any non-null reference value x, `numberSet_Equals(x, NULL)` must
- *      return false.
- *
- * @param a A pointer to a `NumberSet` instance.
- * @param b A pointer to a `NumberSet` instance.
- * @return true if the two `NumberSet` instances are equal.
- */
-bool numberSet_Equals(const NumberSet *a, const NumberSet *b);
-
-/**
- * @function numberSet_Remove
- * @abstract Removes the number from the set
- */
-void numberSet_Remove(NumberSet *set, Number number);
-#endif  // numberSet_h
diff --git a/hicn-light/src/hicn/core/packet_cache.c b/hicn-light/src/hicn/core/packet_cache.c
new file mode 100644
index 000000000..203ad4a63
--- /dev/null
+++ b/hicn-light/src/hicn/core/packet_cache.c
@@ -0,0 +1,547 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file packet_cache.c
+ * \brief Implementation of hICN packet cache
+ */
+
+#include "packet_cache.h"
+
+pkt_cache_t *pkt_cache_create(size_t cs_size) {
+  pkt_cache_t *pkt_cache = (pkt_cache_t *)malloc(sizeof(pkt_cache_t));
+
+  pkt_cache->pit = pit_create();
+  if (!pkt_cache->pit) return NULL;
+  pkt_cache->cs = cs_create(cs_size);
+  if (!pkt_cache->cs) return NULL;
+
+  pkt_cache->index_by_name = kh_init(pkt_cache_name);
+  pool_init(pkt_cache->entries, DEFAULT_PKT_CACHE_SIZE, 0);
+
+  return pkt_cache;
+}
+
+void pkt_cache_free(pkt_cache_t *pkt_cache) {
+  assert(pkt_cache);
+
+  // Free hashmap
+  const Name *k_name;
+  unsigned v;
+  (void)v;
+  kh_foreach(pkt_cache->index_by_name, k_name, v, { free((Name *)k_name); });
+  kh_destroy(pkt_cache_name, pkt_cache->index_by_name);
+
+  // Free pool
+  pool_free(pkt_cache->entries);
+
+  // Free PIT and CS
+  pit_free(pkt_cache->pit);
+  cs_free(pkt_cache->cs);
+
+  free(pkt_cache);
+}
+
+pit_t *pkt_cache_get_pit(pkt_cache_t *pkt_cache) { return pkt_cache->pit; }
+
+cs_t *pkt_cache_get_cs(pkt_cache_t *pkt_cache) { return pkt_cache->cs; }
+
+pkt_cache_entry_t *pkt_cache_lookup(pkt_cache_t *pkt_cache, const Name *name,
+                                    msgbuf_pool_t *msgbuf_pool,
+                                    pkt_cache_lookup_t *lookup_result,
+                                    off_t *entry_id,
+                                    bool is_serve_from_cs_enabled) {
+  Name name_key = name_key_factory(name);
+  khiter_t k = kh_get_pkt_cache_name(pkt_cache->index_by_name, &name_key);
+  if (k == kh_end(pkt_cache->index_by_name)) {
+    *lookup_result = PKT_CACHE_LU_NONE;
+    return NULL;
+  }
+
+  off_t index = kh_val(pkt_cache->index_by_name, k);
+  pkt_cache_entry_t *entry = pkt_cache_at(pkt_cache, index);
+  assert(entry);
+  bool expired = false;
+  if (entry->has_expire_ts && ticks_now() >= entry->expire_ts) {
+    expired = true;
+  }
+
+  if (entry->entry_type == PKT_CACHE_CS_TYPE) {
+    if (expired)
+      *lookup_result = PKT_CACHE_LU_DATA_EXPIRED;
+    else
+      *lookup_result = PKT_CACHE_LU_DATA_NOT_EXPIRED;
+  } else {  // PKT_CACHE_PIT_TYPE
+    if (expired)
+      *lookup_result = PKT_CACHE_LU_INTEREST_EXPIRED;
+    else
+      *lookup_result = PKT_CACHE_LU_INTEREST_NOT_EXPIRED;
+  }
+
+  *entry_id = index;
+  return entry;
+}
+
+void pkt_cache_cs_remove_entry(pkt_cache_t *pkt_cache, pkt_cache_entry_t *entry,
+                               msgbuf_pool_t *msgbuf_pool, bool is_evicted) {
+  assert(pkt_cache);
+  assert(entry);
+  assert(entry->entry_type == PKT_CACHE_CS_TYPE);
+
+  off_t msgbuf_id = entry->u.cs_entry.msgbuf_id;
+  msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id);
+
+  Name name_key = name_key_factory(msgbuf_get_name(msgbuf));
+  khiter_t k = kh_get_pkt_cache_name(pkt_cache->index_by_name, &name_key);
+  assert(k != kh_end(pkt_cache->index_by_name));
+  free((Name *)kh_key(pkt_cache->index_by_name, k));
+  kh_del(pkt_cache_name, pkt_cache->index_by_name, k);
+
+  // Do not update the LRU cache for evicted entries
+  if (!is_evicted) cs_vft[pkt_cache->cs->type]->remove_entry(pkt_cache, entry);
+
+  pkt_cache->cs->num_entries--;
+  pool_put(pkt_cache->entries, entry);
+
+  WITH_DEBUG({
+    char *name_str = name_ToString(msgbuf_get_name(msgbuf));
+    DEBUG("Packet %s removed from CS", name_str);
+    free(name_str);
+  })
+
+  msgbuf_pool_release(msgbuf_pool, &msgbuf);
+}
+
+void pkt_cache_pit_remove_entry(pkt_cache_t *pkt_cache,
+                                pkt_cache_entry_t *entry, const Name *name) {
+  assert(pkt_cache);
+  assert(entry);
+  assert(entry->entry_type == PKT_CACHE_PIT_TYPE);
+
+  Name name_key = name_key_factory(name);
+  khiter_t k = kh_get_pkt_cache_name(pkt_cache->index_by_name, &name_key);
+  assert(k != kh_end(pkt_cache->index_by_name));
+  free((Name *)kh_key(pkt_cache->index_by_name, k));
+  kh_del(pkt_cache_name, pkt_cache->index_by_name, k);
+
+  pool_put(pkt_cache->entries, entry);
+
+  WITH_DEBUG({
+    char *name_str = name_ToString(name);
+    DEBUG("Packet %s removed from PIT", name_str);
+    free(name_str);
+  })
+}
+
+void _pkt_cache_add_to_cs(pkt_cache_t *pkt_cache, pkt_cache_entry_t *entry,
+                          msgbuf_pool_t *msgbuf_pool, msgbuf_t *msgbuf,
+                          off_t msgbuf_id, off_t entry_id) {
+  entry->u.cs_entry =
+      (cs_entry_t){.msgbuf_id = msgbuf_id,
+                   .lru = {.prev = INVALID_ENTRY_ID, .next = INVALID_ENTRY_ID}};
+  entry->create_ts = ticks_now();
+  entry->expire_ts = ticks_now() + msgbuf_get_data_expiry_time(msgbuf);
+  entry->has_expire_ts = true;
+  entry->entry_type = PKT_CACHE_CS_TYPE;
+
+  pkt_cache->cs->num_entries++;
+
+  int tail_id = pkt_cache->cs->lru.tail;
+  int result = cs_vft[pkt_cache->cs->type]->add_entry(pkt_cache, entry_id);
+  if (result == LRU_EVICTION) {
+    // Remove tail (already removed from LRU cache)
+    pkt_cache_entry_t *tail = pkt_cache_entry_at(pkt_cache, tail_id);
+    assert(tail->entry_type == PKT_CACHE_CS_TYPE);
+    pkt_cache_cs_remove_entry(pkt_cache, tail, msgbuf_pool, true);
+  }
+
+  // Acquired by CS
+  msgbuf_pool_acquire(msgbuf);
+}
+
+void pkt_cache_pit_to_cs(pkt_cache_t *pkt_cache,
+                         pkt_cache_entry_t *interest_entry,
+                         msgbuf_pool_t *msgbuf_pool, msgbuf_t *data_msgbuf,
+                         off_t data_msgbuf_id, off_t entry_id) {
+  assert(pkt_cache);
+  assert(interest_entry);
+  assert(interest_entry->entry_type == PKT_CACHE_PIT_TYPE);
+
+  _pkt_cache_add_to_cs(pkt_cache, interest_entry, msgbuf_pool, data_msgbuf,
+                       data_msgbuf_id, entry_id);
+}
+
+void _pkt_cache_add_to_pit(pkt_cache_t *pkt_cache, pkt_cache_entry_t *entry,
+                           const msgbuf_t *msgbuf) {
+  entry->u.pit_entry = (pit_entry_t){
+      .ingressIdSet = NEXTHOPS_EMPTY,
+      .egressIdSet = NEXTHOPS_EMPTY,
+      .fib_entry = NULL,
+  };
+  pit_entry_ingress_add(&entry->u.pit_entry, msgbuf_get_connection_id(msgbuf));
+
+  entry->create_ts = ticks_now();
+  entry->expire_ts = ticks_now() + msgbuf_get_interest_lifetime(msgbuf);
+  entry->has_expire_ts = true;
+  entry->entry_type = PKT_CACHE_PIT_TYPE;
+}
+
+void pkt_cache_cs_to_pit(pkt_cache_t *pkt_cache, pkt_cache_entry_t *entry,
+                         msgbuf_pool_t *msgbuf_pool, const msgbuf_t *msgbuf,
+                         off_t msgbuf_id, off_t entry_id) {
+  assert(pkt_cache);
+  assert(entry);
+  assert(entry->entry_type == PKT_CACHE_CS_TYPE);
+
+  // Release data associated with expired CS entry
+  off_t cs_entry_msgbuf_id = entry->u.cs_entry.msgbuf_id;
+  msgbuf_t *cs_entry_msgbuf = msgbuf_pool_at(msgbuf_pool, cs_entry_msgbuf_id);
+  msgbuf_pool_release(msgbuf_pool, &cs_entry_msgbuf);
+
+  cs_vft[pkt_cache->cs->type]->remove_entry(pkt_cache, entry);
+  _pkt_cache_add_to_pit(pkt_cache, entry, msgbuf);
+  pkt_cache->cs->num_entries--;
+}
+
+void pkt_cache_update_cs(pkt_cache_t *pkt_cache, msgbuf_pool_t *msgbuf_pool,
+                         pkt_cache_entry_t *entry, msgbuf_t *msgbuf,
+                         off_t msgbuf_id) {
+  assert(pkt_cache);
+  assert(entry);
+  assert(entry->entry_type == PKT_CACHE_CS_TYPE);
+
+  // Release previous msgbuf and acquire new one
+  msgbuf_t *prev_msgbuf =
+      msgbuf_pool_at(msgbuf_pool, entry->u.cs_entry.msgbuf_id);
+  msgbuf_pool_release(msgbuf_pool, &prev_msgbuf);
+  msgbuf_pool_acquire(msgbuf);
+
+  entry->u.cs_entry.msgbuf_id = msgbuf_id;
+  entry->create_ts = ticks_now();
+  entry->expire_ts = ticks_now() + msgbuf_get_data_expiry_time(msgbuf);
+  entry->has_expire_ts = true;
+
+  cs_vft[pkt_cache->cs->type]->update_entry(pkt_cache, entry);
+}
+
+pkt_cache_entry_t *pkt_cache_add_to_pit(pkt_cache_t *pkt_cache,
+                                        const msgbuf_t *msgbuf) {
+  assert(pkt_cache);
+
+  pkt_cache_entry_t *entry =
+      pkt_cache_allocate(pkt_cache, msgbuf_get_name(msgbuf));
+  _pkt_cache_add_to_pit(pkt_cache, entry, msgbuf);
+  return entry;
+}
+
+pkt_cache_entry_t *pkt_cache_add_to_cs(pkt_cache_t *pkt_cache,
+                                       msgbuf_pool_t *msgbuf_pool,
+                                       msgbuf_t *msgbuf, off_t msgbuf_id) {
+  assert(pkt_cache);
+
+  pkt_cache_entry_t *entry =
+      pkt_cache_allocate(pkt_cache, msgbuf_get_name(msgbuf));
+  off_t entry_id = pkt_cache_get_entry_id(pkt_cache, entry);
+  _pkt_cache_add_to_cs(pkt_cache, entry, msgbuf_pool, msgbuf, msgbuf_id,
+                       entry_id);
+
+  return entry;
+}
+
+void pkt_cache_update_pit(pkt_cache_t *pkt_cache, pkt_cache_entry_t *entry,
+                          const msgbuf_t *msgbuf) {
+  assert(pkt_cache);
+  assert(entry);
+  assert(entry->entry_type == PKT_CACHE_PIT_TYPE);
+
+  pit_entry_t *pit_entry = &entry->u.pit_entry;
+  fib_entry_t *fib_entry = pit_entry_get_fib_entry(pit_entry);
+  if (fib_entry)
+    fib_entry_on_timeout(fib_entry, pit_entry_get_egress(pit_entry));
+
+  _pkt_cache_add_to_pit(pkt_cache, entry, msgbuf);
+}
+
+bool pkt_cache_try_aggregate_in_pit(pkt_cache_t *pkt_cache,
+                                    pkt_cache_entry_t *entry,
+                                    const msgbuf_t *msgbuf) {
+  assert(pkt_cache);
+  assert(entry);
+  assert(entry->entry_type == PKT_CACHE_PIT_TYPE);
+
+  pit_entry_t *pit_entry = &entry->u.pit_entry;
+
+  // Extend entry lifetime
+  Ticks expire_ts = ticks_now() + msgbuf_get_interest_lifetime(msgbuf);
+  if (expire_ts > entry->expire_ts) entry->expire_ts = expire_ts;
+
+  // Check if the reverse path is already present
+  // in the PIT entry (i.e. it is a retransmission)
+  unsigned connection_id = msgbuf_get_connection_id(msgbuf);
+  bool is_aggregated = !pit_entry_ingress_contains(pit_entry, connection_id);
+  if (is_aggregated) pit_entry_ingress_add(pit_entry, connection_id);
+
+  WITH_DEBUG({
+    char *name_str = name_ToString(msgbuf_get_name(msgbuf));
+    if (is_aggregated) {
+      DEBUG("Interest %s already existing (expiry %lu): aggregate", name_str,
+            entry->expire_ts);
+    } else {
+      DEBUG("Interest %s already existing (expiry %lu): retransmit", name_str,
+            entry->expire_ts);
+    }
+    free(name_str);
+  })
+
+  return is_aggregated;
+}
+
+nexthops_t *pkt_cache_on_data(pkt_cache_t *pkt_cache,
+                              msgbuf_pool_t *msgbuf_pool, off_t msgbuf_id,
+                              bool is_cs_store_enabled,
+                              bool is_connection_local, bool *wrong_egress,
+                              pkt_cache_verdict_t *verdict) {
+  assert(pkt_cache);
+  assert(msgbuf_id_is_valid(msgbuf_id));
+
+  msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id);
+  assert(msgbuf_get_type(msgbuf) == MSGBUF_TYPE_DATA);
+
+  *wrong_egress = false;
+  off_t entry_id;
+  pkt_cache_lookup_t lookup_result;
+  pkt_cache_entry_t *entry =
+      pkt_cache_lookup(pkt_cache, msgbuf_get_name(msgbuf), msgbuf_pool,
+                       &lookup_result, &entry_id, true);
+
+  pit_entry_t *pit_entry;
+  fib_entry_t *fib_entry;
+  nexthops_t *nexthops = NULL;
+  nexthops_t *nexthops_copy;
+  switch (lookup_result) {
+    case PKT_CACHE_LU_INTEREST_NOT_EXPIRED:
+      pit_entry = &entry->u.pit_entry;
+      fib_entry = pit_entry_get_fib_entry(pit_entry);
+      if (fib_entry)
+        fib_entry_on_data(fib_entry, pit_entry_get_egress(pit_entry), msgbuf,
+                          entry->create_ts, ticks_now());
+
+      // Check if the data is coming from the exepected connection
+      nexthops_t *egressIdSet = pit_entry_get_egress(pit_entry);
+      unsigned egress_connection = msgbuf_get_connection_id(msgbuf);
+      if (!nexthops_contains(egressIdSet, egress_connection)) {
+        *wrong_egress = true;
+        return NULL;
+      }
+
+      // XXX TODO : be sure nexthops are valid b/c pit entry is removed
+      // XXX TODO eventually pass holding structure as parameter
+      nexthops = pit_entry_get_ingress(pit_entry);
+      assert(nexthops);
+
+      nexthops_copy = (nexthops_t *)malloc(sizeof(*nexthops_copy));
+      *nexthops_copy = *nexthops;
+
+      if (is_cs_store_enabled) {
+        pkt_cache_pit_to_cs(pkt_cache, entry, msgbuf_pool, msgbuf, msgbuf_id,
+                            entry_id);
+        *verdict = PKT_CACHE_VERDICT_FORWARD_DATA;
+      } else {
+        pkt_cache_pit_remove_entry(pkt_cache, entry, msgbuf_get_name(msgbuf));
+        *verdict = PKT_CACHE_VERDICT_CLEAR_DATA;
+      }
+
+      return nexthops_copy;
+
+    // Data packets are stored in the content store even in the case
+    // where there is no match in the PIT, to allow applications to push
+    // content to the forwarder's CS. This behavior is allowed only for
+    // local faces.
+    case PKT_CACHE_LU_INTEREST_EXPIRED:
+      if (is_cs_store_enabled && is_connection_local) {
+        pkt_cache_pit_to_cs(pkt_cache, entry, msgbuf_pool, msgbuf, msgbuf_id,
+                            entry_id);
+        *verdict = PKT_CACHE_VERDICT_STORE_DATA;
+      } else {
+        pkt_cache_pit_remove_entry(pkt_cache, entry, msgbuf_get_name(msgbuf));
+        *verdict = PKT_CACHE_VERDICT_CLEAR_DATA;
+      }
+      return NULL;
+
+    case PKT_CACHE_LU_NONE:
+      *verdict = PKT_CACHE_VERDICT_IGNORE_DATA;
+      if (is_cs_store_enabled && is_connection_local) {
+        pkt_cache_add_to_cs(pkt_cache, msgbuf_pool, msgbuf, msgbuf_id);
+        *verdict = PKT_CACHE_VERDICT_STORE_DATA;
+      }
+      return NULL;
+
+    case PKT_CACHE_LU_DATA_EXPIRED:
+      if (is_cs_store_enabled && is_connection_local) {
+        pkt_cache_update_cs(pkt_cache, msgbuf_pool, entry, msgbuf, msgbuf_id);
+        *verdict = PKT_CACHE_VERDICT_UPDATE_DATA;
+      } else {
+        pkt_cache_cs_remove_entry(pkt_cache, entry, msgbuf_pool, false);
+        *verdict = PKT_CACHE_VERDICT_CLEAR_DATA;
+      }
+      return NULL;
+
+    case PKT_CACHE_LU_DATA_NOT_EXPIRED:
+      *verdict = PKT_CACHE_VERDICT_IGNORE_DATA;
+      if (is_cs_store_enabled && is_connection_local) {
+        pkt_cache_update_cs(pkt_cache, msgbuf_pool, entry, msgbuf, msgbuf_id);
+        *verdict = PKT_CACHE_VERDICT_UPDATE_DATA;
+      }
+      return NULL;
+
+    default:
+      ERROR("Inivalid packet cache content");
+      return NULL;
+  }
+}
+
+void pkt_cache_on_interest(pkt_cache_t *pkt_cache, msgbuf_pool_t *msgbuf_pool,
+                           off_t msgbuf_id, pkt_cache_verdict_t *verdict,
+                           off_t *data_msgbuf_id, pkt_cache_entry_t **entry_ptr,
+                           bool is_serve_from_cs_enabled) {
+  assert(pkt_cache);
+  assert(msgbuf_id_is_valid(msgbuf_id));
+
+  msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id);
+  assert(msgbuf_get_type(msgbuf) == MSGBUF_TYPE_INTEREST);
+
+  off_t entry_id;
+  pkt_cache_lookup_t lookup_result;
+  pkt_cache_entry_t *entry =
+      pkt_cache_lookup(pkt_cache, msgbuf_get_name(msgbuf), msgbuf_pool,
+                       &lookup_result, &entry_id, is_serve_from_cs_enabled);
+  *entry_ptr = entry;
+
+  cs_entry_t *cs_entry = NULL;
+  bool is_cs_miss = true;
+  bool is_aggregated;
+  switch (lookup_result) {
+    case PKT_CACHE_LU_NONE:
+      *verdict = PKT_CACHE_VERDICT_FORWARD_INTEREST;
+      break;
+
+    case PKT_CACHE_LU_DATA_NOT_EXPIRED:
+      if (!is_serve_from_cs_enabled) goto PKT_CACHE_LU_DATA_EXPIRED;
+
+      cs_entry = &entry->u.cs_entry;
+      *data_msgbuf_id = cs_entry->msgbuf_id;
+
+      *verdict = PKT_CACHE_VERDICT_FORWARD_DATA;
+      is_cs_miss = false;
+      break;
+
+    case PKT_CACHE_LU_INTEREST_NOT_EXPIRED:
+      is_aggregated = pkt_cache_try_aggregate_in_pit(pkt_cache, entry, msgbuf);
+
+      *verdict = is_aggregated ? PKT_CACHE_VERDICT_AGGREGATE_INTEREST
+                               : PKT_CACHE_VERDICT_RETRANSMIT_INTEREST;
+      break;
+
+    case PKT_CACHE_LU_INTEREST_EXPIRED:
+      pkt_cache_update_pit(pkt_cache, entry, msgbuf);
+
+      *verdict = PKT_CACHE_VERDICT_INTEREST_EXPIRED_FORWARD_INTEREST;
+      break;
+
+    case PKT_CACHE_LU_DATA_EXPIRED:
+    PKT_CACHE_LU_DATA_EXPIRED:
+      pkt_cache_cs_to_pit(pkt_cache, entry, msgbuf_pool, msgbuf, msgbuf_id,
+                          entry_id);
+
+      *verdict = PKT_CACHE_VERDICT_DATA_EXPIRED_FORWARD_INTEREST;
+      break;
+
+    default:
+      *verdict = PKT_CACHE_VERDICT_ERROR;
+  }
+  is_cs_miss ? cs_miss(pkt_cache->cs) : cs_hit(pkt_cache->cs);
+}
+
+void pkt_cache_cs_clear(pkt_cache_t *pkt_cache) {
+  assert(pkt_cache);
+
+  const Name *k_name;
+  unsigned v_pool_pos;
+  kh_foreach(pkt_cache->index_by_name, k_name, v_pool_pos,
+             {
+               khiter_t k =
+                   kh_get_pkt_cache_name(pkt_cache->index_by_name, k_name);
+               assert(k != kh_end(pkt_cache->index_by_name));
+
+               pkt_cache_entry_t *entry = pkt_cache_at(pkt_cache, v_pool_pos);
+               if (entry->entry_type == PKT_CACHE_CS_TYPE) {
+                 // Remove from hashmap
+                 free((Name *)kh_key(pkt_cache->index_by_name, k));
+                 kh_del(pkt_cache_name, pkt_cache->index_by_name, k);
+
+                 // Remove from pool
+                 pool_put(pkt_cache->entries, entry);
+               }
+             })
+
+      // Re-create CS
+      cs_clear(pkt_cache->cs);
+}
+
+size_t pkt_cache_get_size(pkt_cache_t *pkt_cache) {
+  uint64_t hashmap_size = kh_size(pkt_cache->index_by_name);
+  return hashmap_size;
+}
+
+size_t pkt_cache_get_cs_size(pkt_cache_t *pkt_cache) {
+  return pkt_cache->cs->num_entries;
+}
+
+size_t pkt_cache_get_num_cs_stale_entries(pkt_cache_t *pkt_cache) {
+  size_t num_stale_entries = 0;
+  Ticks now = ticks_now();
+  pkt_cache_entry_t *entry;
+
+  pool_foreach(pkt_cache->entries, entry, {
+    if (entry->entry_type == PKT_CACHE_CS_TYPE && entry->has_expire_ts &&
+        now >= entry->expire_ts) {
+      num_stale_entries++;
+    }
+  });
+
+  return num_stale_entries;
+}
+
+int pkt_cache_set_cs_size(pkt_cache_t *pkt_cache, size_t size) {
+  if (pkt_cache->cs->num_entries > size) return -1;
+
+  pkt_cache->cs->max_size = size;
+  return 0;
+}
+
+size_t pkt_cache_get_pit_size(pkt_cache_t *pkt_cache) {
+  uint64_t hashmap_size = kh_size(pkt_cache->index_by_name);
+  uint64_t pit_size = hashmap_size - pkt_cache->cs->num_entries;
+  return pit_size;
+}
+
+void pkt_cache_log(pkt_cache_t *pkt_cache) {
+  uint64_t hashmap_size = kh_size(pkt_cache->index_by_name);
+  uint64_t pit_size = hashmap_size - pkt_cache->cs->num_entries;
+  DEBUG("Packet cache: total size = %lu, PIT size = %lu, CS size = %u",
+        hashmap_size, pit_size, pkt_cache->cs->num_entries);
+
+  cs_log(pkt_cache->cs);
+}
diff --git a/hicn-light/src/hicn/core/packet_cache.h b/hicn-light/src/hicn/core/packet_cache.h
new file mode 100644
index 000000000..ccfc83b97
--- /dev/null
+++ b/hicn-light/src/hicn/core/packet_cache.h
@@ -0,0 +1,445 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file packet_cache.h
+ * \brief hICN packet cache
+ *
+ * The packet cache is a data structure that merges together the PIT and the CS,
+ * to which it holds a reference.
+ * It contains PIT and CS entries, indexed in a hashtable by hICN packet names.
+ *
+ * Each entry has shared fields, e.g. entry type (PIT or CS) and timestamps,
+ * which are used by both PIT and CS entries. In addition, a C union holds
+ * the PIT or CS specific fields.
+ *
+ * Having a single entry that can hold PIT or CS entries allows to reduce
+ * the number of lookups.
+ */
+
+#ifndef HICNLIGHT_PACKET_CACHE_H
+#define HICNLIGHT_PACKET_CACHE_H
+
+#include "content_store.h"
+#include "pit.h"
+#include "msgbuf_pool.h"
+#include "../base/khash.h"
+#include "../content_store/lru.h"
+
+#define DEFAULT_PKT_CACHE_SIZE 2048
+
+typedef enum { PKT_CACHE_PIT_TYPE, PKT_CACHE_CS_TYPE } pkt_cache_entry_type_t;
+
+/**
+ * @brief Return a Name that can be used as key for hash table lookups.
+ * The returned Name is a copy of the input one but it is "memsetted"
+ * to ensure successful hash calculation.
+ */
+static inline Name name_key_factory(const Name *name) {
+  NameBitvector *content_name = name_GetContentName(name);
+
+  Name name_key;
+  memset(&name_key, 0, sizeof(Name));
+
+  name_key.content_name = *content_name;
+  name_key.segment = name_GetSegment(name);
+  name_key.name_hash = name_HashCode(name);
+
+  return name_key;
+}
+
+KHASH_INIT(pkt_cache_name, const Name *, unsigned, 1, name_HashCode,
+           name_Equals);
+
+typedef struct {
+  pkt_cache_entry_type_t entry_type;
+
+  Ticks create_ts;
+  Ticks expire_ts;
+  // TODO(eloparco): Is it necessary?
+  // Now it is always set to true
+  bool has_expire_ts;
+
+  union {
+    pit_entry_t pit_entry;
+    cs_entry_t cs_entry;
+  } u;
+} pkt_cache_entry_t;
+
+typedef struct {
+  pit_t *pit;
+  cs_t *cs;
+  pkt_cache_entry_t *entries;
+  kh_pkt_cache_name_t *index_by_name;
+} pkt_cache_t;
+
+/**
+ * @brief Create a new packet cache.
+ *
+ * @return pkt_cache_t* The newly created packet cache
+ */
+pkt_cache_t *pkt_cache_create(size_t cs_size);
+
+#define _pc_var(x) _pkt_cache_##x
+/**
+ * @brief Add an entry with the specified name to the packet cache.
+ *
+ * @param[in] pkt_cache Pointer to the msgbuf pool data structure to use.
+ * @param[in, out] entry Empty entry that will be used to return the
+ * allocated one from the msgbuf pool.
+ * * @param[in] name Name to use
+ */
+static inline pkt_cache_entry_t *pkt_cache_allocate(
+    const pkt_cache_t *pkt_cache, const Name *name) {
+  pkt_cache_entry_t *entry = NULL;
+  pool_get(pkt_cache->entries, entry);
+  assert(entry);
+
+  off_t id = entry - pkt_cache->entries;
+  int res;
+
+  // Generate the key (starting from the name) to use in the name hash table
+  NameBitvector *nb = name_GetContentName(name);
+  Name *name_copy = (Name *)calloc(1, sizeof(Name));
+  name_copy->content_name = *nb;
+  name_copy->segment = name_GetSegment(name);
+  name_copy->name_hash = name_HashCode(name);
+
+  // Add in name hash table
+  khiter_t k = kh_put_pkt_cache_name(pkt_cache->index_by_name, name_copy, &res);
+  assert(res != -1);
+  kh_value(pkt_cache->index_by_name, k) = id;
+
+  return entry;
+}
+
+/**
+ * @brief Free a packet cache data structure.
+ *
+ * @param[in] pkt_cache Pointer to packet cache data structure to free.
+ */
+void pkt_cache_free(pkt_cache_t *pkt_cache);
+
+/**
+ * @brief Get a reference to the PIT data structure contained in the packet
+ * cache.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to get the
+ * PIT from.
+ */
+pit_t *pkt_cache_get_pit(pkt_cache_t *pkt_cache);
+
+/**
+ * @brief Get a reference to the CS data structure contained in the packet
+ * cache.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to get the CS
+ * from.
+ */
+cs_t *pkt_cache_get_cs(pkt_cache_t *pkt_cache);
+
+/**
+ * @brief Return the total packet cache size (i.e. PIT + CS).
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ */
+size_t pkt_cache_get_size(pkt_cache_t *pkt_cache);
+
+/**
+ * @brief Return the number of stale entries (i.e. expired) in the CS.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ */
+size_t pkt_cache_get_num_cs_stale_entries(pkt_cache_t *pkt_cache);
+
+/**
+ * @brief Change the maximum capacity of the content store (LRU eviction will be
+ * used after reaching the provided size)
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ * @param[in] size Maximum size of the content store
+ * @return int 0 if success, -1 if the provided maximum size is smaller than the
+ * number of elements currently stored in the CS
+ */
+int pkt_cache_set_cs_size(pkt_cache_t *pkt_cache, size_t size);
+
+/**
+ * @brief Return the content store size.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ */
+size_t pkt_cache_get_cs_size(pkt_cache_t *pkt_cache);
+
+/**
+ * @brief Return the PIT size.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ */
+size_t pkt_cache_get_pit_size(pkt_cache_t *pkt_cache);
+
+typedef enum {
+  PKT_CACHE_LU_INTEREST_NOT_EXPIRED,
+  PKT_CACHE_LU_INTEREST_EXPIRED,
+  PKT_CACHE_LU_DATA_NOT_EXPIRED,
+  PKT_CACHE_LU_DATA_EXPIRED,
+  PKT_CACHE_LU_NONE
+} pkt_cache_lookup_t;
+
+typedef enum {
+  PKT_CACHE_VERDICT_FORWARD_INTEREST,
+  PKT_CACHE_VERDICT_AGGREGATE_INTEREST,
+  PKT_CACHE_VERDICT_RETRANSMIT_INTEREST,
+  PKT_CACHE_VERDICT_FORWARD_DATA,
+  PKT_CACHE_VERDICT_INTEREST_EXPIRED_FORWARD_INTEREST,
+  PKT_CACHE_VERDICT_DATA_EXPIRED_FORWARD_INTEREST,
+  PKT_CACHE_VERDICT_STORE_DATA,
+  PKT_CACHE_VERDICT_CLEAR_DATA,
+  PKT_CACHE_VERDICT_UPDATE_DATA,
+  PKT_CACHE_VERDICT_IGNORE_DATA,
+  PKT_CACHE_VERDICT_ERROR
+} pkt_cache_verdict_t;
+
+#define pkt_cache_entry_get_create_ts(E) ((E)->create_ts)
+#define pkt_cache_entry_get_expire_ts(E) ((E)->expire_ts)
+#define pkt_cache_entry_set_expire_ts(E, EXPIRY_TIME) \
+  (entry)->expire_ts = EXPIRY_TIME
+#define pkt_cache_get_entry_id(pkt_cache, entry) (entry - pkt_cache->entries)
+#define pkt_cache_entry_at(pkt_cache, id) (&(pkt_cache)->entries[id])
+#define pkt_cache_at(pkt_cache, i) (pkt_cache->entries + i)
+
+/**
+ * @brief Retrieve from the packet cache the entry associated with the specified
+ * name.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to retrieve
+ * the entry from
+ * @param[in] name Packet name to use for the lookup
+ * @param[in] msgbuf_pool Pointer to the msgbuf pool data structure to use
+ * @param[in, out] lookup_result Pointer to store the result of the lookup
+ * @param[in, out] entry_id Pointer to store the entry_id in case of a lookup
+ * match
+ * @param[in] is_serve_from_cs_enabled Boolean to specify if the forwarder is
+ * allowed to serve contents from the CS
+ * @return pkt_cache_entry_t* Entry retrieved, NULL if none found
+ */
+pkt_cache_entry_t *pkt_cache_lookup(pkt_cache_t *pkt_cache, const Name *name,
+                                    msgbuf_pool_t *msgbuf_pool,
+                                    pkt_cache_lookup_t *lookup_result,
+                                    off_t *entry_id,
+                                    bool is_serve_from_cs_enabled);
+
+/**
+ * @brief Clear the content of the CS.
+ *
+ * @param pkt_cache Pointer to the packet cache data structure to use
+ */
+void pkt_cache_cs_clear(pkt_cache_t *pkt_cache);
+
+/**
+ * @brief Log packet cache statistics.
+ *
+ * @param pkt_cache Pointer to the packet cache data structure to use
+ */
+void pkt_cache_log(pkt_cache_t *pkt_cache);
+
+// TODO(eloparco): To implement
+void pkt_cache_print(const pkt_cache_t *pkt_cache);
+
+/************** Packet cache entry operations *************/
+
+/**
+ * @brief Remove a content store entry from the packet cache.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ * @param[in] entry Pointer to the content store entry to remove
+ * @param[in] msgbuf_pool Pointer to the msgbuf pool data structure to use
+ * @param[in] is_evicted Boolean to specify if the content store entry has
+ * already been evicted from the LRU cache
+ */
+void pkt_cache_cs_remove_entry(pkt_cache_t *pkt_cache, pkt_cache_entry_t *entry,
+                               msgbuf_pool_t *msgbuf_pool, bool is_evicted);
+
+/**
+ * @brief Remove a PIT entry from the packet cache.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ * @param[in] entry Pointer to the PITe entry to remove
+ * @param[in] name Name associated with the PIT entry to remove
+ */
+void pkt_cache_pit_remove_entry(pkt_cache_t *pkt_cache,
+                                pkt_cache_entry_t *entry, const Name *name);
+
+/**
+ * @brief Convert a PIT entry to a CS entry.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ * @param[in, out] entry Pointer to the PIT entry to replace
+ * @param[in] msgbuf_pool Pointer to the msgbuf pool data structure to use
+ * @param[in] msgbuf Pointer to the msgbuf associated with the CS entry to
+ * insert
+ * @param[in] msgbuf_id Msgbuf ID (i.e. ID in the msgbuf pool) associated with
+ * the CS entry to insert
+ * @param[in] entry_id Entry ID (i.e. ID in the packet cache pool of entries)
+ * associated with the PIT entry to replace
+ */
+void pkt_cache_pit_to_cs(pkt_cache_t *pkt_cache, pkt_cache_entry_t *entry,
+                         msgbuf_pool_t *msgbuf_pool, msgbuf_t *msgbuf,
+                         off_t msgbuf_id, off_t entry_id);
+
+/**
+ * @brief Convert a CS entry to a PIT entry.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ * @param[in, out] entry Pointer to the CS entry to replace
+ * @param[in] msgbuf Pointer to the msgbuf associated with the PIT entry to
+ * insert
+ * @param[in] msgbuf_id Msgbuf ID (i.e. ID in the msgbuf pool) associated with
+ * the PIT entry to insert
+ * @param[in] entry_id Entry ID (i.e. ID in the packet cache pool of entries)
+ * associated with the CS entry to replace
+ */
+void pkt_cache_cs_to_pit(pkt_cache_t *pkt_cache, pkt_cache_entry_t *entry,
+                         msgbuf_pool_t *msgbuf_pool, const msgbuf_t *msgbuf,
+                         off_t msgbuf_id, off_t entry_id);
+
+/**
+ * @brief Add PIT entry to the packet cache.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ * @param[in] msgbuf Pointer to the msgbuf associated with the PIT entry to
+ * insert
+ * @return pkt_cache_entry_t* Pointer to the packet cache (PIT) entry created
+ */
+pkt_cache_entry_t *pkt_cache_add_to_pit(pkt_cache_t *pkt_cache,
+                                        const msgbuf_t *msgbuf);
+
+/**
+ * @brief Add CS entry to the packet cache.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ * @param[in] msgbuf_pool Pointer to the msgbuf pool data structure to use
+ * @param[in] msgbuf Pointer to the msgbuf associated with the CS entry to
+ * insert
+ * @param[in] msgbuf_id Msgbuf ID (i.e. ID in the msgbuf pool) associated with
+ * the CS entry to insert
+ * @return pkt_cache_entry_t* Pointer to the packet cache (CS) entry created
+ */
+pkt_cache_entry_t *pkt_cache_add_to_cs(pkt_cache_t *pkt_cache,
+                                       msgbuf_pool_t *msgbuf_pool,
+                                       msgbuf_t *msgbuf, off_t msgbuf_id);
+
+/**
+ * @brief Update PIT entry in the packet cache in case of an expired PIT entry.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ * @param[in, out] entry Pointer to the PIT entry to update
+ * @param[in] msgbuf Pointer to the msgbuf associated with the PIT entry to
+ * update
+ */
+void pkt_cache_update_pit(pkt_cache_t *pkt_cache, pkt_cache_entry_t *entry,
+                          const msgbuf_t *msgbuf);
+
+/**
+ * @brief Update CS entry in the packet cache.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ * @param[in] msgbuf_pool Pointer to the msgbuf pool data structure to use
+ * @param[in, out] entry Pointer to the CS entry to update
+ * @param[in] msgbuf Pointer to the msgbuf associated with the CS entry to
+ * update
+ * @param msgbuf_id Msgbuf ID (i.e. ID in the msgbuf pool) associated with the
+ * CS entry to update
+ */
+void pkt_cache_update_cs(pkt_cache_t *pkt_cache, msgbuf_pool_t *msgbuf_pool,
+                         pkt_cache_entry_t *entry, msgbuf_t *msgbuf,
+                         off_t msgbuf_id);
+
+/**
+ * @brief Update PIT entry in the packet cache in case of retransmission or
+ * aggregation.
+ *
+ * @param[in] pkt_cache Pointer to the packet cache data structure to use
+ * @param[in, out] entry Pointer to the PIT entry to update
+ * @param[in] msgbuf Pointer to the msgbuf associated with the PIT entry to
+ * update
+ * @return true If aggregation (interest sent from a connection not stored in
+ * the PIT entry)
+ * @return false If retransmission (interest sent from a connection already
+ * stored in the PIT entry)
+ */
+bool pkt_cache_try_aggregate_in_pit(pkt_cache_t *pkt_cache,
+                                    pkt_cache_entry_t *entry,
+                                    const msgbuf_t *msgbuf);
+
+/************ Handle data/interest packets received *******/
+
+/**
+ * @brief Handle data packet reception.
+ * @details Perform packet cache lookup and execute operations based on it. If:
+ *      - INTEREST not expired: Convert PIT entry to CS entry; return the
+ *                              nexthops (that can be used to forward the data
+ *                              packet now stored in the CS)
+ *      - INTEREST expired: Convert PIT entry to CS entry
+ *      - DATA expired/not expired: Update the CS
+ *      - No match: Add data packet to CS
+ */
+nexthops_t *pkt_cache_on_data(pkt_cache_t *pkt_cache,
+                              msgbuf_pool_t *msgbuf_pool, off_t msgbuf_id,
+                              bool is_cs_store_enabled,
+                              bool is_connection_local, bool *wrong_egress,
+                              pkt_cache_verdict_t *verdict);
+
+/**
+ * @brief Handle interest packet reception.
+ * @details Perform packet cache lookup and execute operations based on it. If:
+ *      - No match: Do nothing
+ *      - DATA not expired: get data message from CS
+ *      - INTEREST not expired: Aggregate or retransmit the interest received;
+ *      - INTEREST expired: Update the PIT;
+ *      - DATA expired: Convert CS entry to PIT entry;
+ */
+void pkt_cache_on_interest(pkt_cache_t *pkt_cache, msgbuf_pool_t *msgbuf_pool,
+                           off_t msgbuf_id, pkt_cache_verdict_t *verdict,
+                           off_t *data_msgbuf_id, pkt_cache_entry_t **entry_ptr,
+                           bool is_serve_from_cs_enabled);
+
+/************** Content Store *****************************/
+
+typedef struct {
+  const char *name;
+  void (*initialize)(cs_t *cs);
+  void (*finalize)(cs_t *cs);
+  int (*add_entry)(pkt_cache_t *pkt_cache, off_t entry_id);
+  void (*update_entry)(pkt_cache_t *pkt_cache, pkt_cache_entry_t *entry);
+  int (*remove_entry)(pkt_cache_t *pkt_cache, pkt_cache_entry_t *entry);
+} cs_ops_t;
+extern const cs_ops_t *const cs_vft[];
+
+/**
+ * @brief Initialize the virtual function table used for the
+ * CS cache strategy (e.g. LRU).
+ *
+ */
+#define DECLARE_CS(NAME)                        \
+  const cs_ops_t cs_##NAME = {                  \
+      .name = #NAME,                            \
+      .initialize = cs_##NAME##_initialize,     \
+      .finalize = cs_##NAME##_finalize,         \
+      .add_entry = cs_##NAME##_add_entry,       \
+      .update_entry = cs_##NAME##_update_entry, \
+      .remove_entry = cs_##NAME##_remove_entry, \
+  }
+
+#endif /* HICNLIGHT_PACKET_CACHE_H */
diff --git a/hicn-light/src/hicn/core/pit.c b/hicn-light/src/hicn/core/pit.c
new file mode 100644
index 000000000..322e53674
--- /dev/null
+++ b/hicn-light/src/hicn/core/pit.c
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The pending interest table.
+ *
+ * Interest aggregation strategy:
+ * - The first Interest for a name is forwarded
+ * - A second Interest for a name from a different reverse path may be
+ * aggregated
+ * - A second Interest for a name from an existing Interest is forwarded
+ * - The Interest Lifetime is like a subscription time.  A reverse path entry is
+ * removed once the lifetime is exceeded.
+ * - Whan an Interest arrives or is aggregated, the Lifetime for that reverse
+ * hop is extended.  As a simplification, we only keep a single lifetime not per
+ * reverse hop.
+ *
+ */
+
+#include "pit.h"
+
+Ticks pit_calculate_lifetime(pit_t* pit, const msgbuf_t* msgbuf) {
+  uint64_t lifetime = msgbuf_get_lifetime(msgbuf);
+  if (lifetime == 0) lifetime = NSEC_TO_TICKS(DEFAULT_INTEREST_LIFETIME);
+
+  return ticks_now() + lifetime;
+}
+
+/* This is only used as a hint for first allocation, as the table is resizeable
+ */
+#define DEFAULT_PIT_SIZE 65535
+
+pit_t* _pit_create(size_t init_size, size_t max_size) {
+  pit_t* pit = malloc(sizeof(pit_t));
+  if (!pit) return NULL;
+
+  if (init_size == 0) init_size = DEFAULT_PIT_SIZE;
+
+  pit->max_size = max_size;
+  return pit;
+}
+
+void pit_free(pit_t* pit) {
+  assert(pit);
+  free(pit);
+}
+
+// void pit_print(const pit_t *pit) {
+//   const Name *k;
+//   unsigned v;
+//   pit_entry_t * entry;
+//   Ticks expire_ts;
+
+//   printf("*** PIT ***\n");
+//   kh_foreach(pit->index_by_name, k, v, {
+//     char *name_str = name_ToString(k);
+//     entry = pit_at(pit, v);
+//     expire_ts = pit_entry_get_expire_ts(entry);
+//     printf("%s\t\t\texpire=%lu\n", name_str, expire_ts);
+//     free(name_str);
+//   })
+// }
diff --git a/hicn-light/src/hicn/core/pit.h b/hicn-light/src/hicn/core/pit.h
new file mode 100644
index 000000000..f2e901490
--- /dev/null
+++ b/hicn-light/src/hicn/core/pit.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file pit.h
+ * @brief hICN Pending Interest Table (PIT)
+ */
+
+#ifndef HICNLIGHT_PIT_H
+#define HICNLIGHT_PIT_H
+
+#include <hicn/core/fib.h>
+
+typedef struct {
+  nexthops_t ingressIdSet;
+  nexthops_t egressIdSet;
+  fib_entry_t* fib_entry;
+} pit_entry_t;
+
+#define pit_entry_get_ingress(E) (&((E)->ingressIdSet))
+#define pit_entry_get_egress(E) (&((E)->egressIdSet))
+#define pit_entry_get_fib_entry(E) ((E)->fib_entry)
+#define pit_entry_set_fib_entry(E, FIB_ENTRY) ((E)->fib_entry = FIB_ENTRY)
+
+#define pit_entry_ingress_add(E, NH) \
+  nexthops_add(pit_entry_get_ingress(E), (NH))
+
+#define pit_entry_ingress_contains(E, NH) \
+  nexthops_contains(pit_entry_get_ingress(E), (NH))
+
+#define pit_entry_egress_add(E, NH) nexthops_add(pit_entry_get_egress(E), (NH))
+
+typedef struct {
+  // TODO(eloparco): How to handle PIT size?
+  size_t max_size;
+} pit_t;
+
+#define DEFAULT_INTEREST_LIFETIME 4000000000ULL
+
+Ticks pit_calculate_lifetime(pit_t* pit, const msgbuf_t* msgbuf);
+
+/**
+ * @brief Allocate a new PIT data structure (extended parameters)
+ *
+ * @param init_size Initial size (0 = default)
+ * @param max_size Maximum size (0 = unbounded)
+ *
+ * @return pit_t* Newly allocated PIT data structure
+ */
+pit_t* _pit_create(size_t init_size, size_t max_size);
+
+/**
+ * @brief Allocate a new PIT data structure
+ *
+ * @return pit_t* Newly allocated PIT data structure
+ */
+#define pit_create() _pit_create(0, 0)
+
+void pit_free(pit_t* pit);
+
+#endif /* HICNLIGHT_PIT_H */
diff --git a/hicn-light/src/hicn/core/policy_stats.c b/hicn-light/src/hicn/core/policy_stats.c
new file mode 100644
index 000000000..1acbccf69
--- /dev/null
+++ b/hicn-light/src/hicn/core/policy_stats.c
@@ -0,0 +1,189 @@
+#ifdef WITH_POLICY_STATS
+
+// This has to be included first because of _GNU_SOURCE
+#include <hicn/core/forwarder.h>
+
+#include <hicn/core/connection_table.h>
+#include <hicn/base/loop.h>
+#include <hicn/util/log.h>
+#include <hicn/core/ticks.h>
+#include <hicn/policy.h>
+#include <hicn/core/fib.h>
+
+#include "policy_stats.h"
+
+#define ALPHA 0.9
+#define STATS_INTERVAL 1000 /* ms */
+
+static int policy_stats_mgr_tick(void* mgr_arg, int fd, void* data) {
+  policy_stats_mgr_t* mgr = mgr_arg;
+  assert(mgr);
+  assert(!data);
+
+  uint64_t now = ticks_now();
+
+  /* Loop over FIB entries to compute statistics from counters */
+  const fib_t* fib = forwarder_get_fib(mgr->forwarder);
+  fib_entry_t* entry;
+
+  fib_foreach_entry(fib, entry, {
+    policy_stats_update(&entry->policy_stats, &entry->policy_counters, now);
+  });
+
+  return 0;
+}
+
+int policy_stats_mgr_initialize(policy_stats_mgr_t* mgr, void* forwarder) {
+  mgr->forwarder = forwarder;
+
+  loop_timer_create(&mgr->timer, MAIN_LOOP, mgr, policy_stats_mgr_tick, NULL);
+  if (!mgr->timer) {
+    ERROR("Error allocating prefix stats mgr timer.");
+    return -1;
+  }
+
+  if (loop_timer_register(mgr->timer, STATS_INTERVAL) < 0) {
+    ERROR("Error registering prefix stats mgr timer.");
+    return -1;
+  }
+
+  return 0;
+}
+
+void policy_stats_mgr_finalize(policy_stats_mgr_t* mgr) {
+  loop_event_unregister(mgr->timer);
+  loop_event_free(mgr->timer);
+}
+
+void policy_stats_on_retransmission(const policy_stats_mgr_t* mgr,
+                                    policy_counters_t* counters,
+                                    const nexthops_t* nexthops) {
+  connection_table_t* table = forwarder_get_connection_table(mgr->forwarder);
+  unsigned nexthop;
+  nexthops_foreach(nexthops, nexthop, {
+#ifdef WITH_POLICY
+    const connection_t* conn = connection_table_at(table, nexthop);
+
+    if (connection_has_tag(conn, POLICY_TAG_WIRED))
+      counters->wired.num_losses++;
+    if (connection_has_tag(conn, POLICY_TAG_WIFI)) counters->wifi.num_losses++;
+    if (connection_has_tag(conn, POLICY_TAG_CELLULAR))
+      counters->cellular.num_losses++;
+#endif /* WITH_POLICY */
+    counters->all.num_losses++;
+  });
+}
+
+#define UPDATE_TAG_STATS(TAG, NAME)                                \
+  do {                                                             \
+    if (connection_has_tag(conn, TAG)) {                           \
+      counters->NAME.num_packets++;                                \
+      counters->NAME.num_bytes += msg_size;                        \
+      stats->NAME.latency =                                        \
+          ALPHA * stats->NAME.latency + (1 - ALPHA) * (double)rtt; \
+      counters->NAME.latency_idle = 0;                             \
+    }                                                              \
+  } while (0)
+
+/* Update statistic counters upon Data packet reception */
+void policy_stats_on_data(const policy_stats_mgr_t* mgr, policy_stats_t* stats,
+                          policy_counters_t* counters,
+                          const nexthops_t* nexthops, const msgbuf_t* msgbuf,
+                          Ticks rtt) {
+#ifdef WITH_POLICY
+  forwarder_t* forwarder = mgr->forwarder;
+  connection_table_t* table = forwarder_get_connection_table(forwarder);
+#endif /* WITH_POLICY */
+
+  size_t msg_size = msgbuf_get_len(msgbuf);
+
+  unsigned nexthop;
+  nexthops_foreach(nexthops, nexthop, {
+#ifdef WITH_POLICY
+    const connection_t* conn = connection_table_at(table, nexthop);
+    if (!conn) continue;
+
+    UPDATE_TAG_STATS(POLICY_TAG_WIRED, wired);
+    UPDATE_TAG_STATS(POLICY_TAG_WIFI, wifi);
+    UPDATE_TAG_STATS(POLICY_TAG_CELLULAR, cellular);
+#endif /* WITH_POLICY */
+  });
+
+  stats->all.latency = ALPHA * stats->all.latency + (1 - ALPHA) * (double)rtt;
+  counters->all.latency_idle = 0;
+  counters->all.num_packets++;
+  counters->all.num_bytes += msg_size;
+}
+
+void policy_stats_on_timeout(const policy_stats_mgr_t* mgr,
+                             policy_counters_t* counters,
+                             const nexthops_t* nexthops) {
+#ifdef WITH_POLICY
+  connection_table_t* table = forwarder_get_connection_table(mgr->forwarder);
+
+  unsigned nexthop;
+  nexthops_foreach(nexthops, nexthop, {
+    const connection_t* conn = connection_table_at(table, nexthop);
+    if (!conn) continue;
+    if (connection_has_tag(conn, POLICY_TAG_WIRED))
+      counters->wired.num_losses++;
+    if (connection_has_tag(conn, POLICY_TAG_WIFI)) counters->wifi.num_losses++;
+    if (connection_has_tag(conn, POLICY_TAG_CELLULAR))
+      counters->cellular.num_losses++;
+  });
+#endif /* WITH_POLICY */
+
+  counters->all.num_losses++;
+}
+
+#define UPDATE_TYPE(TYPE)                                                      \
+  do {                                                                         \
+    /* (a) throughput */                                                       \
+    if (counters->TYPE.num_bytes > 0) {                                        \
+      throughput = counters->TYPE.num_bytes / (now - counters->last_update);   \
+      throughput = throughput * 8 / 1024;                                      \
+      if (throughput < 0) throughput = 0;                                      \
+    } else {                                                                   \
+      throughput = 0;                                                          \
+    }                                                                          \
+    stats->TYPE.throughput =                                                   \
+        ALPHA * stats->TYPE.throughput + (1 - ALPHA) * throughput;             \
+                                                                               \
+    /* (b) loss rate */                                                        \
+    if ((counters->TYPE.num_losses > 0) && (counters->TYPE.num_packets > 0)) { \
+      loss_rate = counters->TYPE.num_losses / counters->TYPE.num_packets;      \
+      loss_rate *= 100;                                                        \
+    } else {                                                                   \
+      loss_rate = 0;                                                           \
+    }                                                                          \
+    stats->TYPE.loss_rate =                                                    \
+        ALPHA * stats->TYPE.loss_rate + (1 - ALPHA) * loss_rate;               \
+                                                                               \
+    /* (c) latency */                                                          \
+    counters->TYPE.latency_idle++;                                             \
+    if (counters->TYPE.latency_idle > 1) stats->TYPE.latency = 0;              \
+                                                                               \
+    /* (d) Reset counters */                                                   \
+    counters->TYPE.num_bytes = 0;                                              \
+    counters->TYPE.num_losses = 0;                                             \
+    counters->TYPE.num_packets = 0;                                            \
+  } while (0)
+
+void policy_stats_update(policy_stats_t* stats, policy_counters_t* counters,
+                         uint64_t now) {
+  double throughput;
+  double loss_rate;
+
+  if (now == counters->last_update) return;
+
+#ifdef WITH_POLICY
+  UPDATE_TYPE(wired);
+  UPDATE_TYPE(wifi);
+  UPDATE_TYPE(cellular);
+#endif /* WITH_POLICY */
+  UPDATE_TYPE(all);
+
+  counters->last_update = now;
+}
+
+#endif /* WITH_POLICY_STATS */
diff --git a/hicn-light/src/hicn/core/policy_stats.h b/hicn-light/src/hicn/core/policy_stats.h
new file mode 100644
index 000000000..fa12b51cb
--- /dev/null
+++ b/hicn-light/src/hicn/core/policy_stats.h
@@ -0,0 +1,93 @@
+
+#ifndef HICNLIGHT_POLICY_STATS_H
+#define HICNLIGHT_POLICY_STATS_H
+
+#ifdef WITH_POLICY_STATS
+
+#include <hicn/policy.h>
+#include "../base/loop.h"
+
+typedef struct policy_stats_mgr_s {
+  void* forwarder;
+  event_t* timer;
+} policy_stats_mgr_t;
+
+#if 0
+
+/* PER-INTERFACE POLICY STATS */
+
+typedef struct {
+    float throughput;
+    float latency;
+    float loss_rate;
+} interface_stats_t;
+
+/* POLICY STATS */
+
+typedef struct {
+    interface_stats_t wired;
+    interface_stats_t wifi;
+    interface_stats_t cellular;
+    interface_stats_t all;
+} policy_stats_t;
+
+typedef struct {
+    uint32_t num_packets;
+    uint32_t num_bytes;
+    uint32_t num_losses;
+    uint32_t latency_idle;
+} interface_counters_t;
+
+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 INTERFACE_STATS_EMPTY \
+  (interface_stats_t) { .throughput = 0, .latency = 0, .loss_rate = 0, }
+
+#define POLICY_STATS_EMPTY                                           \
+  (policy_stats_t) {                                                 \
+    .wired = INTERFACE_STATS_EMPTY, .wifi = INTERFACE_STATS_EMPTY,   \
+    .cellular = INTERFACE_STATS_EMPTY, .all = INTERFACE_STATS_EMPTY, \
+  }
+
+#define INTERFACE_COUNTERS_EMPTY                                          \
+  (interface_counters_t) {                                                \
+    .num_packets = 0, .num_bytes = 0, .num_losses = 0, .latency_idle = 0, \
+  }
+
+#define POLICY_COUNTERS_EMPTY                                              \
+  (policy_counters_t) {                                                    \
+    .wired = INTERFACE_COUNTERS_EMPTY, .wifi = INTERFACE_COUNTERS_EMPTY,   \
+    .cellular = INTERFACE_COUNTERS_EMPTY, .all = INTERFACE_COUNTERS_EMPTY, \
+    .last_update = 0,                                                      \
+  }
+#endif
+
+int policy_stats_mgr_initialize(policy_stats_mgr_t* mgr, void* forwarder);
+
+void policy_stats_mgr_finalize(policy_stats_mgr_t* mgr);
+
+void policy_stats_on_retransmission(const policy_stats_mgr_t* mgr,
+                                    policy_counters_t* countrs,
+                                    const nexthops_t* nexthops);
+
+void policy_stats_on_data(const policy_stats_mgr_t* mgr, policy_stats_t* stats,
+                          policy_counters_t* counters,
+                          const nexthops_t* nexthops, const msgbuf_t* msgbuf,
+                          Ticks rtt);
+
+void policy_stats_on_timeout(const policy_stats_mgr_t* mgr,
+                             policy_counters_t* counters,
+                             const nexthops_t* nexthops);
+
+void policy_stats_update(policy_stats_t* stats, policy_counters_t* counters,
+                         uint64_t now);
+
+#endif /* WITH_POLICY_STATS */
+
+#endif /* HICNLIGHT_POLICY_STATS_H */
diff --git a/hicn-light/src/hicn/core/strategy.c b/hicn-light/src/hicn/core/strategy.c
new file mode 100644
index 000000000..3716cd585
--- /dev/null
+++ b/hicn-light/src/hicn/core/strategy.c
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file strategy.c
+ * \brief Implementation of hICN forwarding strategy
+ */
+
+#include "nexthops.h"
+#include "strategy.h"
+#include "strategy_vft.h"
+
+int strategy_initialize(strategy_entry_t *entry, const void *forwarder) {
+  return strategy_vft[entry->type]->initialize(entry, forwarder);
+}
+
+nexthops_t *strategy_lookup_nexthops(strategy_entry_t *entry,
+                                     nexthops_t *nexthops,
+                                     const msgbuf_t *msgbuf) {
+  return strategy_vft[entry->type]->lookup_nexthops(entry, nexthops, msgbuf);
+}
+
+int strategy_add_nexthop(strategy_entry_t *entry, nexthops_t *nexthops,
+                         off_t offset) {
+  return strategy_vft[entry->type]->add_nexthop(entry, nexthops, offset);
+}
+
+int strategy_remove_nexthop(strategy_entry_t *entry, nexthops_t *nexthops,
+                            off_t offset) {
+  return strategy_vft[entry->type]->remove_nexthop(entry, nexthops, offset);
+}
+
+int strategy_on_data(strategy_entry_t *entry, nexthops_t *nexthops,
+                     const nexthops_t *data_nexthops, const msgbuf_t *msgbuf,
+                     Ticks pitEntryCreation, Ticks objReception) {
+  return strategy_vft[entry->type]->on_data(
+      entry, nexthops, data_nexthops, msgbuf, pitEntryCreation, objReception);
+}
+
+int strategy_on_timeout(strategy_entry_t *entry, nexthops_t *nexthops,
+                        const nexthops_t *timeout_nexthops) {
+  return strategy_vft[entry->type]->on_timeout(entry, nexthops,
+                                               timeout_nexthops);
+}
diff --git a/hicn-light/src/hicn/core/strategy.h b/hicn-light/src/hicn/core/strategy.h
new file mode 100644
index 000000000..9ce75c51d
--- /dev/null
+++ b/hicn-light/src/hicn/core/strategy.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file strategy.h
+ * \brief hICN forwarding strategy
+ */
+#ifndef HICNLIGHT_STRATEGY_H
+#define HICNLIGHT_STRATEGY_H
+
+/*
+ * Forwarding strategy
+ *
+ * The forwarding strategy decides to elect one or several next hops among those
+ * available in the FIB entry, after an eventual application of the policy. This
+ * means it should be aware of the different flags set in the nexthops_t data
+ * structure by previous forwarding steps, that might have excluded certain
+ * nexthops.
+ *
+ * A strategy is defined by its type and comes with :
+ *  - options, initialized at setup and that might eventually be updated (this
+ *  is allowed on a per-strategy basis.
+ *  - a state (eventually) empty, that is used to inform its decisions, and
+ *  might be updated for each interest sent (lookup_nexthops), data received
+ *  (on_data) or timeout event (on_timeout).
+ *
+ * All this information (type, options, state) is made available through a
+ * strategy_entry_t which is stored together with nexthops in the FIB entry.
+ *
+ * Per-nexthop strategy informaton is stored in the nexthops table itself. As it
+ * would be difficult and suboptimal to provide a correct strategy-dependent
+ * initialization in the FIB nad nexthops data structures, it is thus the
+ * responsibility of the forwarding strategy to initialize its state and nexthop
+ * related state when appropriate (eg. at initialization, or when a nexthop is
+ * added).
+ */
+
+#include "nexthops.h"
+#include "strategy_vft.h"
+
+typedef struct strategy_entry_s {
+  const void *forwarder;
+  strategy_type_t type;
+  strategy_options_t options;
+  strategy_state_t state;
+} strategy_entry_t;
+
+int strategy_initialize(strategy_entry_t *entry, const void *forwarder);
+
+nexthops_t *strategy_lookup_nexthops(strategy_entry_t *entry,
+                                     nexthops_t *nexthops,
+                                     const msgbuf_t *msgbuf);
+
+int strategy_add_nexthop(strategy_entry_t *entry, nexthops_t *nexthops,
+                         off_t offset);
+
+int strategy_remove_nexthop(strategy_entry_t *entry, nexthops_t *nexthops,
+                            off_t offset);
+
+int strategy_on_data(strategy_entry_t *entry, nexthops_t *nexthops,
+                     const nexthops_t *data_nexthops, const msgbuf_t *msgbuf,
+                     Ticks pitEntryCreation, Ticks objReception);
+
+int strategy_on_timeout(strategy_entry_t *entry, nexthops_t *nexthops,
+                        const nexthops_t *timeout_nexthops);
+
+#endif /* HICNLIGHT_STRATEGY_H */
diff --git a/hicn-light/src/hicn/core/strategy_vft.c b/hicn-light/src/hicn/core/strategy_vft.c
new file mode 100644
index 000000000..dcfda5c78
--- /dev/null
+++ b/hicn-light/src/hicn/core/strategy_vft.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file strategy_vft.c
+ * \brief Implementation of hICN forwarding strategy VFT
+ */
+
+#include "strategy_vft.h"
+
+extern const strategy_ops_t strategy_load_balancer;
+extern const strategy_ops_t strategy_random;
+extern const strategy_ops_t strategy_replication;
+extern const strategy_ops_t strategy_bestpath;
+extern const strategy_ops_t strategy_low_latency;
+
+const strategy_ops_t *const strategy_vft[] = {
+    [STRATEGY_TYPE_LOADBALANCER] = &strategy_load_balancer,
+    [STRATEGY_TYPE_RANDOM] = &strategy_random,
+    [STRATEGY_TYPE_REPLICATION] = &strategy_replication,
+    [STRATEGY_TYPE_BESTPATH] = &strategy_bestpath,
+#if 0
+  [STRATEGY_TYPE_LOW_LATENCY] = &strategy_low_latency,
+#endif
+};
diff --git a/hicn-light/src/hicn/core/strategy_vft.h b/hicn-light/src/hicn/core/strategy_vft.h
new file mode 100644
index 000000000..0256cba57
--- /dev/null
+++ b/hicn-light/src/hicn/core/strategy_vft.h
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file strategy_vft.h
+ * \brief hICN forwarding strategy VFT
+ */
+#ifndef HICNLIGHT_STRATEGY_VFT_H
+#define HICNLIGHT_STRATEGY_VFT_H
+
+#include "msgbuf.h"
+
+#include "../strategies/best_path.h"
+#include "../strategies/load_balancer.h"
+#include "../strategies/low_latency.h"
+#include "../strategies/random.h"
+#include "../strategies/replication.h"
+
+typedef union {
+  strategy_load_balancer_options_t load_balancer;
+  strategy_low_latency_options_t low_latency;
+  strategy_random_options_t random;
+  strategy_replication_options_t replication;
+  strategy_bestpath_options_t bestpath;
+} strategy_options_t;
+
+typedef struct {
+#ifdef WITH_POLICY
+  int priority;
+#endif /* WITH_POLICY */
+  union {
+    strategy_load_balancer_nexthop_state_t load_balancer;
+    strategy_low_latency_nexthop_state_t low_latency;
+    strategy_random_nexthop_state_t random;
+    strategy_replication_nexthop_state_t replication;
+    strategy_bestpath_nexthop_state_t bestpath;
+  };
+} strategy_nexthop_state_t;
+
+#define STRATEGY_NEXTHOP_STATE_EMPTY \
+  {                                  \
+    0, {                             \
+      { 0 }                          \
+    }                                \
+  }
+
+typedef union {
+  strategy_load_balancer_state_t load_balancer;
+  strategy_low_latency_state_t low_latency;
+  strategy_random_state_t random;
+  strategy_replication_state_t replication;
+  strategy_bestpath_state_t bestpath;
+} strategy_state_t;
+// XXX This has to be merged with nexthops
+// XXX How to avoid errors due to pool id reuse (eg on_data) ?
+
+/**
+ * @typedef strategy_ops_t
+ * @abstract Forwarding strategy implementation
+ * @constant receiveObject is called when we receive an object and have a
+ * measured round trip time.  This allows a strategy to update its performance
+ * data.
+ * @constant lookupNexthop Find the set of nexthops to use for the Interest.
+ *           May be empty, should not be NULL.  Must be destroyed.
+ * @constant addNexthop Add a nexthop to the list of available nexthops with a
+ * routing protocol-specific cost.
+ * @constant destroy cleans up the strategy, freeing all memory and state.  A
+ * strategy is reference counted, so the final destruction only happens after
+ * the last reference is released.
+ * @discussion <#Discussion#>
+ */
+
+struct strategy_entry_s;
+struct nexthops_s;
+
+typedef struct {
+  const char *name;
+
+  int (*initialize)(struct strategy_entry_s *entry, const void *forwarder);
+
+  int (*finalize)(struct strategy_entry_s *entry);
+
+  struct nexthops_s *(*lookup_nexthops)(struct strategy_entry_s *entry,
+                                        struct nexthops_s *nexthops,
+                                        const msgbuf_t *msgbuf);
+
+  int (*add_nexthop)(struct strategy_entry_s *strategy,
+                     struct nexthops_s *nexthops, off_t offset);
+
+  int (*remove_nexthop)(struct strategy_entry_s *entry,
+                        struct nexthops_s *nexthops, off_t offset);
+
+  int (*on_data)(struct strategy_entry_s *entry, struct nexthops_s *nexthops,
+                 const struct nexthops_s *data_nexthops, const msgbuf_t *msgbuf,
+                 Ticks pitEntryCreation, Ticks objReception);
+
+  int (*on_timeout)(struct strategy_entry_s *entry, struct nexthops_s *nexthops,
+                    const struct nexthops_s *timeout_nexthops);
+
+} strategy_ops_t;
+
+extern const strategy_ops_t *const strategy_vft[];
+
+#define DECLARE_STRATEGY(NAME)                              \
+  const strategy_ops_t strategy_##NAME = {                  \
+      .name = #NAME,                                        \
+      .initialize = strategy_##NAME##_initialize,           \
+      .finalize = strategy_##NAME##_finalize,               \
+      .add_nexthop = strategy_##NAME##_add_nexthop,         \
+      .remove_nexthop = strategy_##NAME##_remove_nexthop,   \
+      .lookup_nexthops = strategy_##NAME##_lookup_nexthops, \
+      .on_data = strategy_##NAME##_on_data,                 \
+      .on_timeout = strategy_##NAME##_on_timeout,           \
+  }
+
+#endif /* HICNLIGHT_STRATEGY_VFT_H */
diff --git a/hicn-light/src/hicn/core/streamBuffer.c b/hicn-light/src/hicn/core/streamBuffer.c
index c30139498..401b7c873 100644
--- a/hicn-light/src/hicn/core/streamBuffer.c
+++ b/hicn-light/src/hicn/core/streamBuffer.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-light/src/hicn/core/streamBuffer.h b/hicn-light/src/hicn/core/streamBuffer.h
index 27e793176..0caa10bea 100644
--- a/hicn-light/src/hicn/core/streamBuffer.h
+++ b/hicn-light/src/hicn/core/streamBuffer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-light/src/hicn/core/subscription.c b/hicn-light/src/hicn/core/subscription.c
new file mode 100644
index 000000000..0c4949f26
--- /dev/null
+++ b/hicn-light/src/hicn/core/subscription.c
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ */
+
+#include "subscription.h"
+#include <hicn/base/vector.h>
+#include <hicn/util/log.h>
+
+/*----------------------------------------------------------------------------*
+ * Topics and events
+ *----------------------------------------------------------------------------*/
+
+bool topics_contains(hc_topics_t topic_list, hc_topic_t topic) {
+  return ((topic_list) & (topic));
+}
+
+#define topic_is_set(topic_list, topic_index) \
+  ((topic_list) & (1 << (topic_index)))
+
+const char *event_str[] = {
+#define _(x) [EVENT_##x] = #x,
+    foreach_event_type
+#undef _
+};
+
+/*----------------------------------------------------------------------------*
+ * Subscriptions
+ *----------------------------------------------------------------------------*/
+
+struct subscription_table_s {
+  unsigned *table[TOPIC_N];
+};
+
+subscription_table_t *subscription_table_create() {
+  subscription_table_t *subscriptions = malloc(sizeof(subscription_table_t));
+  for (int i = 0; i < NUM_TOPICS; i++)
+    vector_init(subscriptions->table[i], 0, 0);
+
+  return subscriptions;
+}
+
+void subscription_table_free(subscription_table_t *subscriptions) {
+  for (int i = 0; i < NUM_TOPICS; i++) vector_free(subscriptions->table[i]);
+  free(subscriptions);
+}
+
+int subscription_table_add_topics_for_connection(
+    subscription_table_t *subscriptions, hc_topics_t topics,
+    unsigned connection_id) {
+  bool is_subscription_already_present = false;
+  for (int topic_index = 0; topic_index < NUM_TOPICS; topic_index++) {
+    if (topic_is_set(topics, topic_index)) {
+      int num_duplicates = vector_remove_unordered(
+          subscriptions->table[topic_index], connection_id);
+
+      int ret = vector_push(subscriptions->table[topic_index], connection_id);
+      if (ret < 0) {
+        ERROR("Unable to perform subscription for connection %d, topic %s",
+              connection_id, object_str(topic_index));
+        return -1;
+      }
+
+      if (num_duplicates > 0) {
+        DEBUG("Connection %d had already a subscription for topic %s",
+              connection_id, object_str(topic_index));
+        is_subscription_already_present = true;
+      }
+    }
+  }
+  return is_subscription_already_present ? -2 : 0;
+}
+
+int subscription_table_remove_topics_for_connection(
+    subscription_table_t *subscriptions, hc_topics_t topics,
+    unsigned connection_id) {
+  int num_subscriptions_removed = 0;
+  for (int topic_index = 0; topic_index < NUM_TOPICS; topic_index++) {
+    if (topic_is_set(topics, topic_index)) {
+      int num_duplicates = vector_remove_unordered(
+          subscriptions->table[topic_index], connection_id);
+      if (num_duplicates <= 0) {
+        continue;
+      }
+      num_subscriptions_removed++;
+    }
+  }
+  return num_subscriptions_removed;
+}
+
+hc_topics_t subscription_table_get_topics_for_connection(
+    subscription_table_t *subscriptions, unsigned connection_id) {
+  hc_topics_t topics = 0;
+  for (int topic_index = 0; topic_index < NUM_TOPICS; topic_index++) {
+    unsigned *conn_id;
+    bool found = false;
+    vector_foreach(subscriptions->table[topic_index], conn_id, {
+      if (*conn_id == connection_id) {
+        found = true;
+        break;
+      }
+    });
+    if (found) topics |= (1 << topic_index);
+  }
+  return topics;
+}
+
+unsigned *subscription_table_get_connections_for_topic(
+    subscription_table_t *subscriptions, hc_topic_t topic) {
+  int topic_index = object_from_topic(topic);
+  return subscriptions->table[topic_index];
+}
+
+void subscription_table_print(subscription_table_t *subscriptions) {
+  for (int topic_index = OBJECT_UNDEFINED + 1; topic_index < NUM_TOPICS;
+       topic_index++) {
+    printf("topic %s (%lu subscription/s) from connection/s: [ ",
+           object_str(topic_index),
+           (unsigned long)vector_len(subscriptions->table[topic_index]));
+    unsigned *connection_id;
+    vector_foreach(subscriptions->table[topic_index], connection_id,
+                   { printf("%d ", *connection_id); });
+    printf("]\n");
+  }
+}
\ No newline at end of file
diff --git a/hicn-light/src/hicn/core/subscription.h b/hicn-light/src/hicn/core/subscription.h
new file mode 100644
index 000000000..74ddd9e18
--- /dev/null
+++ b/hicn-light/src/hicn/core/subscription.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ */
+
+#ifndef HICNLIGHT_SUBSCRIPTION_H
+#define HICNLIGHT_SUBSCRIPTION_H
+
+#include <hicn/ctrl/api.h>
+#include <stddef.h>
+
+/*----------------------------------------------------------------------------*
+ * Topics
+ *----------------------------------------------------------------------------*/
+
+bool topics_contains(hc_topics_t topic_list, hc_topic_t topic);
+
+/*----------------------------------------------------------------------------*
+ * Subscriptions
+ *----------------------------------------------------------------------------*/
+
+typedef struct subscription_table_s subscription_table_t;
+
+subscription_table_t *subscription_table_create();
+
+void subscription_table_free(subscription_table_t *subscriptions);
+
+/**
+ * @brief Add topic subscriptions for a connection.
+ *
+ * @param subscriptions The pointer to the subscription table
+ * @param topics Topics the connection wants to subscribe to
+ * @param connection_id Identifier of the connection
+ * @return int 0 for success, -1 for error, -2 if already esisting subscription
+ * for at least one of the topic for
+ */
+int subscription_table_add_topics_for_connection(
+    subscription_table_t *subscriptions, hc_topics_t topics,
+    unsigned connection_id);
+
+/**
+ * @brief Remove topic subscriptions for a connection.
+ *
+ * @param subscriptions The pointer to the subscription table
+ * @param topics Topics the connection wants to unsubscribe to
+ * @param connection_id Identifier of the connection
+ * @return int Number of removed subscriptions
+ */
+int subscription_table_remove_topics_for_connection(
+    subscription_table_t *subscriptions, hc_topics_t topics,
+    unsigned connection_id);
+
+/**
+ * @brief Get the topics a connection has subscribed to.
+ *
+ * @param subscriptions The pointer to the subscription table
+ * @param connection_id Identifier of the connection
+ * @return hc_topics_t
+ */
+hc_topics_t subscription_table_get_topics_for_connection(
+    subscription_table_t *subscriptions, unsigned connection_id);
+
+/**
+ * @brief Get the connections that have a subscription for the specified topic.
+ *
+ * @param subscriptions The pointer to the subscription table
+ * @param topic Topic to retrieve the subscriptions for
+ * @return unsigned* Array containing the connection ids associated with the
+ * specified topic
+ */
+unsigned *subscription_table_get_connections_for_topic(
+    subscription_table_t *subscriptions, hc_topic_t topic);
+
+/**
+ * @brief Print the subscription table containing, for each topic, the list
+ * of connections with a subsctiption.
+ *
+ * @param subscriptions The pointer to the subscription table
+ */
+void subscription_table_print(subscription_table_t *subscriptions);
+
+#endif  // HICNLIGHT_SUBSCRIPTION_H
\ No newline at end of file
diff --git a/hicn-light/src/hicn/core/system.h b/hicn-light/src/hicn/core/system.h
index be6c3e7cf..860133dd3 100644
--- a/hicn-light/src/hicn/core/system.h
+++ b/hicn-light/src/hicn/core/system.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,13 +25,12 @@
 #define system_h
 
 #include <hicn/core/forwarder.h>
-#include <hicn/utils/interfaceSet.h>
 
 /**
  * @function system_Interfaces
  * @abstract The system network interfaces
  */
-InterfaceSet *system_Interfaces(Forwarder *forwarder);
+InterfaceSet *system_Interfaces(forwarder_t *forwarder);
 
 /**
  * Returns the MTU of the named interface
@@ -43,7 +42,7 @@ InterfaceSet *system_Interfaces(Forwarder *forwarder);
  * @return positive the MTU the kernel reports
  *
  */
-unsigned system_InterfaceMtu(Forwarder *forwarder, const char *interfaceName);
+unsigned system_InterfaceMtu(forwarder_t *forwarder, const char *interfaceName);
 
 /**
  * Returns the LINK address of the specified interface
@@ -55,6 +54,6 @@ unsigned system_InterfaceMtu(Forwarder *forwarder, const char *interfaceName);
  * @retval null The interface does not exist
  *
  */
-Address *system_GetMacAddressByName(Forwarder *forwarder,
+Address *system_GetMacAddressByName(forwarder_t *forwarder,
                                     const char *interfaceName);
 #endif
diff --git a/hicn-light/src/hicn/core/ticks.h b/hicn-light/src/hicn/core/ticks.h
index 8750abde5..0955569df 100644
--- a/hicn-light/src/hicn/core/ticks.h
+++ b/hicn-light/src/hicn/core/ticks.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,7 +25,42 @@
 
 #define __STDC_FORMAT_MACROS
 #include <stdint.h>
+#include <time.h>
+
+#include <sys/param.h>  // HZ
+
+#ifdef __APPLE__
+#include <mach/clock.h>
+#include <mach/mach.h>
+#define HZ 1000
+#endif
 
 typedef uint64_t Ticks;
 
+// these will all be a little off because its all integer division
+#define NSEC_PER_TICK ((1000000000ULL) / HZ)
+#define NSEC_TO_TICKS(nsec) ((nsec < NSEC_PER_TICK) ? 1 : nsec / NSEC_PER_TICK)
+
+#define TICKS_TO_NSEC(ticks) ((1000000000ULL) * ticks / HZ)
+
+static inline Ticks ticks_now() {
+#if __linux__
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
+  return ts.tv_sec * 1000 + ts.tv_nsec / 1e6;
+#elif _WIN32
+  struct timespec ts;
+  _clock_gettime(TIME_UTC, &ts);
+  return ts.tv_sec * 1000 + ts.tv_nsec / 1e6;
+#else
+  clock_serv_t clockService;
+  mach_timespec_t ts;
+  host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &clockService);
+  clock_get_time(clockService, &ts);
+  mach_port_deallocate(mach_task_self(), clockService);
+#endif
+
+  return ts.tv_sec * 1000 + ts.tv_nsec / 1e6;
+}
+
 #endif  // ticks_h
diff --git a/hicn-light/src/hicn/core/wldr.c b/hicn-light/src/hicn/core/wldr.c
index ad3663d0d..aa1dbf4f9 100644
--- a/hicn-light/src/hicn/core/wldr.c
+++ b/hicn-light/src/hicn/core/wldr.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,93 +13,100 @@
  * limitations under the License.
  */
 
-#include <parc/assert/parc_Assert.h>
-#include <parc/logging/parc_LogReporterTextStdout.h>
 #include <hicn/core/connection.h>
 #include <hicn/core/forwarder.h>
 #include <hicn/core/wldr.h>
 #include <stdint.h>
 #include <stdio.h>
 
-struct wldr_buffer {
-  Message *message;
+typedef struct {
+  msgbuf_t *msgbuf;
   uint8_t rtx_counter;
-};
-
-typedef struct wldr_buffer WldrBuffer;
+} wldr_buffer_t;
 
-struct wldr_state {
+struct wldr_s {
   uint16_t expected_label;
   uint16_t next_label;
-  WldrBuffer *buffer[BUFFER_SIZE];
+  wldr_buffer_t *buffer[BUFFER_SIZE];
 };
 
-Wldr *wldr_Init() {
-  Wldr *wldr = parcMemory_AllocateAndClear(sizeof(Wldr));
+wldr_t *wldr_create() {
+#if 0
+  wldr_t * wldr = parcMemory_AllocateAndClear(sizeof(Wldr));
   parcAssertNotNull(wldr, "parcMemory_AllocateAndClear(%zu) returned NULL",
                     sizeof(Wldr));
   wldr->expected_label = 1;
   wldr->next_label = 1;
   for (int i = 0; i < BUFFER_SIZE; i++) {
-    WldrBuffer *entry = parcMemory_AllocateAndClear(sizeof(WldrBuffer));
+    wldr_buffer_t *entry = parcMemory_AllocateAndClear(sizeof(wldr_buffer_t));
     parcAssertNotNull(
         entry,
-        "WldrBuffer init: parcMemory_AllocateAndClear(%zu) returned NULL",
-        sizeof(WldrBuffer));
-    entry->message = NULL;
+        "wldr_buffer_t init: parcMemory_AllocateAndClear(%zu) returned NULL",
+        sizeof(wldr_buffer_t));
+    entry->msgbuf = NULL;
     entry->rtx_counter = 0;
     wldr->buffer[i] = entry;
   }
   return wldr;
+#else
+  return NULL;
+#endif
 }
 
-void wldr_ResetState(Wldr *wldr) {
+void wldr_resset_state(wldr_t *wldr) {
+#if 0
   wldr->expected_label = 1;
   wldr->next_label = 1;
   for (int i = 0; i < BUFFER_SIZE; i++) {
-    wldr->buffer[i]->message = NULL;
+    wldr->buffer[i]->msgbuf = NULL;
     wldr->buffer[i]->rtx_counter = 0;
   }
+#endif
 }
 
-void wldr_Destroy(Wldr **wldrPtr) {
-  Wldr *wldr = *wldrPtr;
+void wldr_free(wldr_t *wldr) {
+#if 0
+  wldr_t * wldr = *wldrPtr;
   for (unsigned i = 0; i < BUFFER_SIZE; i++) {
-    if (wldr->buffer[i]->message != NULL) {
-      message_Release(&(wldr->buffer[i]->message));
+    if (wldr->buffer[i]->msgbuf != NULL) {
+      message_Release(&(wldr->buffer[i]->msgbuf));
       parcMemory_Deallocate((void **)&(wldr->buffer[i]));
     }
   }
   parcMemory_Deallocate((void **)&wldr);
   *wldrPtr = NULL;
+#endif
 }
 
-static void _wldr_RetransmitPacket(Wldr *wldr, const Connection *conn,
+#if 0
+static void _wldr_RetransmitPacket(wldr_t * wldr, const connection_t * conn,
                                    uint16_t label) {
-  if (wldr->buffer[label % BUFFER_SIZE]->message == NULL) {
+  if (wldr->buffer[label % BUFFER_SIZE]->msgbuf == NULL) {
     // the required message for retransmission is not in the buffer
     return;
   }
 
   if (wldr->buffer[label % BUFFER_SIZE]->rtx_counter < MAX_RTX) {
-    Message *msg = wldr->buffer[label % BUFFER_SIZE]->message;
+    msgbuf_t *msg = wldr->buffer[label % BUFFER_SIZE]->msgbuf;
     message_SetWldrLabel(msg, wldr->next_label);
 
-    if (wldr->buffer[wldr->next_label % BUFFER_SIZE]->message != NULL) {
-      message_Release(&(wldr->buffer[wldr->next_label % BUFFER_SIZE]->message));
+    if (wldr->buffer[wldr->next_label % BUFFER_SIZE]->msgbuf != NULL) {
+      msgbuf_Release(&(wldr->buffer[wldr->next_label % BUFFER_SIZE]->msgbuf));
     }
 
-    wldr->buffer[wldr->next_label % BUFFER_SIZE]->message = msg;
+    wldr->buffer[wldr->next_label % BUFFER_SIZE]->msgbuf = msg;
     wldr->buffer[wldr->next_label % BUFFER_SIZE]->rtx_counter =
         wldr->buffer[label % BUFFER_SIZE]->rtx_counter + 1;
-    message_Acquire(wldr->buffer[wldr->next_label % BUFFER_SIZE]->message);
+    message_Acquire(wldr->buffer[wldr->next_label % BUFFER_SIZE]->msgbuf);
     wldr->next_label++;
     connection_ReSend(conn, msg, false);
   }
 }
+#endif
 
-static void _wldr_SendWldrNotificaiton(Wldr *wldr, const Connection *conn,
-                                       Message *message, uint16_t expected_lbl,
+#if 0
+static void _wldr_SendWldrNotification(wldr_t * wldr, const connection_t * conn,
+                                       msgbuf_t *msgbuf, uint16_t expected_lbl,
                                        uint16_t received_lbl) {
   // here we need to create a new packet that is used to send the wldr
   // notification to the prevoius hop. the destionation address of the
@@ -113,38 +120,43 @@ static void _wldr_SendWldrNotificaiton(Wldr *wldr, const Connection *conn,
   // this way the notification packet will be dispaced to the right connection
   // at the next hop.
 
-  Message *notification =
-      message_CreateWldrNotification(message, expected_lbl, received_lbl);
+  msgbuf_t *notification =
+      message_CreateWldrNotification(msgbuf, expected_lbl, received_lbl);
   parcAssertNotNull(notification, "Got null from CreateWldrNotification");
   connection_ReSend(conn, notification, true);
 }
+#endif
 
-void wldr_SetLabel(Wldr *wldr, Message *message) {
+void wldr_set_label(wldr_t *wldr, msgbuf_t *msgbuf) {
+#if 0
   // in this function we send the packet for the first time
   // 1) we set the wldr label
-  message_SetWldrLabel(message, wldr->next_label);
+  message_SetWldrLabel(msgbuf, wldr->next_label);
 
   // 2) we store the pointer to packet in the buffer
-  if (wldr->buffer[wldr->next_label % BUFFER_SIZE]->message != NULL) {
+  if (wldr->buffer[wldr->next_label % BUFFER_SIZE]->msgbuf != NULL) {
     // release an old message if necessary
-    message_Release(&(wldr->buffer[wldr->next_label % BUFFER_SIZE]->message));
+    message_Release(&(wldr->buffer[wldr->next_label % BUFFER_SIZE]->msgbuf));
   }
 
   // we need to acquire the message to avoid that it gets destroyed
-  message_Acquire(message);
+  message_Acquire(msgbuf);
 
-  wldr->buffer[wldr->next_label % BUFFER_SIZE]->message = message;
+  wldr->buffer[wldr->next_label % BUFFER_SIZE]->msgbuf = msgbuf;
   wldr->buffer[wldr->next_label % BUFFER_SIZE]->rtx_counter = 0;
   wldr->next_label++;
   if (wldr->next_label ==
       0)  // we alwasy skip label 0 beacause it means that wldr is not active
     wldr->next_label++;
+#endif
 }
 
-void wldr_DetectLosses(Wldr *wldr, const Connection *conn, Message *message) {
-  if (message_HasWldr(message)) {
+void wldr_detect_losses(wldr_t *wldr, const connection_t *connection,
+                        const msgbuf_t *msgbuf) {
+#if 0
+  if (message_HasWldr(msgbuf)) {
     // this is a normal wldr packet
-    uint16_t pkt_lbl = (uint16_t)message_GetWldrLabel(message);
+    uint16_t pkt_lbl = (uint16_t)message_GetWldrLabel(msgbuf);
     if (pkt_lbl != wldr->expected_label) {
       // if the received packet label is 1 and the expected packet label >
       // pkt_lbl usually we are in the case where a remote note disconnected for
@@ -153,7 +165,7 @@ void wldr_DetectLosses(Wldr *wldr, const Connection *conn, Message *message) {
       // synch the labels
 
       if ((pkt_lbl != 1) || (wldr->expected_label < pkt_lbl)) {
-        _wldr_SendWldrNotificaiton(wldr, conn, message, wldr->expected_label,
+        _wldr_SendWldrNotificaiton(wldr, conn, msgbuf, wldr->expected_label,
                                    pkt_lbl);
       }
 
@@ -165,12 +177,14 @@ void wldr_DetectLosses(Wldr *wldr, const Connection *conn, Message *message) {
         wldr->expected_label++;  // for the next_label we want to skip 0
     }
   }
+#endif
 }
 
-void wldr_HandleWldrNotification(Wldr *wldr, const Connection *conn,
-                                 Message *message) {
-  uint16_t expected_lbl = (uint16_t)message_GetWldrExpectedLabel(message);
-  uint16_t received_lbl = (uint16_t)message_GetWldrLastReceived(message);
+void wldr_handle_notification(wldr_t *wldr, const connection_t *connection,
+                              const msgbuf_t *msgbuf) {
+#if 0
+  uint16_t expected_lbl = (uint16_t)message_GetWldrExpectedLabel(msgbuf);
+  uint16_t received_lbl = (uint16_t)message_GetWldrLastReceived(msgbuf);
   if ((wldr->next_label - expected_lbl) > BUFFER_SIZE) {
     // the packets are not in the buffer anymore
     return;
@@ -179,4 +193,5 @@ void wldr_HandleWldrNotification(Wldr *wldr, const Connection *conn,
     _wldr_RetransmitPacket(wldr, conn, expected_lbl);
     expected_lbl++;
   }
+#endif
 }
diff --git a/hicn-light/src/hicn/core/wldr.h b/hicn-light/src/hicn/core/wldr.h
index e21889f63..7eccf39cd 100644
--- a/hicn-light/src/hicn/core/wldr.h
+++ b/hicn-light/src/hicn/core/wldr.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -18,7 +18,7 @@
 
 #include <hicn/hicn-light/config.h>
 #include <hicn/core/connection.h>
-#include <hicn/core/message.h>
+#include <hicn/core/msgbuf.h>
 
 #define BUFFER_SIZE 8192
 #define MAX_RTX 3
@@ -34,19 +34,19 @@
 //                        ATTENTION!!! in order to detect a notificaiton the
 //                        source and destination ports must be set to 0
 
-struct wldr_state;
-typedef struct wldr_state Wldr;
+typedef struct wldr_s wldr_t;
 
-Wldr *wldr_Init();
+wldr_t *wldr_create();
 
-void wldr_Destroy(Wldr **wldrPtr);
+void wldr_free(wldr_t *wldr);
 
-void wldr_ResetState(Wldr *wldr);
+void wldr_reset_state(wldr_t *wldr);
 
-void wldr_SetLabel(Wldr *wldr, Message *message);
+void wldr_set_label(wldr_t *wldr, msgbuf_t *msgbuf);
 
-void wldr_DetectLosses(Wldr *wldr, const Connection *conn, Message *message);
+void wldr_detect_losses(wldr_t *wldr, const connection_t *connection,
+                        const msgbuf_t *msgbuf);
 
-void wldr_HandleWldrNotification(Wldr *wldr, const Connection *conn,
-                                 Message *message);
+void wldr_handle_notification(wldr_t *wldr, const connection_t *connection,
+                              const msgbuf_t *msgbuf);
 #endif  // wldr_h
diff --git a/hicn-light/src/hicn/io/CMakeLists.txt b/hicn-light/src/hicn/io/CMakeLists.txt
index cc4f7371f..68a5baec5 100644
--- a/hicn-light/src/hicn/io/CMakeLists.txt
+++ b/hicn-light/src/hicn/io/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -12,46 +12,22 @@
 # limitations under the License.
 
 list(APPEND HEADER_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/addressPair.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/ioOperations.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/listener.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/listenerSet.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/tcpListener.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/hicnListener.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/udpTunnel.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/tcpTunnel.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/udpConnection.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/udpListener.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/streamConnection.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/hicnTunnel.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/hicnConnection.h
 )
 
 list(APPEND SOURCE_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/addressPair.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/ioOperations.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/listenerSet.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/streamConnection.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/tcpListener.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/tcpTunnel.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/udpConnection.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/udpListener.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/udpTunnel.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/base.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/tcp.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/udp.c
 )
 
-if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
-  list(APPEND SOURCE_FILES
-    io/hicnTunnel.c
-    io/hicnConnection.c
-    io/hicnListener.c
-  )
-endif()
-
-set(TO_INSTALL_HEADER_FILES
-  ${TO_INSTALL_HEADER_FILES}
-  ${HEADER_FILES}
-  PARENT_SCOPE
-)
+#if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
+#  list(APPEND SOURCE_FILES
+#    io/hicnTunnel.c
+#    io/hicnConnection.c
+#    io/hicnListener.c
+#  )
+#endif()
 
 set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
-set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
\ No newline at end of file
+set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
diff --git a/hicn-light/src/hicn/io/addressPair.c b/hicn-light/src/hicn/io/addressPair.c
deleted file mode 100644
index f9451f900..000000000
--- a/hicn-light/src/hicn/io/addressPair.c
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_Hash.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Object.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/io/addressPair.h>
-
-struct address_pair {
-  Address *local;
-  Address *remote;
-};
-
-static void _addressPair_Destroy(AddressPair **addressPairPtr) {
-  AddressPair *pair = *addressPairPtr;
-
-  addressDestroy(&pair->local);
-  addressDestroy(&pair->remote);
-}
-
-parcObject_ExtendPARCObject(AddressPair, _addressPair_Destroy, NULL,
-                            addressPair_ToString, addressPair_Equals, NULL,
-                            addressPair_HashCode, NULL);
-
-parcObject_ImplementAcquire(addressPair, AddressPair);
-
-parcObject_ImplementRelease(addressPair, AddressPair);
-
-AddressPair *addressPair_Create(const Address *local, const Address *remote) {
-  parcAssertNotNull(local, "Parameter local must be non-null");
-  parcAssertNotNull(remote, "Parameter remote must be non-null");
-
-  AddressPair *pair = parcObject_CreateInstance(AddressPair);
-  parcAssertNotNull(pair, "Got null from parcObject_Create()");
-
-  pair->local = addressCopy(local);
-  pair->remote = addressCopy(remote);
-
-  return pair;
-}
-
-bool addressPair_Equals(const AddressPair *a, const AddressPair *b) {
-  if (a == b) {
-    return true;
-  }
-  if (a == NULL || b == NULL) {
-    return false;
-  }
-
-  if (addressEquals(a->local, b->local)) {
-    if (addressEquals(a->remote, b->remote)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-bool addressPair_EqualsAddresses(const AddressPair *a, const Address *local,
-                                 const Address *remote) {
-  if (a == NULL || local == NULL || remote == NULL) {
-    return false;
-  }
-
-  if (addressEquals(a->local, local)) {
-    if (addressEquals(a->remote, remote)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-char *addressPair_ToString(const AddressPair *pair) {
-  parcAssertNotNull(pair, "Parameter pair must be non-null");
-
-  char *local = addressToString(pair->local);
-  char *remote = addressToString(pair->remote);
-
-  char *output;
-  int failure = asprintf(&output, "{ .local=%s, .remote=%s }", local, remote);
-  parcAssertTrue(failure > -1, "Error on asprintf");
-
-  parcMemory_Deallocate((void **)&local);
-  parcMemory_Deallocate((void **)&remote);
-
-  return output;
-}
-
-const Address *addressPair_GetLocal(const AddressPair *pair) {
-  parcAssertNotNull(pair, "Parameter pair must be non-null");
-  return pair->local;
-}
-
-const Address *addressPair_GetRemote(const AddressPair *pair) {
-  parcAssertNotNull(pair, "Parameter pair must be non-null");
-  return pair->remote;
-}
-
-/**
- * @function addressPair_HashCode
- * @abstract Hash useful for tables.  Consistent with Equals.
- * @discussion
- *   Returns a non-cryptographic hash that is consistent with equals.  That is,
- *   if a == b, then hash(a) == hash(b).
- *
- */
-PARCHashCode addressPair_HashCode(const AddressPair *pair) {
-  PARCHashCode hashpair[2];
-  hashpair[0] = addressHashCode(pair->local);
-  hashpair[1] = addressHashCode(pair->remote);
-  return parcHashCode_Hash((const uint8_t *)hashpair, sizeof(hashpair));
-}
diff --git a/hicn-light/src/hicn/io/addressPair.h b/hicn-light/src/hicn/io/addressPair.h
deleted file mode 100644
index f1b72e0dc..000000000
--- a/hicn-light/src/hicn/io/addressPair.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * Used to identify a connection between a specific local address and
- * a specific remote address.
- */
-
-#ifndef address_Pair_h
-#define address_Pair_h
-
-#include <hicn/utils/address.h>
-
-struct address_pair;
-typedef struct address_pair AddressPair;
-
-/**
- * @function addressPair_Create
- * @abstract Creates and address pair.  There is no restriction on the address
- * types.
- * @discussion
- *   Creates an ordered pair of addresses, where the first is considered the
- * "local" address and the second is the "remote" address.  Those designations
- * are purely a convention used to name them, and does not imply any specifici
- * types of operations.
- *
- *   The two addresses may be of any address types (e.g. IPv4, IPv6, Local,
- * Ethernet). However, some functions that use an AddressPair may require that
- * the local and remote addresses be the same type.
- *
- */
-AddressPair *addressPair_Create(const Address *local, const Address *remote);
-
-/**
- * Returns a reference counted copy of the address pair
- *
- * Increments the reference count and returns the same address pair
- *
- * @param [in] addressPair An allocated address pair
- *
- * @retval non-null A reference counted copy
- * @retval null An error
- */
-AddressPair *addressPair_Acquire(const AddressPair *addressPair);
-
-/**
- * Releases a reference count to the object
- *
- * Decrements the reference count and destroys the object when it reaches 0.
- */
-void addressPair_Release(AddressPair **pairPtr);
-
-/**
- * Determine if two AddressPair instances are equal.
- *
- * Two AddressPair instances are equal if, and only if, the local and remote
- * addresses are identical. Equality is determined by addressEquals(a->local,
- * b->local) and Adress_Equals(a->remote, b->remote).
- *
- * The following equivalence relations on non-null `AddressPair` instances are
- * maintained:
- *
- *  * It is reflexive: for any non-null reference value x,
- * `AddressPair_Equals(x, x)` must return true.
- *
- *  * It is symmetric: for any non-null reference values x and y,
- *    `addressPair_Equals(x, y)` must return true if and only if
- *        `addressPair_Equals(y, x)` returns true.
- *
- *  * It is transitive: for any non-null reference values x, y, and z, if
- *        `addressPair_Equals(x, y)` returns true and
- *        `addressPair_Equals(y, z)` returns true,
- *        then  `addressPair_Equals(x, z)` must return true.
- *
- *  * It is consistent: for any non-null reference values x and y, multiple
- *      invocations of `addressPair_Equals(x, y)` consistently return true or
- *      consistently return false.
- *
- *  * For any non-null reference value x, `addressPair_Equals(x, NULL)` must
- *      return false.
- *
- * @param a A pointer to a `AddressPair` instance.
- * @param b A pointer to a `AddressPair` instance.
- * @return true if the two `AddressPair` instances are equal.
- */
-bool addressPair_Equals(const AddressPair *a, const AddressPair *b);
-
-/**
- * @function addressPair_EqualsAddresses
- * @abstract As AddressEquals, but "b" is broken out
- * @discussion
- *   Equality is determined by addressEquals(a->local, local) and
- *   Adress_Equals(a->remote, remote).
- */
-bool addressPair_EqualsAddresses(const AddressPair *a, const Address *local,
-                                 const Address *remote);
-
-const Address *addressPair_GetLocal(const AddressPair *pair);
-
-const Address *addressPair_GetRemote(const AddressPair *pair);
-
-/**
- * @function addressPair_HashCode
- * @abstract Hash useful for tables.  Consistent with Equals.
- * @discussion
- *   Returns a non-cryptographic hash that is consistent with equals.  That is,
- *   if a == b, then hash(a) == hash(b).
- */
-PARCHashCode addressPair_HashCode(const AddressPair *pair);
-
-/**
- * @function addressPair_ToString
- * @abstract Human readable string representation.  Caller must use free(3).
- */
-char *addressPair_ToString(const AddressPair *pair);
-#endif  // address_Pair_h
diff --git a/hicn-light/src/hicn/io/base.c b/hicn-light/src/hicn/io/base.c
new file mode 100644
index 000000000..71d10021e
--- /dev/null
+++ b/hicn-light/src/hicn/io/base.c
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file base.c
+ * #brief Implementation of base IO functions.
+ */
+
+#include <hicn/util/log.h>
+
+#include "base.h"
+
+/**
+ * @brief Helper function for listener to read a single packet on a socket
+ */
+ssize_t io_read_single_fd(int fd, msgbuf_t *msgbuf, address_t *address) {
+  uint8_t *packet = msgbuf_get_packet(msgbuf);
+  size_t size = msgbuf_get_len(msgbuf);
+
+  for (;;) {
+    ssize_t n = read(fd, packet, size);
+    if (n == 0) return n;
+    if (n < 0) {
+      if (errno == EINTR) continue;  // XXX was break;
+
+      /* ICMP unreachable due to closing the remote end of a connection */
+      if (errno == ECONNREFUSED) continue;
+
+      ERROR("read failed %d: (%d) %s", fd, errno, strerror(errno));
+      return -1;
+    }
+
+    msgbuf->length = n;
+    *address = ADDRESS_ANY(AF_UNSPEC, 0);  // XXX placeholder, see hicn.c
+  }
+
+  return 1;
+}
+
+ssize_t io_read_single_socket(int fd, msgbuf_t *msgbuf, address_t *address) {
+  struct sockaddr_storage *sa = &address->as_ss;
+  socklen_t sa_len = sizeof(sa);
+  uint8_t *packet = msgbuf_get_packet(msgbuf);
+
+  ssize_t n = recvfrom(fd, packet, MTU, 0, (struct sockaddr *)sa, &sa_len);
+  msgbuf->length = n;
+
+  return n;
+}
+
+#ifdef __linux__
+ssize_t io_read_batch_socket(int fd, msgbuf_t **msgbuf, address_t **address,
+                             size_t batch_size) {
+  struct mmsghdr msghdr[batch_size];
+  struct iovec iovecs[batch_size];
+  struct sockaddr_storage addrs[batch_size];
+
+  /* Prepare the mmghdr struct for recvmmsg */
+  for (unsigned i = 0; i < MAX_MSG; i++) {
+    struct mmsghdr *msg = &msghdr[i];
+    *msg = (struct mmsghdr){
+        .msg_hdr =
+            {
+                .msg_iov = &iovecs[i],
+                .msg_iovlen = 1,
+                .msg_name = &addrs[i],
+                .msg_namelen = sizeof(struct sockaddr_storage),
+                .msg_control = NULL,
+                .msg_controllen = 0,
+            },
+    };
+
+    iovecs[i] = (struct iovec){
+        .iov_base = msgbuf_get_packet(msgbuf[i]),
+        .iov_len = MTU,
+    };
+  }
+
+  int n;
+  for (;;) {
+    n = recvmmsg(fd, msghdr, batch_size, /* flags */ 0,
+                 /* timeout */ NULL);
+    if (n == 0) return 0;
+    if (n < 0) {
+      if (errno == EINTR) continue;  // XXX was break;
+
+      /* ICMP unreachable due to closing the remote end of a connection */
+      if (errno == ECONNREFUSED) break;
+      if (errno == EAGAIN) return n;  // Nothing to read
+
+      ERROR("read failed %d: (%d) %s", fd, errno, strerror(errno));
+      return (ssize_t)n;
+    }
+
+    /*
+     * Assign size to msgbuf, and put the source address into the array
+     * received in parameters, which corresponds to the remote parts of the
+     * connection (local part is setup in the listener itself, eg.
+     * listener_read_batch).
+     */
+    for (int i = 0; i < n; i++) {
+      struct mmsghdr *msg = &msghdr[i];
+      msgbuf[i]->length = msg->msg_len;
+
+      /*
+       * As is, the address we put in the array has uninitialized
+       * memory in it:
+       *     *address[i] = *(address_t*)msg->msg_hdr.msg_name;
+       *
+       * This can be confirmed by testing with the following
+       * memset which removes the valgrind errors:
+       *     memset(address[i], 0, sizeof(address_t));
+       *
+       * The solution is to copy only the part which we know is
+       * initialized (we have compatible types, since the destination, an
+       * address_t, is effectively a struct sockaddr_storage). We might
+       * eventually provide a helper for this to avoid similar mistakes.
+       */
+      //*address[i] = *(address_t*)msg->msg_hdr.msg_name;
+      memcpy(address[i], msg->msg_hdr.msg_name, msg->msg_hdr.msg_namelen);
+    }
+    break;
+  }
+
+  return n;
+}
+#endif /* __linux__ */
diff --git a/hicn-light/src/hicn/io/base.h b/hicn-light/src/hicn/io/base.h
new file mode 100644
index 000000000..3463c6760
--- /dev/null
+++ b/hicn-light/src/hicn/io/base.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file base.h
+ * #brief Base IO functions.
+ */
+
+#ifndef HICNLIGHT_IO_BASE
+#define HICNLIGHT_IO_BASE
+
+#include "../core/address_pair.h"
+#include "../core/msgbuf.h"
+
+#define MAX_MSG 128  // 64 //16 //32
+#define USE_CONNECTED_SOCKETS 1
+
+ssize_t io_read_single_fd(int fd, msgbuf_t* msgbuf, address_t* address);
+
+ssize_t io_read_single_socket(int fd, msgbuf_t* msgbuf, address_t* address);
+
+ssize_t io_read_batch_socket(int fd, msgbuf_t** msgbuf, address_t** address,
+                             size_t n);
+
+#endif /* HICNLIGHT_IO_BASE */
diff --git a/hicn-light/src/hicn/io/hicn.c b/hicn-light/src/hicn/io/hicn.c
new file mode 100644
index 000000000..8b4ad2e00
--- /dev/null
+++ b/hicn-light/src/hicn/io/hicn.c
@@ -0,0 +1,450 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file hicn.c
+ * @brief Implementation of hicn face
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <hicn/hicn-light/config.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <hicn/util/log.h>
+
+#include "base.h"
+#include "../core/listener.h"
+#include "../core/listener_vft.h"
+#include "../core/connection.h"
+#include "../core/connection_vft.h"
+#include "../core/connection_table.h"
+#include "../core/forwarder.h"
+#include "../core/mapme.h"
+#include "../socket/api.h"
+
+#ifdef __linux__
+#include "../socket/error.h"
+
+#define IPv6 6
+#define IPv4 4
+#define MTU_SIZE 1500  // bytes
+#define MAX_HICN_RETRY 5
+#define DEFAULT_PORT 1234
+
+// XXX #if !defined(__APPLE__) && !defined(__ANDROID__) && !defined(_WIN32) &&
+// defined(PUNTING)
+
+// XXX the socket helper should be moved here as we can have a single hicn
+// listener
+
+#if 0
+static
+const
+address_pair_t *
+_createRecvAddressPairFromPacket(const uint8_t *msgBuffer) {
+    address_t * packetSrcAddr = NULL; /* This one is in the packet */
+    address_t * localAddr = NULL; /* This one is to be determined */
+
+    if (messageHandler_GetIPPacketType(msgBuffer) == IPv6_TYPE) {
+        struct sockaddr_in6 addr_in6;
+        addr_in6.sin6_family = AF_INET6;
+        addr_in6.sin6_port = htons(DEFAULT_PORT);
+        addr_in6.sin6_flowinfo = 0;
+        addr_in6.sin6_scope_id = 0;
+        memcpy(&addr_in6.sin6_addr,
+                (struct in6_addr *)messageHandler_GetSource(msgBuffer), 16);
+        packetSrcAddr = addressCreateFromInet6(&addr_in6);
+
+        /* We now determine the local address used to reach the packet src address */
+#ifndef _WIN32
+        int sock = socket (AF_INET6, SOCK_DGRAM, 0);
+#else
+        int sock = (int)socket (AF_INET6, SOCK_DGRAM, 0);
+#endif /* _WIN32 */
+        if (sock < 0)
+            goto ERR;
+
+        struct sockaddr_in6 remote, local;
+        memset(&remote, 0, sizeof(remote));
+        remote.sin6_family = AF_INET6;
+        remote.sin6_addr = addr_in6.sin6_addr;
+        remote.sin6_port = htons(DEFAULT_PORT);
+
+        socklen_t locallen = sizeof(local);
+        if (connect(sock, (const struct sockaddr*)&remote, sizeof(remote)) == -1)
+            goto ERR;
+        if (getsockname(sock, (struct sockaddr*) &local, &locallen) == -1)
+            goto ERR;
+
+        local.sin6_port = htons(DEFAULT_PORT);
+        localAddr = addressCreateFromInet6(&local);
+
+        close(sock);
+
+    } else if (messageHandler_GetIPPacketType(msgBuffer) == IPv4_TYPE) {
+        struct sockaddr_in addr_in;
+        addr_in.sin_family = AF_INET;
+        addr_in.sin_port = htons(DEFAULT_PORT);
+        memcpy(&addr_in.sin_addr,
+                (struct in_addr *)messageHandler_GetSource(msgBuffer), 4);
+        packetSrcAddr = addressCreateFromInet(&addr_in);
+
+        /* We now determine the local address used to reach the packet src address */
+
+#ifndef _WIN32
+        int sock = socket (AF_INET, SOCK_DGRAM, 0);
+#else
+        int sock = (int)socket (AF_INET, SOCK_DGRAM, 0);
+#endif /* _WIN32 */
+        if (sock < 0) {
+            perror("Socket error");
+            goto ERR;
+        }
+
+        struct sockaddr_in remote, local;
+        memset(&remote, 0, sizeof(remote));
+        remote.sin_family = AF_INET;
+        remote.sin_addr = addr_in.sin_addr;
+        remote.sin_port = htons(DEFAULT_PORT);
+
+        socklen_t locallen = sizeof(local);
+        if (connect(sock, (const struct sockaddr*)&remote, sizeof(remote)) == -1)
+            goto ERR;
+        if (getsockname(sock, (struct sockaddr*) &local, &locallen) == -1)
+            goto ERR;
+
+        local.sin_port = htons(DEFAULT_PORT);
+        localAddr = addressCreateFromInet(&local);
+
+        close(sock);
+    }
+    /* As this is a receive pair, we swap src and dst */
+    return addressPair_Create(localAddr, packetSrcAddr);
+
+ERR:
+    perror("Socket error");
+    return NULL;
+}
+
+static
+bool _isEmptyAddressIPv6(address_t * address) {
+    struct sockaddr_in6 *addr6 =
+        parcMemory_AllocateAndClear(sizeof(struct sockaddr_in6));
+    parcAssertNotNull(addr6, "parcMemory_AllocateAndClear(%zu) returned NULL",
+            sizeof(addr6));
+
+    addressGetInet6(address, addr6);
+
+    bool res = true;
+    for (int i = 0; i < 16; ++i) {
+        if (addr6->sin6_addr.s6_addr[i] != 0) {
+            res = false;
+        }
+    }
+
+    parcMemory_Deallocate((void **)&addr6);
+
+    return res;
+}
+
+}
+
+static
+const Connection *
+_lookupConnection(ListenerOps * listener, const address_pair_t *pair)
+{
+    HicnListener * hicn = (HicnListener*)listener->context;
+    const connection_table_t * table = forwarder_GetConnectionTable(hicn->forwarder);
+    const address_t * packetSourceAddress = address_pair_local(pair);
+
+    if (hicn->connection_id != -1)
+        return connection_table_get_by_id(table, hicn->connection_id);
+
+    if (!packetSourceAddress)
+        return NULL;
+
+    // in this first check we try to retrieve the standard connection
+    // generated by the hicn-light
+    const address_pair_t new_pair = {
+        .local = hicn->localAddress,
+        .remote = *packetSourceAddress,
+    };
+    return *connection_table_lookup(table, &new_pair);
+}
+
+
+// XXX TODO : rely on libhicn
+int
+_createAddressFromPacket(const uint8_t *packet, address_t * address)
+{
+    if (messageHandler_GetIPPacketType(packet) == IPv6_TYPE) {
+        struct sockaddr_in6 * sin6 = address6(address);
+        *sin6 = (struct sockaddr_in6) {
+            .sin6_family = AF_INET6,
+            .sin6_port = htons(DEFAULT_PORT),
+            .sin6_flowinfo = 0,
+            .sin6_scope_id = 0,
+        };
+        memcpy(&sin6->sin6_addr,
+                (struct in6_addr *)messageHandler_GetSource(packet), 16);
+        return 0;
+    } else if (messageHandler_GetIPPacketType(packet) == IPv4_TYPE) {
+        struct sockaddr_in * sin = address4(address);
+        *sin = (struct sockaddr_in) {
+            .sin_family = AF_INET,
+            .sin_port = htons(DEFAULT_PORT),
+        };
+        memcpy(&sin->sin_addr,
+                (struct in_addr *)messageHandler_GetSource(packet), 4);
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+#endif
+
+/******************************************************************************
+ * Listener
+ ******************************************************************************/
+
+typedef struct {
+  // address_t localAddress;  // this is the local address  or 0::0 in case of
+  // the
+  // main listener this is the address used inside
+  // forwarder to identify the listener. Notice that this
+  // address is the same as the fisical interfaces on
+  // which we create the TUN. it is NOT the TUN address
+  // which is given by libhicn after the bind operation
+  // However the user alway uses this address since is
+  // the only one available at configuration time
+
+  // XXX why do we need the id of the associated connection ?
+  int connection_id;  // this is used only if the listener is used to receive
+  // data packets we assume that 1 connection is associated
+  // to one listener in this case so we set the
+  // connection_id we the connection is create. if this id
+  // is not set and a data packet is received, the packet is
+  // dropped
+
+  hicn_socket_t *hicn_socket;
+  hicn_socket_helper_t *hicn_socket_helper;
+
+} listener_hicn_data_t;
+
+#define listener_hicn_read_callback listener_read_callback
+
+bool listener_hicn_bind(listener_t *listener, const address_t *address) {
+  assert(listener);
+  assert(address);
+
+  listener_hicn_data_t *data = listener->data;
+  assert(data);
+
+  char *address_str = malloc(/* max */ INET6_ADDRSTRLEN);
+  inet_ntop(address_family(address), address, address_str,
+            /* max */ INET6_ADDRSTRLEN);
+  int rc = hicn_bind(data->hicn_socket_helper, listener->fd, address_str);
+  if (rc < 0) {
+    ERROR("hicn_bind failed %d %s", rc, hicn_socket_strerror(rc));
+    free(address_str);
+    return false;
+  }
+
+  free(address_str);
+  return true;
+}
+
+static int listener_hicn_initialize(listener_t *listener) {
+  assert(listener);
+
+  listener_hicn_data_t *data = listener->data;
+  assert(data);
+
+  /* This is the id of the connection associated to this listener (unique in
+   * the case of hICN */
+  data->connection_id = -1;
+
+  data->hicn_socket_helper = hicn_create();
+  if (!data->hicn_socket) goto ERR_HELPER;
+
+  if (address_empty(&listener->address)) {
+    listener->fd = hicn_socket(data->hicn_socket_helper, listener->name, NULL);
+  } else {
+    char *local_addr = malloc(/* max */ INET6_ADDRSTRLEN);
+    inet_ntop(address_family(&listener->address), &listener->address,
+              local_addr, /* max */ INET6_ADDRSTRLEN);
+    listener->fd =
+        hicn_socket(data->hicn_socket_helper, listener->name, local_addr);
+    free(local_addr);
+  }
+
+  if (listener->fd < 0) {
+    ERROR("HicnListener %s: error creating hICN listener", listener->name);
+    goto ERR_FD;
+  }
+
+  // Set non-blocking flag
+  int flags = fcntl(listener->fd, F_GETFL, NULL);
+  if (flags != -1) {
+    ERROR("fcntl failed to obtain file descriptor flags (%d)", errno);
+    goto ERR_FLAGS;
+  }
+
+  if (fcntl(listener->fd, F_SETFL, flags | O_NONBLOCK) < 0) {
+    ERROR("fcntl failed to set file descriptor flags (%d)", errno);
+    goto ERR_FLAGS;
+  }
+
+  return 0;
+
+ERR_FLAGS:
+  close(listener->fd);
+ERR_FD:
+  hicn_free(data->hicn_socket_helper);
+ERR_HELPER:
+  return -1;
+}
+
+static void listener_hicn_finalize(listener_t *listener) {
+  assert(listener);
+  assert(listener_get_type(listener) == FACE_TYPE_HICN);
+
+  listener_hicn_data_t *data = listener->data;
+  assert(data);
+
+  // TODO destroy hicn_socket
+  // TODO free(data) (like in other classes)
+
+  hicn_free(data->hicn_socket_helper);
+  // XXX
+  // hicn_socket_free(data->hicn_socket);
+
+  return;
+}
+
+static int listener_hicn_punt(const listener_t *listener,
+                              const char *prefix_s) {
+  assert(listener);
+  assert(listener_get_type(listener) == FACE_TYPE_HICN);
+  assert(prefix_s);
+
+  listener_hicn_data_t *data = listener->data;
+  assert(data);
+
+  int rc;
+  for (int retry = 0; retry < MAX_HICN_RETRY; retry++) {
+    if ((rc = hicn_listen(data->hicn_socket_helper, listener->fd, prefix_s)) >=
+        0)
+      return 0;
+    sleep(1);
+  }
+  ERROR("hicn_listen failed %d %s", rc, hicn_socket_strerror(rc));
+  return -1;
+}
+
+static int listener_hicn_get_socket(const listener_t *listener,
+                                    const address_t *local,
+                                    const address_t *remote,
+                                    const char *interface_name) {
+  assert(listener);
+  assert(listener_get_type(listener) == FACE_TYPE_HICN);
+  assert(local);
+  assert(remote);
+
+  /* ... */
+
+  return -1;
+}
+
+#define listener_hicn_read_single io_read_single_fd
+#define listener_hicn_read_batch NULL
+
+DECLARE_LISTENER(hicn);
+
+/******************************************************************************
+ * Connection
+ ******************************************************************************/
+
+typedef struct {
+  /* ... */
+} connection_hicn_data_t;
+
+static int connection_hicn_initialize(connection_t *connection) {
+  assert(connection);
+  assert(connection_get_type(connection) == FACE_TYPE_HICN);
+
+  /* ... */
+
+  return 0;
+}
+
+static void connection_hicn_finalize(connection_t *connection) {
+  /* ... */
+
+  return;
+}
+
+static bool connection_hicn_flush(const connection_t *connection) {
+  return false;
+}
+
+static bool connection_hicn_send(const connection_t *connection,
+                                 msgbuf_t *msgbuf, bool queue) {
+  assert(connection);
+  /* msgbuf can be NULL */
+
+  //    connection_hicn_data_t * data = connection->data;
+  //    assert(data);
+
+  /* ... */
+
+  return false;
+}
+
+// static
+// int
+// connection_hicn_sendv(const connection_t * connection, struct iovec * iov,
+//        size_t size)
+//{
+//
+//    assert(connetion);
+//    assert(iov);
+//
+////    connection_hicn_data_t * data = connection->data;
+////    assert(data);
+//
+//    /* ... */
+//
+//    return 0;
+//}
+//
+static int connection_hicn_send_packet(const connection_t *connection,
+                                       const uint8_t *packet, size_t size) {
+  assert(connection);
+  assert(packet);
+
+  /* ... */
+
+  return 0;
+}
+
+DECLARE_CONNECTION(hicn);
+
+#endif
diff --git a/hicn-light/src/hicn/io/hicnConnection.c b/hicn-light/src/hicn/io/hicnConnection.c
deleted file mode 100644
index 646cea990..000000000
--- a/hicn-light/src/hicn/io/hicnConnection.c
+++ /dev/null
@@ -1,541 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * Embodies the reader/writer for a Hicn connection
- *
- * NB The Send() function may overflow the output buffer
- *
- */
-
-#include <errno.h>
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/uio.h>
-#include <unistd.h>
-
-#include <hicn/core/message.h>
-#include <hicn/io/hicnConnection.h>
-
-#include <hicn/core/messageHandler.h>
-
-#include <parc/algol/parc_Hash.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/core/connection.h>
-#include <hicn/core/forwarder.h>
-
-typedef struct hicn_state {
-  Forwarder *forwarder;
-  char * interfaceName;
-  Logger *logger;
-
-  // the hicn listener socket we receive packets on
-  int hicnListenerSocket;
-
-  AddressPair *addressPair;
-
-  // We need to access this all the time, so grab it out
-  // of the addressPair;
-  struct sockaddr *peerAddress;
-  socklen_t peerAddressLength;
-
-  struct sockaddr *localAddress;
-  socklen_t localAddressLength;
-
-  bool isLocal;
-  bool isUp;
-  unsigned id;
-
-  unsigned delay;
-
-  /* This information would better be stored in the connection data structure
-   * but it is currently not reachable from within the implementation. */
-  connection_state_t state;
-  connection_state_t admin_state;
-#ifdef WITH_POLICY
-  uint32_t priority;
-#endif /* WITH_POLICY */
-} _HicnState;
-
-// Prototypes
-static bool _send(IoOperations *ops, const Address *nexthop, Message *message);
-static bool _sendIOVBuffer(IoOperations *ops, struct iovec *message,
-    size_t size);
-static const Address *_getRemoteAddress(const IoOperations *ops);
-static const AddressPair *_getAddressPair(const IoOperations *ops);
-static unsigned _getConnectionId(const IoOperations *ops);
-static bool _isUp(const IoOperations *ops);
-static bool _isLocal(const IoOperations *ops);
-static void _destroy(IoOperations **opsPtr);
-static list_connections_type _getConnectionType(const IoOperations *ops);
-static void _sendProbe(IoOperations *ops, uint8_t *message);
-static connection_state_t _getState(const IoOperations *ops);
-static void _setState(IoOperations *ops, connection_state_t state);
-static connection_state_t _getAdminState(const IoOperations *ops);
-static void _setAdminState(IoOperations *ops, connection_state_t admin_state);
-#ifdef WITH_POLICY
-static uint32_t _getPriority(const IoOperations *ops);
-static void _setPriority(IoOperations *ops, uint32_t priority);
-#endif /* WITH_POLICY */
-static const char * _getInterfaceName(const IoOperations *ops);
-
-/*
- * This assigns a unique pointer to the void * which we use
- * as a GUID for this class.
- */
-static const void *_ioOperationsGuid = __FILE__;
-
-/*
- * Return our GUID
- */
-static const void *_streamConnection_Class(const IoOperations *ops) {
-  return _ioOperationsGuid;
-}
-
-static IoOperations _template = {
-  .closure = NULL,
-  .send = &_send,
-  .sendIOVBuffer = &_sendIOVBuffer,
-  .getRemoteAddress = &_getRemoteAddress,
-  .getAddressPair = &_getAddressPair,
-  .getConnectionId = &_getConnectionId,
-  .isUp = &_isUp,
-  .isLocal = &_isLocal,
-  .destroy = &_destroy,
-  .class = &_streamConnection_Class,
-  .getConnectionType = &_getConnectionType,
-  .sendProbe = &_sendProbe,
-  .getState = &_getState,
-  .setState = &_setState,
-  .getAdminState = &_getAdminState,
-  .setAdminState = &_setAdminState,
-#ifdef WITH_POLICY
-  .getPriority = &_getPriority,
-  .setPriority = &_setPriority,
-#endif /* WITH_POLICY */
-  .getInterfaceName = &_getInterfaceName,
-};
-
-// =================================================================
-
-static void _setConnectionState(_HicnState *Hicn, bool isUp);
-static bool _saveSockaddr(_HicnState *hicnConnState, const AddressPair *pair);
-
-IoOperations *hicnConnection_Create(Forwarder *forwarder, const char * interfaceName, int fd,
-                                    const AddressPair *pair, bool isLocal) {
-  IoOperations *io_ops = NULL;
-
-  _HicnState *hicnConnState = parcMemory_AllocateAndClear(sizeof(_HicnState));
-  parcAssertNotNull(hicnConnState,
-                    "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(_HicnState));
-
-  hicnConnState->forwarder = forwarder;
-  hicnConnState->interfaceName = strdup(interfaceName);
-  hicnConnState->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-
-  bool saved = _saveSockaddr(hicnConnState, pair);
-  if (saved) {
-    hicnConnState->hicnListenerSocket = fd;
-    hicnConnState->id = forwarder_GetNextConnectionId(forwarder);
-    hicnConnState->addressPair = addressPair_Acquire(pair);
-    hicnConnState->isLocal = isLocal;
-
-    // allocate a connection
-    io_ops = parcMemory_AllocateAndClear(sizeof(IoOperations));
-    parcAssertNotNull(io_ops, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                      sizeof(IoOperations));
-    memcpy(io_ops, &_template, sizeof(IoOperations));
-    io_ops->closure = hicnConnState;
-
-    _setConnectionState(hicnConnState, true);
-
-#ifdef WITH_POLICY
-    hicnConnState->priority = 0;
-#endif /* WITH_POLICY */
-
-    if (logger_IsLoggable(hicnConnState->logger, LoggerFacility_IO,
-                          PARCLogLevel_Info)) {
-      char *str = addressPair_ToString(hicnConnState->addressPair);
-      logger_Log(hicnConnState->logger, LoggerFacility_IO, PARCLogLevel_Info,
-                 __func__,
-                 "HicnConnection %p created for address %s (isLocal %d)",
-                 (void *)hicnConnState, str, hicnConnState->isLocal);
-      free(str);
-    }
-
-    messenger_Send(
-        forwarder_GetMessenger(forwarder),
-        missive_Create(MissiveType_ConnectionCreate, hicnConnState->id));
-    messenger_Send(forwarder_GetMessenger(forwarder),
-                   missive_Create(MissiveType_ConnectionUp, hicnConnState->id));
-  } else {
-    // _saveSockaddr will already log an error, no need for extra log message
-    // here
-    logger_Release(&hicnConnState->logger);
-    free(hicnConnState->interfaceName);
-    parcMemory_Deallocate((void **)&hicnConnState);
-  }
-
-  return io_ops;
-}
-
-// =================================================================
-// I/O Operations implementation
-
-static void _destroy(IoOperations **opsPtr) {
-  parcAssertNotNull(opsPtr, "Parameter opsPtr must be non-null double pointer");
-  parcAssertNotNull(*opsPtr,
-                    "Parameter opsPtr must dereference to non-null pointer");
-
-  IoOperations *ops = *opsPtr;
-  parcAssertNotNull(ioOperations_GetClosure(ops),
-                    "ops->context must not be null");
-
-  _HicnState *hicnConnState = (_HicnState *)ioOperations_GetClosure(ops);
-  addressPair_Release(&hicnConnState->addressPair);
-  parcMemory_Deallocate((void **)&(hicnConnState->peerAddress));
-  parcMemory_Deallocate((void **)&(hicnConnState->localAddress));
-
-  messenger_Send(
-      forwarder_GetMessenger(hicnConnState->forwarder),
-      missive_Create(MissiveType_ConnectionDestroyed, hicnConnState->id));
-
-  if (logger_IsLoggable(hicnConnState->logger, LoggerFacility_IO,
-                        PARCLogLevel_Info)) {
-    logger_Log(hicnConnState->logger, LoggerFacility_IO, PARCLogLevel_Info,
-               __func__, "HicnConnection %p destroyed", (void *)hicnConnState);
-  }
-
-  // do not close hicListenerSocket, the listener will close
-  // that when its done
-  // should I say something to libhicn?
-
-  logger_Release(&hicnConnState->logger);
-  free(hicnConnState->interfaceName);
-  parcMemory_Deallocate((void **)&hicnConnState);
-  parcMemory_Deallocate((void **)&ops);
-
-  *opsPtr = NULL;
-}
-
-static bool _isUp(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _HicnState *hicnConnState =
-      (const _HicnState *)ioOperations_GetClosure(ops);
-  return hicnConnState->isUp;
-}
-
-static bool _isLocal(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _HicnState *hicnConnState =
-      (const _HicnState *)ioOperations_GetClosure(ops);
-  return hicnConnState->isLocal;
-}
-
-static const Address *_getRemoteAddress(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _HicnState *hicnConnState =
-      (const _HicnState *)ioOperations_GetClosure(ops);
-  return addressPair_GetRemote(hicnConnState->addressPair);
-}
-
-static const AddressPair *_getAddressPair(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _HicnState *hicnConnState =
-      (const _HicnState *)ioOperations_GetClosure(ops);
-  return hicnConnState->addressPair;
-}
-
-static unsigned _getConnectionId(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _HicnState *hicnConnState =
-      (const _HicnState *)ioOperations_GetClosure(ops);
-  return hicnConnState->id;
-}
-
-/**
- * @function hicnConnection_Send
- * @abstract Non-destructive send of the message.
- * @discussion
- *   sends a message to the peer.
- *
- * @param dummy is ignored. .
- */
-static bool _send(IoOperations *ops, const Address *dummy, Message *message) {
-  parcAssertNotNull(ops, "Parameter ops must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
-  _HicnState *hicnConnState = (_HicnState *)ioOperations_GetClosure(ops);
-
-  // NAT for HICN
-  if (message_GetType(message) == MessagePacketType_ContentObject) {
-    // this is a data packet. We need to put the remote address in the
-    // destination field
-
-    if (messageHandler_GetIPPacketType(message_FixedHeader(message)) ==
-        IPv6_TYPE) {
-      messageHandler_SetDestination_IPv6(
-          (uint8_t *)message_FixedHeader(message),
-          &((struct sockaddr_in6 *)hicnConnState->peerAddress)->sin6_addr);
-    } else {
-      messageHandler_SetDestination_IPv4(
-          (uint8_t *)message_FixedHeader(message),
-          &(((struct sockaddr_in *)hicnConnState->peerAddress)
-                ->sin_addr.s_addr));
-    }
-  } else if (message_GetType(message) == MessagePacketType_Interest) {
-    // this si an interest packet. We need to put the local address in the
-    // source field
-    if (messageHandler_GetIPPacketType(message_FixedHeader(message)) ==
-        IPv6_TYPE) {
-      messageHandler_SetSource_IPv6(
-          (uint8_t *)message_FixedHeader(message),
-          &((struct sockaddr_in6 *)hicnConnState->localAddress)->sin6_addr);
-    } else {
-      messageHandler_SetSource_IPv4(
-          (uint8_t *)message_FixedHeader(message),
-          &(((struct sockaddr_in *)hicnConnState->localAddress)
-                ->sin_addr.s_addr));
-    }
-  } else if (message_GetType(message) == MessagePacketType_WldrNotification) {
-    // here we don't need to do anything for now
-  } else {
-    // unkown packet
-    if (logger_IsLoggable(hicnConnState->logger, LoggerFacility_IO,
-                          PARCLogLevel_Debug)) {
-      logger_Log(hicnConnState->logger, LoggerFacility_IO, PARCLogLevel_Debug,
-                 __func__, "connid %u can't parse the message",
-                 hicnConnState->id);
-    }
-    return false;
-  }
-
-  ssize_t writeLength =
-      write(hicnConnState->hicnListenerSocket, message_FixedHeader(message),
-            message_Length(message));
-
-  if (writeLength < 0) {
-    if (errno == EAGAIN || errno == EWOULDBLOCK) {
-      return false;
-    } else {
-      // this print is for debugging
-      printf("Incorrect write length %zd, expected %zd: (%d) %s\n", writeLength,
-             message_Length(message), errno, strerror(errno));
-      return false;
-    }
-  }
-
-  return true;
-}
-
-static bool _sendIOVBuffer(IoOperations *ops, struct iovec *message,
-    size_t size) {
-  parcAssertNotNull(ops, "Parameter ops must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
-
-  _HicnState *hicnConnState = (_HicnState *)ioOperations_GetClosure(ops);
-
-
-  ssize_t n = writev(hicnConnState->hicnListenerSocket, message, size);
-  if (n < 0) {
-    if (errno != EAGAIN && errno != EWOULDBLOCK) {
-      if (logger_IsLoggable(hicnConnState->logger, LoggerFacility_IO,
-                  PARCLogLevel_Error)) {
-        size_t length = 0;
-        for (int i = 0; i < size; i++)
-          length += message[i].iov_len;
-        logger_Log(hicnConnState->logger, LoggerFacility_IO, PARCLogLevel_Error,
-                __func__, "Incorrect write length %zd, expected %zd: (%d) %s\n",
-                n, length, errno, strerror(errno));
-      }
-    }
-    return false;
-  }
-  return true;
-}
-
-static list_connections_type _getConnectionType(const IoOperations *ops) {
-  return CONN_HICN;
-}
-
-static void _sendProbe(IoOperations *ops, uint8_t *message) {
-  parcAssertNotNull(ops, "Parameter ops must be non-null");
-
-  _HicnState *hicnConnState = (_HicnState *)ioOperations_GetClosure(ops);
-
-  if(messageHandler_IsInterest(message)){//
-    // this is an interest packet. We need to put the local address in the
-    // source field
-    if (messageHandler_GetIPPacketType(message) == IPv6_TYPE) {
-      messageHandler_SetSource_IPv6(message,
-          &((struct sockaddr_in6 *)hicnConnState->localAddress)->sin6_addr);
-    } else {
-      messageHandler_SetSource_IPv4(message,
-          &(((struct sockaddr_in *)hicnConnState->localAddress)
-                ->sin_addr.s_addr));
-    }
-  }//if is a data packet the packet is already set (see
-   //messageHandler_CreateProbeReply)
-
-  ssize_t writeLength = write(hicnConnState->hicnListenerSocket, message,
-                                messageHandler_GetTotalPacketLength(message));
-
-  if (writeLength < 0) {
-    return;
-  }
-}
-
-// =================================================================
-// Internal API
-
-static bool _saveSockaddr(_HicnState *hicnConnState, const AddressPair *pair) {
-  bool success = false;
-  const Address *remoteAddress = addressPair_GetRemote(pair);
-  const Address *localAddress = addressPair_GetLocal(pair);
-  switch (addressGetType(remoteAddress)) {  // local must be of the same type
-
-    case ADDR_INET: {
-      size_t bytes = sizeof(struct sockaddr_in);
-      hicnConnState->peerAddress = parcMemory_Allocate(bytes);
-      parcAssertNotNull(hicnConnState->peerAddress,
-                        "parcMemory_Allocate(%zu) returned NULL", bytes);
-
-      addressGetInet(remoteAddress,
-                     (struct sockaddr_in *)hicnConnState->peerAddress);
-      hicnConnState->peerAddressLength = (socklen_t)bytes;
-
-      hicnConnState->localAddress = parcMemory_Allocate(bytes);
-      parcAssertNotNull(hicnConnState->localAddress,
-                        "parcMemory_Allocate(%zu) returned NULL", bytes);
-
-      addressGetInet(localAddress,
-                     (struct sockaddr_in *)hicnConnState->localAddress);
-      hicnConnState->localAddressLength = (socklen_t)bytes;
-      success = true;
-      break;
-    }
-
-    case ADDR_INET6: {
-      size_t bytes = sizeof(struct sockaddr_in6);
-      hicnConnState->peerAddress = parcMemory_Allocate(bytes);
-      parcAssertNotNull(hicnConnState->peerAddress,
-                        "parcMemory_Allocate(%zu) returned NULL", bytes);
-
-      addressGetInet6(remoteAddress,
-                      (struct sockaddr_in6 *)hicnConnState->peerAddress);
-      hicnConnState->peerAddressLength = (socklen_t)bytes;
-
-      hicnConnState->localAddress = parcMemory_Allocate(bytes);
-      parcAssertNotNull(hicnConnState->localAddress,
-                        "parcMemory_Allocate(%zu) returned NULL", bytes);
-
-      addressGetInet6(localAddress,
-                      (struct sockaddr_in6 *)hicnConnState->localAddress);
-      hicnConnState->localAddressLength = (socklen_t)bytes;
-      success = true;
-      break;
-    }
-
-    default:
-      if (logger_IsLoggable(hicnConnState->logger, LoggerFacility_IO,
-                            PARCLogLevel_Error)) {
-        char *str = addressToString(remoteAddress);
-        logger_Log(hicnConnState->logger, LoggerFacility_IO, PARCLogLevel_Error,
-                   __func__, "Remote address is not INET or INET6: %s", str);
-        parcMemory_Deallocate((void **)&str);
-      }
-      break;
-  }
-  return success;
-}
-
-static void _setConnectionState(_HicnState *hicnConnState, bool isUp) {
-  parcAssertNotNull(hicnConnState, "Parameter HICN must be non-null");
-
-  Messenger *messenger = forwarder_GetMessenger(hicnConnState->forwarder);
-
-  bool oldStateIsUp = hicnConnState->isUp;
-  hicnConnState->isUp = isUp;
-
-  if (oldStateIsUp && !isUp) {
-    // bring connection DOWN
-    Missive *missive =
-        missive_Create(MissiveType_ConnectionDown, hicnConnState->id);
-    messenger_Send(messenger, missive);
-    return;
-  }
-
-  if (!oldStateIsUp && isUp) {
-    // bring connection UP
-    Missive *missive =
-        missive_Create(MissiveType_ConnectionUp, hicnConnState->id);
-    messenger_Send(messenger, missive);
-    return;
-  }
-}
-
-static connection_state_t _getState(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _HicnState *hicnConnState =
-      (const _HicnState *)ioOperations_GetClosure(ops);
-  return hicnConnState->state;
-}
-
-static void _setState(IoOperations *ops, connection_state_t state) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  _HicnState *hicnConnState =
-      (_HicnState *)ioOperations_GetClosure(ops);
-  hicnConnState->state = state;
-}
-
-static connection_state_t _getAdminState(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _HicnState *hicnConnState =
-      (const _HicnState *)ioOperations_GetClosure(ops);
-  return hicnConnState->admin_state;
-}
-
-static void _setAdminState(IoOperations *ops, connection_state_t admin_state) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  _HicnState *hicnConnState =
-      (_HicnState *)ioOperations_GetClosure(ops);
-  hicnConnState->admin_state = admin_state;
-}
-
-#ifdef WITH_POLICY
-static uint32_t _getPriority(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _HicnState *hicnConnState =
-      (const _HicnState *)ioOperations_GetClosure(ops);
-  return hicnConnState->priority;
-}
-
-static void _setPriority(IoOperations *ops, uint32_t priority) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  _HicnState *hicnConnState =
-      (_HicnState *)ioOperations_GetClosure(ops);
-  hicnConnState->priority = priority;
-}
-#endif /* WITH_POLICY
-*/
-static const char * _getInterfaceName(const IoOperations *ops)
-{
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  _HicnState *hicnConnState =
-      (_HicnState *)ioOperations_GetClosure(ops);
-  return hicnConnState->interfaceName;
-}
diff --git a/hicn-light/src/hicn/io/hicnConnection.h b/hicn-light/src/hicn/io/hicnConnection.h
deleted file mode 100644
index fec18e1bd..000000000
--- a/hicn-light/src/hicn/io/hicnConnection.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * 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 hicnConnection.h
- * @brief Represents a Hicn connection for the connection table
- *
- * <#Detailed Description#>
- *
- */
-
-#ifndef hicnConnection_h
-#define hicnConnection_h
-
-#include <hicn/core/forwarder.h>
-#include <hicn/io/addressPair.h>
-#include <hicn/io/ioOperations.h>
-#include <hicn/utils/address.h>
-
-/**
- * Creates a Hicn connection that can send to the remote address
- *
- * The address pair must both be same type (i.e. INET or INET6).
- *
- * @param [in] an allocated hicn-light Forwarder (saves reference)
- * @param [in] fd The socket to use
- * @param [in] pair An allocated address pair for the connection (saves
- * reference)
- * @param [in] isLocal determines if the remote address is on the current system
- *
- * @retval non-null An allocated Io operations
- * @retval null An error
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-IoOperations *hicnConnection_Create(Forwarder *forwarder, const char * interfaceName, int fd,
-                                    const AddressPair *pair, bool isLocal);
-#endif  // hicnConnection_h
diff --git a/hicn-light/src/hicn/io/hicnListener.c b/hicn-light/src/hicn/io/hicnListener.c
deleted file mode 100644
index 8647a4d54..000000000
--- a/hicn-light/src/hicn/io/hicnListener.c
+++ /dev/null
@@ -1,673 +0,0 @@
-/*
- * 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 <errno.h>
-#include <fcntl.h>
-#include <hicn/hicn-light/config.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <unistd.h>
-
-#include <hicn/io/hicnConnection.h>
-#include <hicn/io/hicnListener.h>
-
-#include <hicn/core/connection.h>
-#include <hicn/core/connectionTable.h>
-#include <hicn/core/forwarder.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/core/mapme.h>
-#include <hicn/core/messagePacketType.h>
-#include <hicn/io/listener.h>
-#include <hicn/socket/api.h>
-
-#define IPv6 6
-#define IPv4 4
-#define MTU_SIZE 1500  // bytes
-#define MAX_HICN_RETRY 5
-
-struct hicn_listener {
-
-  char *listenerName;
-
-  Forwarder *forwarder;
-  Logger *logger;
-
-  PARCEvent *hicn_event;
-  int hicn_fd;  // this is the file descriptor got from hicn library
-
-  Address
-      *localAddress;  // this is the local address  or 0::0 in case of the
-                      // main listener this is the address used inside
-                      // forwarder to identify the listener. Notice that this
-                      // address is the same as the fisical interfaces on
-                      // which we create the TUN. it is NOT the TUN address
-                      // which is given by libhicn after the bind operation
-                      // However the user alway uses this address since is
-                      // the only one available at configuration time
-
-  unsigned inetFamily;
-
-  int connection_id;  // this is used only if the listener is used to receive
-                      // data packets we assume that 1 connection is associated
-                      // to one listener in this case so we set the
-                      // connection_id we the connection is create. if this id
-                      // is not set and a data packet is received, the packet is
-                      // dropped
-
-  unsigned conn_id;
-};
-
-static void _destroy(ListenerOps **listenerOpsPtr);
-static const char *_getListenerName(const ListenerOps *ops);
-static const char *_getInterfaceName(const ListenerOps *ops);
-static unsigned _getInterfaceIndex(const ListenerOps *ops);
-static const Address *_getListenAddress(const ListenerOps *ops);
-static EncapType _getEncapType(const ListenerOps *ops);
-static int _getSocket(const ListenerOps *ops);
-static unsigned _createNewConnection(ListenerOps *listener, int fd, const AddressPair *pair);
-static const Connection * _lookupConnection(ListenerOps * listener, const AddressPair *pair);
-static Message *_readMessage(ListenerOps * listener, int fd, uint8_t *msgBuffer);
-static void _hicnListener_readcb(int fd, PARCEventType what, void *listener_void);
-static Address *_createAddressFromPacket(uint8_t *msgBuffer);
-static void _handleWldrNotification(ListenerOps *listener, uint8_t *msgBuffer);
-static void _readFrameToDiscard(HicnListener *hicn, int fd);
-
-static ListenerOps _hicnTemplate = {
-  .context = NULL,
-  .destroy = &_destroy,
-  .getInterfaceIndex = &_getInterfaceIndex,
-  .getListenAddress = &_getListenAddress,
-  .getEncapType = &_getEncapType,
-  .getSocket = &_getSocket,
-  .getInterfaceName = &_getInterfaceName,
-  .getListenerName = &_getListenerName,
-  .createConnection = &_createNewConnection,
-  .lookupConnection = &_lookupConnection,
-};
-
-static bool _isEmptyAddressIPv6(Address *address) {
-  struct sockaddr_in6 *addr6 =
-      parcMemory_AllocateAndClear(sizeof(struct sockaddr_in6));
-  parcAssertNotNull(addr6, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(addr6));
-
-  addressGetInet6(address, addr6);
-
-  bool res = true;
-  for (int i = 0; i < 16; ++i) {
-    if (addr6->sin6_addr.s6_addr[i] != 0) {
-      res = false;
-    }
-  }
-
-  parcMemory_Deallocate((void **)&addr6);
-
-  return res;
-}
-
-static Message *_readMessage(ListenerOps * listener, int fd, uint8_t *msgBuffer) {
-  HicnListener * hicn = (HicnListener*)listener->context;
-  Message *message = NULL;
-
-  ssize_t readLength = read(fd, msgBuffer, MTU_SIZE);
-
-  if (readLength < 0) {
-    printf("read failed %d: (%d) %s\n", fd, errno, strerror(errno));
-    return message;
-  }
-
-  size_t packetLength = messageHandler_GetTotalPacketLength(msgBuffer);
-
-  if (readLength != packetLength) {
-    parcMemory_Deallocate((void **)&msgBuffer);
-    return message;
-  }
-
-  if (messageHandler_IsTCP(msgBuffer)) {
-    MessagePacketType pktType;
-    unsigned connid = 0;
-    if (messageHandler_IsData(msgBuffer)) {
-      pktType = MessagePacketType_ContentObject;
-      if (hicn->connection_id == -1) {
-        parcMemory_Deallocate((void **)&msgBuffer);
-        return message;
-      } else {
-        connid = hicn->connection_id;
-      }
-    } else if (messageHandler_IsInterest(msgBuffer)) {
-      // notice that the connections for the interest (the one that we create at
-      // run time) uses as a local address 0::0, so the main tun
-      pktType = MessagePacketType_Interest;
-      Address *packetAddr = _createAddressFromPacket(msgBuffer);
-
-      AddressPair *pair_find = addressPair_Create(packetAddr, /* dummy */ hicn->localAddress);
-      const Connection *conn = _lookupConnection(listener, pair_find);
-      addressPair_Release(&pair_find);
-      if (conn == NULL) {
-        AddressPair *pair = addressPair_Create(hicn->localAddress, packetAddr);
-        connid = _createNewConnection(listener, fd, pair);
-        addressPair_Release(&pair);
-      } else {
-        connid = connection_GetConnectionId(conn);
-      }
-      addressDestroy(&packetAddr);
-    } else {
-      printf("Got a packet that is not a data nor an interest, drop it!\n");
-      parcMemory_Deallocate((void **)&msgBuffer);
-      return message;
-    }
-
-    message = message_CreateFromByteArray(connid, msgBuffer, pktType,
-                                          forwarder_GetTicks(hicn->forwarder),
-                                          forwarder_GetLogger(hicn->forwarder));
-    if (message == NULL) {
-      parcMemory_Deallocate((void **)&msgBuffer);
-    }
-  } else if (messageHandler_IsWldrNotification(msgBuffer)) {
-    _handleWldrNotification(listener, msgBuffer);
-  } else {
-    messageHandler_handleHooks(hicn->forwarder, msgBuffer, listener, fd, NULL);
-    parcMemory_Deallocate((void **)&msgBuffer);
-  }
-
-  return message;
-}
-
-static void _receivePacket(ListenerOps * listener, int fd) {
-  HicnListener * hicn = (HicnListener*)listener->context;
-  Message *msg = NULL;
-  uint8_t *msgBuffer = parcMemory_AllocateAndClear(MTU_SIZE);
-  msg = _readMessage(listener, fd, msgBuffer);
-
-  if (msg) {
-    forwarder_Receive(hicn->forwarder, msg);
-  }
-}
-
-static void _hicnListener_readcb(int fd, PARCEventType what, void *listener_void) {
-  ListenerOps * listener = (ListenerOps *)listener_void;
-  HicnListener *hicn = (HicnListener *)listener->context;
-
-  if (hicn->inetFamily == IPv4 || hicn->inetFamily == IPv6) {
-    if (what & PARCEventType_Read) {
-      _receivePacket(listener, fd);
-    }
-  } else {
-    _readFrameToDiscard(hicn, fd);
-  }
-}
-
-static bool _isEmptyAddressIPv4(Address *address) {
-  bool res = false;
-
-  char * str = addressToString(address);
-  if (strcmp("inet4://0.0.0.0:1234", str) == 0) res = true;
-  parcMemory_Deallocate((void**)&str);
-
-  return res;
-}
-
-ListenerOps *hicnListener_CreateInet(Forwarder *forwarder, char *symbolic,
-                                     Address *address) {
-  HicnListener *hicn = parcMemory_AllocateAndClear(sizeof(HicnListener));
-  parcAssertNotNull(hicn, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(HicnListener));
-
-  hicn->forwarder = forwarder;
-  hicn->listenerName = parcMemory_StringDuplicate(symbolic, strlen(symbolic));
-  hicn->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-
-  hicn->conn_id = forwarder_GetNextConnectionId(forwarder);
-  hicn->inetFamily = IPv4;
-
-  hicn->connection_id = -1;
-
-  hicn_socket_helper_t *hicnSocketHelper =
-      forwarder_GetHicnSocketHelper(forwarder);
-
-  if (_isEmptyAddressIPv4(address)) {
-    hicn->hicn_fd = hicn_socket(hicnSocketHelper, symbolic, NULL);
-  } else {
-    struct sockaddr_in *tmpAddr =
-        parcMemory_AllocateAndClear(sizeof(struct sockaddr_in));
-    parcAssertNotNull(tmpAddr, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                      sizeof(tmpAddr));
-    addressGetInet(address, tmpAddr);
-    char *local_addr = parcMemory_AllocateAndClear(INET_ADDRSTRLEN);
-    inet_ntop(AF_INET, &(tmpAddr->sin_addr), local_addr, INET_ADDRSTRLEN);
-    parcMemory_Deallocate((void **)&tmpAddr);
-
-    hicn->hicn_fd = hicn_socket(hicnSocketHelper, symbolic, local_addr);
-
-    parcMemory_Deallocate((void **)&local_addr);
-  }
-
-  if (hicn->hicn_fd < 0) {
-    if (logger_IsLoggable(hicn->logger, LoggerFacility_IO,
-                          PARCLogLevel_Debug)) {
-      logger_Log(
-          hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-          "HicnListener %s: error while creating an hicn listener in lib_hicn",
-          symbolic);
-    }
-    logger_Release(&hicn->logger);
-    addressDestroy(&hicn->localAddress);
-    parcMemory_Deallocate((void **)&hicn->listenerName);
-    parcMemory_Deallocate((void **)&hicn);
-    return NULL;
-  }
-
-  // Set non-blocking flag
-  int flags = fcntl(hicn->hicn_fd, F_GETFL, NULL);
-  parcAssertTrue(flags != -1,
-                 "fcntl failed to obtain file descriptor flags (%d)", errno);
-  int failure = fcntl(hicn->hicn_fd, F_SETFL, flags | O_NONBLOCK);
-  parcAssertFalse(failure, "fcntl failed to set file descriptor flags (%d)",
-                  errno);
-
-  ListenerOps *ops = parcMemory_AllocateAndClear(sizeof(ListenerOps));
-  parcAssertNotNull(ops, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(ListenerOps));
-
-  memcpy(ops, &_hicnTemplate, sizeof(ListenerOps));
-  ops->context = hicn;
-
-  hicn->hicn_event = dispatcher_CreateNetworkEvent(
-      forwarder_GetDispatcher(forwarder), true, _hicnListener_readcb,
-      (void *)ops, hicn->hicn_fd);
-  dispatcher_StartNetworkEvent(forwarder_GetDispatcher(forwarder),
-                               hicn->hicn_event);
-
-
-  if (logger_IsLoggable(hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug)) {
-    logger_Log(hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-               "HicnListener %s created", symbolic);
-  }
-
-  return ops;
-  return NULL;
-}
-
-ListenerOps *hicnListener_CreateInet6(Forwarder *forwarder, char *symbolic,
-                                      Address *address) {
-  HicnListener *hicn = parcMemory_AllocateAndClear(sizeof(HicnListener));
-  parcAssertNotNull(hicn, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(HicnListener));
-
-  hicn->forwarder = forwarder;
-  hicn->listenerName = parcMemory_StringDuplicate(symbolic, strlen(symbolic));
-  hicn->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-
-  hicn->conn_id = forwarder_GetNextConnectionId(forwarder);
-  hicn->localAddress = addressCopy(address);
-
-  hicn->inetFamily = IPv6;
-
-  hicn->connection_id = -1;
-
-  // the call to libhicn is the same both for the main and the normal listeners
-  // in both cases we need to set only the identifier. In the case of normal
-  // listener (listener for data packet) we let the library select the right ip
-  // address we just need to set the right type of packet
-
-  hicn_socket_helper_t *hicnSocketHelper =
-      forwarder_GetHicnSocketHelper(forwarder);
-
-  if (_isEmptyAddressIPv6(address)) {
-    // create main listener
-    hicn->hicn_fd = hicn_socket(hicnSocketHelper, symbolic, NULL);
-  } else {
-    // create listener for the connetion
-    struct sockaddr_in6 *tmpAddr =
-        parcMemory_AllocateAndClear(sizeof(struct sockaddr_in6));
-
-    parcAssertNotNull(tmpAddr, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                      sizeof(tmpAddr));
-    addressGetInet6(address, tmpAddr);
-
-    char *local_addr = parcMemory_AllocateAndClear(INET6_ADDRSTRLEN);
-    inet_ntop(AF_INET6, &(tmpAddr->sin6_addr), local_addr, INET6_ADDRSTRLEN);
-
-    parcMemory_Deallocate((void **)&tmpAddr);
-
-    hicn->hicn_fd = hicn_socket(hicnSocketHelper, symbolic, local_addr);
-
-    parcMemory_Deallocate((void **)&local_addr);
-  }
-
-  if (hicn->hicn_fd < 0) {
-    if (logger_IsLoggable(hicn->logger, LoggerFacility_IO,
-                          PARCLogLevel_Debug)) {
-      logger_Log(
-          hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-          "HicnListener %s: error while creating an hicn listener in lib_hicn",
-          symbolic);
-    }
-    logger_Release(&hicn->logger);
-    addressDestroy(&hicn->localAddress);
-    parcMemory_Deallocate((void **)&hicn->listenerName);
-    parcMemory_Deallocate((void **)&hicn);
-    return NULL;
-  }
-
-  // Set non-blocking flag
-  int flags = fcntl(hicn->hicn_fd, F_GETFL, NULL);
-  parcAssertTrue(flags != -1,
-                 "fcntl failed to obtain file descriptor flags (%d)", errno);
-  int failure = fcntl(hicn->hicn_fd, F_SETFL, flags | O_NONBLOCK);
-  parcAssertFalse(failure, "fcntl failed to set file descriptor flags (%d)",
-                  errno);
-
-  ListenerOps *ops = parcMemory_AllocateAndClear(sizeof(ListenerOps));
-  parcAssertNotNull(ops, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(ListenerOps));
-
-  memcpy(ops, &_hicnTemplate, sizeof(ListenerOps));
-  ops->context = hicn;
-
-  hicn->hicn_event = dispatcher_CreateNetworkEvent(
-      forwarder_GetDispatcher(forwarder), true, _hicnListener_readcb,
-      (void *)ops, hicn->hicn_fd);
-  dispatcher_StartNetworkEvent(forwarder_GetDispatcher(forwarder),
-                               hicn->hicn_event);
-
-  if (logger_IsLoggable(hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug)) {
-    logger_Log(hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-               "HicnListener %s created", symbolic);
-  }
-
-  return ops;
-}
-
-bool _hicnListener_BindInet6(ListenerOps *ops, const Address *remoteAddress) {
-  HicnListener *hicn = (HicnListener *)ops->context;
-  hicn_socket_helper_t *hicnSocketHelper =
-      forwarder_GetHicnSocketHelper(hicn->forwarder);
-
-  struct sockaddr_in6 *tmpAddr =
-      parcMemory_AllocateAndClear(sizeof(struct sockaddr_in6));
-  parcAssertNotNull(tmpAddr, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(tmpAddr));
-  addressGetInet6(remoteAddress, tmpAddr);
-  char *remote_addr = parcMemory_AllocateAndClear(INET6_ADDRSTRLEN);
-  inet_ntop(AF_INET6, &(tmpAddr->sin6_addr), remote_addr, INET6_ADDRSTRLEN);
-  parcMemory_Deallocate((void **)&tmpAddr);
-
-  int res = hicn_bind(hicnSocketHelper, hicn->hicn_fd, remote_addr);
-
-  bool result = false;
-  if (res < 0) {
-    if (logger_IsLoggable(hicn->logger, LoggerFacility_IO,
-                          PARCLogLevel_Debug)) {
-      logger_Log(hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-                 "hicn_bind failed %d %s", res, hicn_socket_strerror(res));
-    }
-  } else {
-    result = true;
-  }
-
-  parcMemory_Deallocate((void **)&remote_addr);
-
-  return result;
-}
-
-bool _hicnListener_BindInet(ListenerOps *ops, const Address *remoteAddress) {
-  HicnListener *hicn = (HicnListener *)ops->context;
-  hicn_socket_helper_t *hicnSocketHelper =
-      forwarder_GetHicnSocketHelper(hicn->forwarder);
-
-  struct sockaddr_in *tmpAddr =
-      parcMemory_AllocateAndClear(sizeof(struct sockaddr_in));
-  parcAssertNotNull(tmpAddr, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(tmpAddr));
-  addressGetInet(remoteAddress, tmpAddr);
-  char *remote_addr = parcMemory_AllocateAndClear(INET_ADDRSTRLEN);
-  inet_ntop(AF_INET, &(tmpAddr->sin_addr), remote_addr, INET_ADDRSTRLEN);
-  parcMemory_Deallocate((void **)&tmpAddr);
-
-  int res = hicn_bind(hicnSocketHelper, hicn->hicn_fd, remote_addr);
-  bool result = false;
-
-  if (res < 0) {
-    if (logger_IsLoggable(hicn->logger, LoggerFacility_IO,
-                          PARCLogLevel_Debug)) {
-      logger_Log(hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-                 "hicn_bind failed %d %s", res, hicn_socket_strerror(res));
-    }
-  } else {
-    result = true;
-  }
-
-  parcMemory_Deallocate((void **)&remote_addr);
-
-  return result;
-}
-
-bool hicnListener_Bind(ListenerOps *ops, const Address *remoteAddress) {
-  if (addressGetType(remoteAddress) == ADDR_INET) {
-    return _hicnListener_BindInet(ops, remoteAddress);
-  } else if (addressGetType(remoteAddress) == ADDR_INET6) {
-    return _hicnListener_BindInet6(ops, remoteAddress);
-  } else {
-    printf("Bind failed: Invalid address\n");
-    return false;
-  }
-}
-
-bool hicnListener_Punting(ListenerOps *ops, const char *prefix) {
-  HicnListener *hicn = (HicnListener *)ops->context;
-  hicn_socket_helper_t *hicnSocketHelper =
-      forwarder_GetHicnSocketHelper(hicn->forwarder);
-
-  int res = hicn_listen(hicnSocketHelper, hicn->hicn_fd, prefix);
-  int retry = 0;
-
-  while (res < 0 && retry < MAX_HICN_RETRY) {
-    sleep(1);
-    res = hicn_listen(hicnSocketHelper, hicn->hicn_fd, prefix);
-    retry++;
-  }
-
-  if (res < 0) {
-    if (logger_IsLoggable(hicn->logger, LoggerFacility_IO,
-                          PARCLogLevel_Debug)) {
-      logger_Log(hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-                 "hicn_listen failed %d %s", res, hicn_socket_strerror(res));
-    }
-    return false;
-  }
-
-  return true;
-}
-
-bool hicnListener_SetConnectionId(ListenerOps *ops, unsigned connId) {
-  HicnListener *hicn = (HicnListener *)ops->context;
-  if (hicn) {
-    hicn->connection_id = connId;
-    return true;
-  }
-  return false;
-}
-
-static void _hicnListener_Destroy(HicnListener **listenerPtr) {
-  parcAssertNotNull(listenerPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*listenerPtr,
-                    "Parameter must derefernce to non-null pointer");
-
-  HicnListener *hicn = *listenerPtr;
-
-  dispatcher_DestroyNetworkEvent(forwarder_GetDispatcher(hicn->forwarder),
-                                 &hicn->hicn_event);
-  logger_Release(&hicn->logger);
-  addressDestroy(&hicn->localAddress);
-  parcMemory_Deallocate((void **)&hicn);
-  *listenerPtr = NULL;
-}
-
-static void _destroy(ListenerOps **listenerOpsPtr) {
-  ListenerOps *ops = *listenerOpsPtr;
-  HicnListener *hicn = (HicnListener *)ops->context;
-  _hicnListener_Destroy(&hicn);
-  parcMemory_Deallocate((void **)&ops);
-  *listenerOpsPtr = NULL;
-}
-
-static const char *_getListenerName(const ListenerOps *ops) {
-  HicnListener *hicn = (HicnListener *)ops->context;
-  return hicn->listenerName;
-}
-
-static const char *_getInterfaceName(const ListenerOps *ops) {
-  const char *interfaceName = "";
-  return interfaceName;
-}
-
-static unsigned _getInterfaceIndex(const ListenerOps *ops) {
-  HicnListener *hicn = (HicnListener *)ops->context;
-  return hicn->conn_id;
-}
-
-static const Address *_getListenAddress(const ListenerOps *ops) {
-  HicnListener *hicn = (HicnListener *)ops->context;
-  return hicn->localAddress;
-}
-
-static EncapType _getEncapType(const ListenerOps *ops) { return ENCAP_HICN; }
-
-static int _getSocket(const ListenerOps *ops) {
-  HicnListener *hicn = (HicnListener *)ops->context;
-  return hicn->hicn_fd;
-}
-
-// ===============================
-
-static void _readFrameToDiscard(HicnListener *hicn, int fd) {
-  // we need to discard the frame.  Read 1 byte.  This will clear it off the
-  // stack.
-  uint8_t buffer;
-  int nread = read(fd, &buffer, 1);
-
-  if (nread > 0) {
-    if (logger_IsLoggable(hicn->logger, LoggerFacility_IO,
-                          PARCLogLevel_Debug)) {
-      logger_Log(hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-                 "Discarded frame from fd %d", fd);
-    }
-  } else if (nread < 0) {
-    if (logger_IsLoggable(hicn->logger, LoggerFacility_IO,
-                          PARCLogLevel_Error)) {
-      logger_Log(hicn->logger, LoggerFacility_IO, PARCLogLevel_Error, __func__,
-                 "Error trying to discard frame from fd %d: (%d) %s", fd, errno,
-                 strerror(errno));
-    }
-  }
-}
-
-static unsigned _createNewConnection(ListenerOps * listener, int fd,
-                                     const AddressPair *pair) {
-  HicnListener * hicn = (HicnListener *)listener->context;
-  bool isLocal = false;
-
-  // udpConnection_Create takes ownership of the pair
-  IoOperations *ops = hicnConnection_Create(hicn->forwarder, listener->getInterfaceName(listener), fd, pair, isLocal);
-  Connection *conn = connection_Create(ops);
-
-  connectionTable_Add(forwarder_GetConnectionTable(hicn->forwarder), conn);
-  unsigned connid = ioOperations_GetConnectionId(ops);
-
-  return connid;
-}
-
-static const Connection * _lookupConnection(ListenerOps * listener,
-                                const AddressPair *pair) {
-  HicnListener * hicn = (HicnListener*)listener->context;
-  const Address * packetSourceAddress = addressPair_GetLocal(pair);
-
-  const Connection *conn = NULL;
-  if (hicn->connection_id != -1) {
-    conn = connectionTable_FindById(
-        forwarder_GetConnectionTable(hicn->forwarder), hicn->connection_id);
-  } else {
-    if (packetSourceAddress != NULL) {
-      // in this first check we try to retrieve the standard connection
-      // generated by the hicn-light
-      AddressPair *pair =
-          addressPair_Create(hicn->localAddress, packetSourceAddress);
-      conn = connectionTable_FindByAddressPair(
-          forwarder_GetConnectionTable(hicn->forwarder), pair);
-      addressPair_Release(&pair);
-    }
-  }
-
-  return conn;
-}
-
-static Address *_createAddressFromPacket(uint8_t *msgBuffer) {
-  Address *packetAddr = NULL;
-  if (messageHandler_GetIPPacketType(msgBuffer) == IPv6_TYPE) {
-    struct sockaddr_in6 addr_in6;
-    addr_in6.sin6_family = AF_INET6;
-    addr_in6.sin6_port = htons(1234);
-    addr_in6.sin6_flowinfo = 0;
-    addr_in6.sin6_scope_id = 0;
-    memcpy(&addr_in6.sin6_addr,
-           (struct in6_addr *)messageHandler_GetSource(msgBuffer), 16);
-    packetAddr = addressCreateFromInet6(&addr_in6);
-  } else if (messageHandler_GetIPPacketType(msgBuffer) == IPv4_TYPE) {
-    struct sockaddr_in addr_in;
-    addr_in.sin_family = AF_INET;
-    addr_in.sin_port = htons(1234);
-    memcpy(&addr_in.sin_addr,
-           (struct in_addr *)messageHandler_GetSource(msgBuffer), 4);
-    packetAddr = addressCreateFromInet(&addr_in);
-  }
-  return packetAddr;
-}
-
-static void _handleWldrNotification(ListenerOps *listener, uint8_t *msgBuffer) {
-  HicnListener * hicn = (HicnListener *)listener->context;
-
-  Address *packetAddr = _createAddressFromPacket(msgBuffer);
-
-  if (packetAddr == NULL) {
-    parcMemory_Deallocate((void **)&msgBuffer);
-    return;
-  }
-
-  AddressPair * pair = addressPair_Create(packetAddr, /* dummy */ hicn->localAddress);
-
-  const Connection *conn = _lookupConnection(listener, pair);
-
-  addressPair_Release(&pair);
-  addressDestroy(&packetAddr);
-
-  if (conn == NULL) {
-    parcMemory_Deallocate((void **)&msgBuffer);
-    return;
-  }
-
-  Message *message = message_CreateFromByteArray(
-      connection_GetConnectionId(conn), msgBuffer,
-      MessagePacketType_WldrNotification, forwarder_GetTicks(hicn->forwarder),
-      forwarder_GetLogger(hicn->forwarder));
-
-  connection_HandleWldrNotification((Connection *)conn, message);
-
-  message_Release(&message);
-}
diff --git a/hicn-light/src/hicn/io/hicnListener.h b/hicn-light/src/hicn/io/hicnListener.h
deleted file mode 100644
index faf6ad6b8..000000000
--- a/hicn-light/src/hicn/io/hicnListener.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * 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 hicnListener.h
- * @brief Listens for in coming Hicn connections
- *
- *
- */
-
-#ifndef hicnListener_h
-#define hicnListener_h
-
-#include <hicn/core/forwarder.h>
-#include <hicn/core/messageHandler.h>
-#include <hicn/io/listener.h>
-#include <stdlib.h>
-
-struct hicn_listener;
-typedef struct hicn_listener HicnListener;
-
-ListenerOps *hicnListener_CreateInet(Forwarder *forwarder, char *symbolic,
-                                     Address *address);
-ListenerOps *hicnListener_CreateInet6(Forwarder *forwarder, char *symbolic,
-                                      Address *address);
-bool hicnListener_Punting(ListenerOps *ops, const char *prefix);
-bool hicnListener_Bind(ListenerOps *ops, const Address *remoteAddress);
-bool hicnListener_SetConnectionId(ListenerOps *ops, unsigned connId);
-// const Address *hicnListener_GetTunAddress(const ListenerOps *ops);
-#endif  // hicnListener_h
diff --git a/hicn-light/src/hicn/io/hicnTunnel.c b/hicn-light/src/hicn/io/hicnTunnel.c
deleted file mode 100644
index fd5acc680..000000000
--- a/hicn-light/src/hicn/io/hicnTunnel.c
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * 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 <errno.h>
-#include <hicn/hicn-light/config.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <parc/assert/parc_Assert.h>
-#include <hicn/io/hicnConnection.h>
-#include <hicn/io/hicnListener.h>
-#include <hicn/io/hicnTunnel.h>
-
-IoOperations *hicnTunnel_CreateOnListener(Forwarder *forwarder,
-                                          ListenerOps *localListener,
-                                          const Address *remoteAddress) {
-  parcAssertNotNull(forwarder, "Parameter hicn-light must be non-null");
-  parcAssertNotNull(localListener, "Parameter localListener must be non-null");
-  parcAssertNotNull(remoteAddress, "Parameter remoteAddress must be non-null");
-
-  Logger *logger = forwarder_GetLogger(forwarder);
-
-  IoOperations *ops = NULL;
-  if (localListener->getEncapType(localListener) == ENCAP_HICN) {
-    const Address *localAddress =
-        localListener->getListenAddress(localListener);
-    address_type localType = addressGetType(localAddress);
-    address_type remoteType = addressGetType(remoteAddress);
-
-    if (localType == remoteType) {
-      bool res = hicnListener_Bind(localListener, remoteAddress);
-      if (res == false) {
-        if (logger_IsLoggable(logger, LoggerFacility_IO, PARCLogLevel_Error)) {
-          logger_Log(logger, LoggerFacility_IO, PARCLogLevel_Error, __func__,
-                     "Unable to bind local listener to remote node");
-        }
-        return ops;
-      }
-
-      // localAddress = hicnListener_GetTunAddress(localListener); //This is the
-      // true local address
-
-      AddressPair *pair = addressPair_Create(localAddress, remoteAddress);
-      bool isLocal = false;
-      int fd = localListener->getSocket(localListener);
-      ops = hicnConnection_Create(forwarder, localListener->getInterfaceName(localListener), fd, pair, isLocal);
-
-      addressPair_Release(&pair);
-    } else {
-      if (logger_IsLoggable(logger, LoggerFacility_IO, PARCLogLevel_Error)) {
-        logger_Log(logger, LoggerFacility_IO, PARCLogLevel_Error, __func__,
-                   "Local listener of type %s and remote type %s, cannot "
-                   "establish tunnel",
-                   addressTypeToString(localType),
-                   addressTypeToString(remoteType));
-      }
-    }
-  } else {
-    if (logger_IsLoggable(logger, LoggerFacility_IO, PARCLogLevel_Error)) {
-      logger_Log(logger, LoggerFacility_IO, PARCLogLevel_Error, __func__,
-                 "Local listener %p is not type UDP, cannot establish tunnel",
-                 (void *)localListener);
-    }
-  }
-
-  return ops;
-}
-
-IoOperations *hicnTunnel_Create(Forwarder *forwarder,
-                                const Address *localAddress,
-                                const Address *remoteAddress) {
-  ListenerSet *set = forwarder_GetListenerSet(forwarder);
-  ListenerOps *listener = listenerSet_Find(set, ENCAP_HICN, localAddress);
-  IoOperations *ops = NULL;
-  if (listener) {
-    ops = hicnTunnel_CreateOnListener(forwarder, listener, remoteAddress);
-  } else {
-    if (logger_IsLoggable(forwarder_GetLogger(forwarder), LoggerFacility_IO,
-                          PARCLogLevel_Error)) {
-      char *str = addressToString(localAddress);
-      logger_Log(forwarder_GetLogger(forwarder), LoggerFacility_IO,
-                 PARCLogLevel_Error, __func__,
-                 "Could not find listener to match address %s", str);
-      parcMemory_Deallocate((void **)&str);
-    }
-  }
-
-  if (ops) {
-    hicnListener_SetConnectionId(listener, ops->getConnectionId(ops));
-  }
-
-  return ops;
-}
diff --git a/hicn-light/src/hicn/io/hicnTunnel.h b/hicn-light/src/hicn/io/hicnTunnel.h
deleted file mode 100644
index 1fe0b413c..000000000
--- a/hicn-light/src/hicn/io/hicnTunnel.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * 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 hicnTunnel.h
- * @brief Establish a tunnel to a remote system
- *
- * Creates a "hicn tunnel" to a remote system.  There must already be a local
- * HICN listener for the local side of the connection.
- *
- */
-
-#ifndef hicnTunnel_h
-#define hicnTunnel_h
-
-#include <hicn/core/forwarder.h>
-#include <hicn/io/ioOperations.h>
-#include <hicn/io/listener.h>
-#include <hicn/utils/address.h>
-
-/**
- * Establishes a connection to a remote system over HICN
- *
- * The remoteAddress must be of the same type (i.e. v4 or v6) as the
- * localAddress.  There must be an existing HICN listener on the local address.
- * If either of these are not true, will return NULL.
- *
- * The connection will go in the table immediately, and will be in the "up"
- * state.
- *
- * @param [in] an allocated hicn-light Forwarder
- * @param [in] localAddress The local IP address and port to use for the
- * connection
- * @param [in] remote Address the remote IP address for the connection, must
- * include a destination port.
- *
- * @retval non-null An allocated Io Operations structure for the connection
- * @retval null An error
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-IoOperations *hicnTunnel_Create(Forwarder *forwarder,
-                                const Address *localAddress,
-                                const Address *remoteAddress);
-
-IoOperations *hicnTunnel_CreateOnListener(Forwarder *forwarder,
-                                          ListenerOps *localListener,
-                                          const Address *remoteAddress);
-
-#endif  // hicnTunnel_h
diff --git a/hicn-light/src/hicn/io/ioOperations.c b/hicn-light/src/hicn/io/ioOperations.c
deleted file mode 100644
index 0087b320a..000000000
--- a/hicn-light/src/hicn/io/ioOperations.c
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * 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 <parc/assert/parc_Assert.h>
-#include <hicn/hicn-light/config.h>
-#include <hicn/io/ioOperations.h>
-#include <stdio.h>
-
-void *ioOperations_GetClosure(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter ops must be non-null");
-  return ops->closure;
-}
-
-bool ioOperations_Send(IoOperations *ops, const Address *nexthop,
-                       Message *message) {
-  return ops->send(ops, nexthop, message);
-}
-
-bool ioOperations_SendIOVBuffer(IoOperations *ops, struct iovec *message,
-    size_t size) {
-  return ops->sendIOVBuffer(ops, message, size);
-}
-
-const Address *ioOperations_GetRemoteAddress(const IoOperations *ops) {
-  return ops->getRemoteAddress(ops);
-}
-
-const AddressPair *ioOperations_GetAddressPair(const IoOperations *ops) {
-  return ops->getAddressPair(ops);
-}
-
-
-
-bool ioOperations_IsUp(const IoOperations *ops) { return ops->isUp(ops); }
-
-bool ioOperations_IsLocal(const IoOperations *ops) { return ops->isLocal(ops); }
-
-unsigned ioOperations_GetConnectionId(const IoOperations *ops) {
-  return ops->getConnectionId(ops);
-}
-
-void ioOperations_Release(IoOperations **opsPtr) {
-  IoOperations *ops = *opsPtr;
-  ops->destroy(opsPtr);
-}
-
-const void *ioOperations_Class(const IoOperations *ops) {
-  return ops->class(ops);
-}
-
-list_connections_type ioOperations_GetConnectionType(const IoOperations *ops) {
-  return ops->getConnectionType(ops);
-}
-
-void ioOperations_SendProbe(IoOperations *ops, uint8_t *message) {
-  ops->sendProbe(ops, message);
-}
-
-
-connection_state_t ioOperations_GetState(const IoOperations *ops) {
-  return ops->getState(ops);
-}
-
-void ioOperations_SetState(IoOperations *ops, connection_state_t state) {
-  ops->setState(ops, state);
-}
-
-connection_state_t ioOperations_GetAdminState(const IoOperations *ops) {
-  return ops->getAdminState(ops);
-}
-
-void ioOperations_SetAdminState(IoOperations *ops, connection_state_t admin_state) {
-  ops->setAdminState(ops, admin_state);
-}
-
-#ifdef WITH_POLICY
-uint32_t ioOperations_GetPriority(const IoOperations *ops) {
-  return ops->getPriority(ops);
-}
-
-void ioOperations_SetPriority(IoOperations *ops, uint32_t priority) {
-  ops->setPriority(ops, priority);
-}
-#endif /* WITH_POLICY */
-
-const char * ioOperations_GetInterfaceName(const IoOperations *ops) {
-    return ops->getInterfaceName(ops);
-}
diff --git a/hicn-light/src/hicn/io/ioOperations.h b/hicn-light/src/hicn/io/ioOperations.h
deleted file mode 100644
index 5d9befac3..000000000
--- a/hicn-light/src/hicn/io/ioOperations.h
+++ /dev/null
@@ -1,449 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * Defines the interface all connections use to communicate with the forwarder.
- */
-
-/**
- * I/O is built around a callback structure.  The connection table contains an
- * operations structure built around function pointers.  These allow the
- * connection table to be agnostic about underlying connections.
- */
-
-#ifndef io_h
-#define io_h
-
-#include <hicn/core/connectionState.h>
-#include <hicn/core/message.h>
-#include <hicn/core/ticks.h>
-#include <hicn/io/addressPair.h>
-#include <hicn/utils/address.h>
-
-// packet types for probing
-#define PACKET_TYPE_PROBE_REQUEST 5
-#define PACKET_TYPE_PROBE_REPLY 6
-
-struct io_ops;
-typedef struct io_ops IoOperations;
-
-/**
- * @typedef IoOperations
- * @abstract The IO Operations structure abstracts an connection's properties
- * and send() method
- * @constant context Implementation specific opaque data, passed back on each
- * call
- * @constant send function pointer to send a message, does not destroy the
- * message
- * @constant getRemoteAddress function pointer to return the "to" address
- * associated with the connection. Some connections might not have a specific
- * peer, such as multicast, where its the group address.
- * @constant isUp test if the connection is up, ready to send a message.
- * @constant isLocal test if the connection is local to the host.
- * @constant getConnectionId returns the hicn-light id for the connection.
- * @constant destroy releases a refernce count on the connection and possibly
- * destroys the connection.
- * @constant class A unique identifier for each class that instantiates
- * IoOperations.
- * @constant getConnectionType Returns the type of connection (TCP, UDP, L2,
- * etc.) of the underlying connection.
- * @constant getState Returns the current state of the connection (redundant
- * with isUp for added for completeness of the API).
- * @constant setState Allows to mark the current state of a connection.
- * @constant getAdminState Returns the administrative state of a connection (as
- * requested by the user, which might occasionally differ from the current
- * state).
- * @constant setAdminState Allows to set the administrative state of a
- * connection.
- * @constant getInterfaceName Returns the interface name associated to a
- * connection.
- * @discussion <#Discussion#>
- */
-struct io_ops {
-  void *closure;
-  bool (*send)(IoOperations *ops, const Address *nexthop, Message *message);
-  bool (*sendIOVBuffer)(IoOperations *ops, struct iovec *message, size_t
-      size);
-  const Address *(*getRemoteAddress)(const IoOperations *ops);
-  const AddressPair *(*getAddressPair)(const IoOperations *ops);
-  bool (*isUp)(const IoOperations *ops);
-  bool (*isLocal)(const IoOperations *ops);
-  unsigned (*getConnectionId)(const IoOperations *ops);
-  void (*destroy)(IoOperations **opsPtr);
-  const void *(*class)(const IoOperations *ops);
-  list_connections_type (*getConnectionType)(const IoOperations *ops);
-  void (*sendProbe)(IoOperations *ops, uint8_t *message);
-  connection_state_t (*getState)(const IoOperations *ops);
-  void (*setState)(IoOperations *ops, connection_state_t state);
-  connection_state_t (*getAdminState)(const IoOperations *ops);
-  void (*setAdminState)(IoOperations *ops, connection_state_t admin_state);
-#ifdef WITH_POLICY
-  uint32_t (*getPriority)(const IoOperations *ops);
-  void (*setPriority)(IoOperations *ops, uint32_t priority);
-#endif /* WITH_POLICY */
-  const char * (*getInterfaceName)(const IoOperations *ops);
-};
-
-/**
- * Returns the closure of the interface
- *
- * The creator of the closure sets this parameter to store its state.
- *
- * @param [in] ops A concrete instance of the interface
- *
- * @return The value set by the concrete instance of the interface.
- *
- * Example:
- * @clode
- * {
-
- * }
- * @endcode
- */
-void *ioOperations_GetClosure(const IoOperations *ops);
-
-/**
- * Release all memory related to the interface and implementation
- *
- * This function must release all referenced memory in the concrete
- * implementation and memory related to the IoOperations.  It should NULL the
- * input parameter.
- *
- * @param [in,out] opsPtr Pointer to interface.  Will be NULLed.
- *
- * Example:
- * @code
- *
- *   static void
- *   _etherConnection_InternalRelease(_EtherState *etherConnState)
- *   {
- *      // release internal state of _EtherState
- *   }
- *
- *   static void
- *   _etherConnection_Release(IoOperations **opsPtr)
- *   {
- *      IoOperations *ops = *opsPtr;
- *
- *      _EtherState *etherConnState = (_EtherState *)
- * ioOperations_GetClosure(ops);
- *      _etherConnection_InternalRelease(etherConnState);
- *
- *      parcMemory_Deallocate((void **) &ops);
- *   }
- *
- *   IoOperations *
- *   etherConnection_Create(Forwarder *forwarder, GenericEther *ether,
- * AddressPair *pair)
- *   {
- *      size_t allocationSize = sizeof(_EtherState) + sizeof(IoOperations);
- *      IoOperations *ops = parcMemory_AllocateAndClear(allocationSize);
- *      if (ops) {
- *         // fill in other interface functions
- *         ops->destroy = &_etherConnection_Release;
- *         ops->closure = (uint8_t *) ops + sizeof(IoOperations);
- *
- *         _EtherState *etherConnState = ioOperations_GetClosure(ops);
- *         // fill in Ethernet state
- *      }
- *      return ops;
- *   }
- * @endcode
- */
-void ioOperations_Release(IoOperations **opsPtr);
-
-/**
- * Sends the specified Message out this connection
- *
- * The the implementation of send may queue the message, it must acquire a
- * reference to it.
- *
- * @param [in] ops The connection implementation.
- * @param [in] nexthop On multiple access networks, this parameter might be
- * used, usually NULL.
- * @param [in] message The message to send.  If the message will be queued, it
- * will be acquired.
- *
- * @return true The message was sent or queued
- * @retrun false An error occured and the message will not be sent or queued
- *
- * Example:
- * @code
- * {
- *     if (ioOperations_IsUp(conn->ops)) {
- *        return ioOperations_Send(conn->ops, NULL, message);
- *     }
- * }
- * @endcode
- */
-bool ioOperations_Send(IoOperations *ops, const Address *nexthop,
-    Message *message);
-
-bool ioOperations_SendIOVBuffer(IoOperations *ops, struct iovec *message,
-    size_t size);
-
-/**
- * A connection is made up of a local and a remote address.  This function
- * returns the remote address.
- *
- * Represents the destination endpoint of the communication.
- *
- * @param [in] ops The connection implementation.
- *
- * @return non-null The remote address
- * @return null The connection does not have a remote address
- *
- * Example:
- * @code
- * {
- *    Address *local =  addressCreateFromLink((uint8_t []) { 0x01, 0x02, 0x03,
- * 0x04, 0x05, 0x06 }, 6); Address *remote = addressCreateFromLink((uint8_t [])
- * { 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }, 6); AddressPair *pair =
- * addressPair_Create(local, remote); IoOperations *ops =
- * etherConnection_Create(forwarder, ether, pair);
- *
- *    const Address *test = ioOperations_GetRemoteAddress(ops);
- *    parcAssertTrue(addressEquals(test, remote), "Wrong remote address");
- *    ioOperations_Release(&ops);
- *    addressPair_Release(&pair);
- *    addressDestroy(&local);
- *    addressDestroy(&remote);
- * }
- * @endcode
- */
-const Address *ioOperations_GetRemoteAddress(const IoOperations *ops);
-
-/**
- * A connection is made up of a local and a remote address.  This function
- * returns the address pair.
- *
- * Represents the destination endpoint of the communication.
- *
- * @param [in] ops The connection implementation.
- *
- * @return non-null The address pair
- * @return null An error.
- *
- * Example:
- * @code
- * {
- *    Address *local =  addressCreateFromLink((uint8_t []) { 0x01, 0x02, 0x03,
- * 0x04, 0x05, 0x06 }, 6); Address *remote = addressCreateFromLink((uint8_t [])
- * { 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }, 6); AddressPair *pair =
- * addressPair_Create(local, remote); IoOperations *ops =
- * etherConnection_Create(forwarder, ether, pair);
- *
- *    const AddressPair *test = ioOperations_GetAddressPair(ops);
- *    parcAssertTrue(addressPair(test, pair), "Wrong address pair");
- *    ioOperations_Release(&ops);
- *    addressPair_Release(&pair);
- *    addressDestroy(&local);
- *    addressDestroy(&remote);
- * }
- * @endcode
- */
-const AddressPair *ioOperations_GetAddressPair(const IoOperations *ops);
-
-/**
- * Returns true if the underlying connection is in operation
- *
- * An UP connection is able to send and receive packets. If a subsystem needs to
- * take actions when a connection goes UP or DOWN, it should subscribe as a
- * Missive listener.
- *
- * @param [in] ops The connection implementation.
- *
- * @return true The connection is UP
- * @return false The connection is not UP
- *
- * Example:
- * @code
- * {
- *     if (ioOperations_IsUp(conn->ops)) {
- *        return ioOperations_Send(conn->ops, NULL, message);
- *     }
- * }
- * @endcode
- */
-bool ioOperations_IsUp(const IoOperations *ops);
-
-/**
- * If the remote address is local to this system, returns true
- *
- * Will return true if an INET or INET6 connection is on localhost.  Will return
- * true for AF_UNIX.  An Ethernet connection is not local.
- *
- * @param [in] ops The connection implementation.
- *
- * @return true The remote address is local to the system
- * @return false The remote address is not local
- *
- * Example:
- * @code
- * {
- *     // Is the ingress connection remote?  If so check for non-zero and
- * decrement if (!ioOperations(ingressConnectionOps) { uint8_t hoplimit =
- * message_GetHopLimit(interestMessage); if (hoplimit == 0) {
- *           // error
- *        } else {
- *           hoplimit--;
- *        }
- *        // take actions on hoplimit
- *     }
- * }
- * @endcode
- */
-bool ioOperations_IsLocal(const IoOperations *ops);
-
-/**
- * Returns the connection ID represented by this IoOperations in the
- * ConnectionTable.
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [in] ops The connection implementation.
- *
- * @return number The connection ID in the connection table.
- *
- * Example:
- * @code
- * {
- *     unsigned id = ioOperations_GetConnectionId(ingressIoOps);
- *     const Connection *conn =
- * connectionTable_FindById(forwarder->connectionTable, id);
- * }
- * @endcode
- */
-unsigned ioOperations_GetConnectionId(const IoOperations *ops);
-
-/**
- * A pointer that represents the class of the connection
- *
- * Each concrete implementation has a class pointer that is unique to the
- * implementation (not instance). Each implementation is free to choose how to
- * determine the value, so long as it is unique on the system. This is a
- * system-local value.
- *
- * @param [in] ops The connection implementation.
- *
- * @return non-null A pointer value unique to the implementation (not instance).
- *
- * Example:
- * @code
- *   bool
- *   etherConnection_IsInstanceOf(const Connection *conn)
- *   {
- *      bool result = false;
- *      if (conn != NULL) {
- *         IoOperations *ops = connection_GetIoOperations(conn);
- *         const void *class = ioOperations_Class(ops);
- *         result = (class == _etherConnection_Class(ops));
- *      }
- *      return result;
- *   }
- * @endcode
- */
-const void *ioOperations_Class(const IoOperations *ops);
-
-/**
- * Returns the transport type of the connection (TCP, UDP, L2, etc.).
- *
- * TCP and AF_UNIX are both stream connections and will both return
- * "Connection_TCP". Ethernet will return "Connection_L2".
- *
- * @param [in] ops The connection implementation.
- *
- * @return Connection_TCP A TCP4, TCP6, or AF_UNIX connection
- * @return Connection_UDP A UDP4 or UDP6 connection
- * @return Connection_L2 An Ethernet connection
- *
- * Example:
- * @code
- * {
- *     ConnectionType type =
- * ioOperations_GetConnectionType(connection_GetIoOperations(connection));
- *     Connection *Conn =
- * Connection_Create(connection_GetConnectionId(connection), localAddress,
- * remoteAddress, type);
- * }
- * @endcode
- */
-list_connections_type ioOperations_GetConnectionType(const IoOperations *ops);
-
-void ioOperations_SendProbe(IoOperations *ops, uint8_t *message);
-
-
-/**
- * Returns the current state of the connection
- *
- * @param [in] ops The connection implementation.
- *
- * @return Connection state (connection_state_t).
- */
-connection_state_t ioOperations_GetState(const IoOperations *ops);
-
-/**
- * Sets the current state of the connection
- *
- * @param [in] ops The connection implementation.
- * @param [in] state New state to set (connection_state_t).
- */
-void ioOperations_SetState(IoOperations *ops, connection_state_t state);
-
-/**
- * Returns the administrative state of the connection
- *
- * @param [in] ops The connection implementation.
- *
- * @return Connection state (connection_state_t).
- */
-connection_state_t ioOperations_GetAdminState(const IoOperations *ops);
-
-/**
- * Sets the administrative state of the connection
- *
- * @param [in] ops The connection implementation.
- * @param [in] state New state to set (connection_state_t).
- */
-void ioOperations_SetAdminState(IoOperations *ops, connection_state_t admin_state);
-
-#ifdef WITH_POLICY
-/**
- * Returns the priority of the connection
- *
- * @param [in] ops The connection implementation.
- *
- * @return Connection state (uint32_t).
- */
-uint32_t ioOperations_GetPriority(const IoOperations *ops);
-
-/**
- * Sets the priority of the connection
- *
- * @param [in] ops The connection implementation.
- * @param [in] state New state to set (uint32_t).
- */
-void ioOperations_SetPriority(IoOperations *ops, uint32_t priority);
-#endif /* WITH_POLICY */
-
-/**
- * Sets the interface name associated to the connection.
- *
- * @param [in] ops The connection implementation.
- * @return the name associated to the connection (const char *)
- */
-const char * ioOperations_GetInterfaceName(const IoOperations *ops);
-
-#endif  // io_h
diff --git a/hicn-light/src/hicn/io/listener.h b/hicn-light/src/hicn/io/listener.h
deleted file mode 100644
index 1b473be59..000000000
--- a/hicn-light/src/hicn/io/listener.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * 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 listener.h
- * @brief Provides the function abstraction of all Listeners.
- *
- * A listener accepts in coming packets.  A Stream listener will accept the
- * connection then pass it off to the {@link StreamConnection} class.  A
- * datagram listener will have to have its own way to multiplex packets.
- *
- */
-
-#ifndef listener_h
-#define listener_h
-
-#include <hicn/utils/address.h>
-#include <hicn/io/addressPair.h>
-#include <hicn/core/connection.h>
-
-struct listener_ops;
-typedef struct listener_ops ListenerOps;
-
-typedef enum {
-  ENCAP_TCP,   /**< TCP encapsulation type */
-  ENCAP_UDP,   /**< UDP encapsulation type */
-  ENCAP_ETHER, /**< Ethernet encapsulation type */
-  ENCAP_LOCAL, /**< A connection to a local protocol stack */
-  ENCAP_HICN
-} EncapType;
-
-struct listener_ops {
-  /**
-   * A user-defined parameter
-   */
-  void *context;
-
-  /**
-   * Called to destroy the Listener.
-   *
-   * @param [in] listenerOpsPtr Double pointer to this structure
-   */
-  void (*destroy)(ListenerOps **listenerOpsPtr);
-
-  /**
-   * Returns the listener name of the listener.
-   *
-   * @param [in] ops Pointer to this structure
-   *
-   * @return the listener name of the listener
-   */
-  const char *(*getListenerName)(const ListenerOps *ops);
-
-  /**
-   * Returns the interface index of the listener.
-   *
-   * @param [in] ops Pointer to this structure
-   *
-   * @return the interface index of the listener
-   */
-  unsigned (*getInterfaceIndex)(const ListenerOps *ops);
-
-  /**
-   * Returns the address pair that defines the listener (local, remote)
-   *
-   * @param [in] ops Pointer to this structure
-   *
-   * @return the (local, remote) pair of addresses
-   */
-  const Address *(*getListenAddress)(const ListenerOps *ops);
-
-  /**
-   * Returns the encapsulation type of the listener (e.g. TCP, UDP, HICN)
-   *
-   * @param [in] ops Pointer to this structure
-   *
-   * @return the listener encapsulation type
-   */
-  EncapType (*getEncapType)(const ListenerOps *ops);
-
-  /**
-   * Returns the interface name of the listener.
-   *
-   * @param [in] ops Pointer to this structure
-   *
-   * @return the interface name of the listener
-   */
-  const char *(*getInterfaceName)(const ListenerOps *ops);
-
-  /**
-   * Returns the underlying socket associated with the listener
-   *
-   * Not all listeners are capable of returning a useful socket.  In those
-   * cases, this function pointer is NULL.
-   *
-   * TCP does not support this operation (function is NULL).  UDP returns its
-   * local socket.
-   *
-   * The caller should never close this socket, the listener will do that when
-   * its destroy method is called.
-   *
-   * @param [in] ops Pointer to this structure
-   *
-   * @retval integer The socket descriptor
-   *
-   * Example:
-   * @code
-   * <#example#>
-   * @endcode
-   */
-  int (*getSocket)(const ListenerOps *ops);
-
-  unsigned (*createConnection)(ListenerOps *listener, int fd, const AddressPair *pair);
-  const Connection * (*lookupConnection)(ListenerOps * listener, const AddressPair *pair);
-};
-#endif  // listener_h
diff --git a/hicn-light/src/hicn/io/listenerSet.c b/hicn-light/src/hicn/io/listenerSet.c
deleted file mode 100644
index d69632287..000000000
--- a/hicn-light/src/hicn/io/listenerSet.c
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_ArrayList.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/io/listenerSet.h>
-
-struct listener_set {
-  PARCArrayList *listOfListeners;
-};
-
-static void listenerSet_DestroyListenerOps(void **opsPtr) {
-  ListenerOps *ops = *((ListenerOps **)opsPtr);
-  ops->destroy(&ops);
-}
-
-ListenerSet *listenerSet_Create() {
-  ListenerSet *set = parcMemory_AllocateAndClear(sizeof(ListenerSet));
-  parcAssertNotNull(set, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(ListenerSet));
-  set->listOfListeners = parcArrayList_Create(listenerSet_DestroyListenerOps);
-
-  return set;
-}
-
-void listenerSet_Destroy(ListenerSet **setPtr) {
-  parcAssertNotNull(setPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*setPtr, "Parameter must dereference to non-null pointer");
-
-  ListenerSet *set = *setPtr;
-  parcArrayList_Destroy(&set->listOfListeners);
-  parcMemory_Deallocate((void **)&set);
-  *setPtr = NULL;
-}
-
-/**
- * @function listenerSet_Add
- * @abstract Adds the listener to the set
- * @discussion
- *     Unique set based on pair (EncapType, localAddress)
- *
- * @param <#param1#>
- * @return <#return#>
- */
-bool listenerSet_Add(ListenerSet *set, ListenerOps *ops) {
-  parcAssertNotNull(set, "Parameter set must be non-null");
-  parcAssertNotNull(ops, "Parameter ops must be non-null");
-
-  int opsEncap = ops->getEncapType(ops);
-  const Address *opsAddress = ops->getListenAddress(ops);
-
-  // make sure its not in the set
-  size_t length = parcArrayList_Size(set->listOfListeners);
-  for (size_t i = 0; i < length; i++) {
-    ListenerOps *entry = parcArrayList_Get(set->listOfListeners, i);
-
-    int entryEncap = entry->getEncapType(entry);
-    const Address *entryAddress = entry->getListenAddress(entry);
-
-    if (opsEncap == entryEncap && addressEquals(opsAddress, entryAddress)) {
-      // duplicate
-      return false;
-    }
-  }
-
-  parcArrayList_Add(set->listOfListeners, ops);
-  return true;
-}
-
-size_t listenerSet_Length(const ListenerSet *set) {
-  parcAssertNotNull(set, "Parameter set must be non-null");
-  return parcArrayList_Size(set->listOfListeners);
-}
-
-/**
- * Returns the listener at the given index
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [in] set An allocated listener set
- * @param [in] index The index position (0 <= index < listenerSet_Count)
- *
- * @retval non-null The listener at index
- * @retval null An error
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-ListenerOps *listenerSet_Get(const ListenerSet *set, size_t index) {
-  parcAssertNotNull(set, "Parameter set must be non-null");
-  return parcArrayList_Get(set->listOfListeners, index);
-}
-
-ListenerOps *listenerSet_Find(const ListenerSet *set, EncapType encapType,
-                              const Address *localAddress) {
-  parcAssertNotNull(set, "Parameter set must be non-null");
-  parcAssertNotNull(localAddress, "Parameter localAddress must be non-null");
-
-  ListenerOps *match = NULL;
-
-  for (size_t i = 0; i < parcArrayList_Size(set->listOfListeners) && !match;
-       i++) {
-    ListenerOps *ops = parcArrayList_Get(set->listOfListeners, i);
-    parcAssertNotNull(ops, "Got null listener ops at index %zu", i);
-
-    if (ops->getEncapType(ops) == encapType) {
-      if (addressEquals(localAddress, ops->getListenAddress(ops))) {
-        match = ops;
-      }
-    }
-  }
-
-  return match;
-}
-
-ListenerOps *listenerSet_FindById(const ListenerSet *set, unsigned id) {
-  parcAssertNotNull(set, "Parameter set must be non-null");
-
-  ListenerOps *match = NULL;
-
-  for (size_t i = 0; i < parcArrayList_Size(set->listOfListeners) && !match;
-       i++) {
-    ListenerOps *ops = parcArrayList_Get(set->listOfListeners, i);
-    parcAssertNotNull(ops, "Got null listener ops at index %zu", i);
-    if (ops->getInterfaceIndex(ops) == id) {
-        match = ops;
-    }
-  }
-
-  return match;
-}
-
-int listenerSet_FindIdByListenerName(const ListenerSet *set, const char *listenerName ) {
-  parcAssertNotNull(set, "Parameter set must be non-null");
-  parcAssertNotNull(listenerName, "Parameter listenerName must be non-null");
-
-  ListenerOps *match = NULL;
-  int index = -1;
-  for (size_t i = 0; i < parcArrayList_Size(set->listOfListeners) && !match;
-       i++) {
-    ListenerOps *ops = parcArrayList_Get(set->listOfListeners, i);
-    parcAssertNotNull(ops, "Got null listener ops at index %zu", i);
-    if (ops->getListenerName(ops) && strcmp(ops->getListenerName(ops), listenerName) == 0) {
-        index = ops->getInterfaceIndex(ops);
-        break;
-    }
-  }
-
-  return index;
-}
-
-void listenerSet_RemoveById(const ListenerSet *set, unsigned id) {
-  parcAssertNotNull(set, "Parameter set must be non-null");
-
-  for (size_t i = 0; i < parcArrayList_Size(set->listOfListeners);
-       i++) {
-    ListenerOps *ops = parcArrayList_Get(set->listOfListeners, i);
-    parcAssertNotNull(ops, "Got null listener ops at index %zu", i);
-    if (ops->getInterfaceIndex(ops) == id) {
-       parcArrayList_RemoveAndDestroyAtIndex(set->listOfListeners, i);
-       break;
-    }
-  }
-}
diff --git a/hicn-light/src/hicn/io/listenerSet.h b/hicn-light/src/hicn/io/listenerSet.h
deleted file mode 100644
index 5779d2af4..000000000
--- a/hicn-light/src/hicn/io/listenerSet.h
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * 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 listenerSet.h
- * @brief A listener set is unique on (EncapType, localAddress)
- *
- * Keeps track of all the running listeners.  The set is unique on the
- * encapsulation type and the local address.  For example, with TCP
- * encapsulation and local address 127.0.0.1 or Ethernet encapsulation and MAC
- * address 00:11:22:33:44:55.
- *
- * NOTE: This does not allow multiple EtherType on the same interface because
- * the Address for a LINK address does not include an EtherType.
- *
- */
-
-#ifndef listenerSet_h
-#define listenerSet_h
-
-#include <hicn/io/listener.h>
-
-struct listener_set;
-typedef struct listener_set ListenerSet;
-
-/**
- * <#One Line Description#>
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in out in,out#>] <#name#> <#description#>
- *
- * @retval <#value#> <#explanation#>
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-ListenerSet *listenerSet_Create(void);
-
-/**
- * <#One Line Description#>
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [<#in out in,out#>] <#name#> <#description#>
- *
- * @retval <#value#> <#explanation#>
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-void listenerSet_Destroy(ListenerSet **setPtr);
-
-/**
- * @function listenerSet_Add
- * @abstract Adds the listener to the set
- * @discussion
- *     Unique set based on pair (EncapType, localAddress).
- *     Takes ownership of the ops memory if added.
- *
- * @param <#param1#>
- * @return true if added, false if not
- */
-bool listenerSet_Add(ListenerSet *set, ListenerOps *ops);
-
-/**
- * The number of listeners in the set
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [in] set An allocated listener set
- *
- * @retval <#value#> <#explanation#>
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-size_t listenerSet_Length(const ListenerSet *set);
-size_t listenerSet_Length(const ListenerSet *set);
-
-/**
- * Returns the listener at the given index
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [in] set An allocated listener set
- * @param [in] index The index position (0 <= index < listenerSet_Lenght)
- *
- * @retval non-null The listener at index
- * @retval null An error
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-ListenerOps *listenerSet_Get(const ListenerSet *set, size_t index);
-
-/**
- * Looks up a listener by its key (EncapType, LocalAddress)
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [in] set An allocated listener set
- * @param [in] encapType the listener type
- * @param [in] localAddress The local bind address (e.g. MAC address or TCP
- * socket)
- *
- * @retval non-null The listener matching the query
- * @retval null Does not exist
- *
- * Example:
- * @code
- *
- * @endcode
- */
-ListenerOps *listenerSet_Find(const ListenerSet *set, EncapType encapType,
-                              const Address *localAddress);
-
-/**
- * Looks up a listener by its id
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [in] set An allocated listener set
- * @param [in] id of the listener
- *
- * @retval non-null The listener matching the query
- * @retval null Does not exist
- *
- * Example:
- * @code
- *
- * @endcode
- */
-ListenerOps *listenerSet_FindById(const ListenerSet *set, unsigned id);
-
-/**
- * Looks up a listener by its id
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [in] set An allocated listener set
- * @param [in] name of the listener
- *
- * @retval greater or equal to 0 The listener matching the query
- * @retval -1 Does not exist
- *
- * Example:
- * @code
- *
- * @endcode
- */
-int listenerSet_FindIdByListenerName(const ListenerSet *set, const char *listenerName);
-
-/**
- * Remove up a listener by its id
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [in] set An allocated listener set
- * @param [in] id of the listener
- *
- * Example:
- * @code
- *
- * @endcode
- */
-void listenerSet_RemoveById(const ListenerSet *set, unsigned id);
-#endif
diff --git a/hicn-light/src/hicn/io/streamConnection.c b/hicn-light/src/hicn/io/streamConnection.c
deleted file mode 100644
index 53ffa74c3..000000000
--- a/hicn-light/src/hicn/io/streamConnection.c
+++ /dev/null
@@ -1,773 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * Common activity for STREAM based listeners.
- */
-
-#include <errno.h>
-#include <hicn/hicn-light/config.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <parc/algol/parc_Hash.h>
-#include <hicn/core/connection.h>
-#include <hicn/core/forwarder.h>
-#include <hicn/core/message.h>
-#include <hicn/io/streamConnection.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/core/messageHandler.h>
-
-#include <hicn/utils/commands.h>
-
-#include <hicn/hicn.h>
-// 128 KB output queue
-#define OUTPUT_QUEUE_BYTES (128 * 1024)
-
-static void _conn_readcb(PARCEventQueue *bufferEventVector, PARCEventType type,
-                         void *ioOpsVoid);
-
-static void _conn_eventcb(PARCEventQueue *bufferEventVector,
-                          PARCEventQueueEventType events, void *ioOpsVoid);
-
-typedef struct stream_state {
-  Forwarder *forwarder;
-  char * interfaceName;
-  Logger *logger;
-
-  int fd;
-
-  AddressPair *addressPair;
-  PARCEventQueue *bufferEventVector;
-
-  bool isLocal;
-  bool isUp;
-  bool isClosed;
-  unsigned id;
-
-  size_t nextMessageLength;
-
-  /* This information would better be stored in the connection data structure
-   * but it is currently not reachable from within the implementation. */
-  connection_state_t state;
-  connection_state_t admin_state;
-#ifdef WITH_POLICY
-  uint32_t priority;
-#endif /* WITH_POLICY */
-} _StreamState;
-
-// Prototypes
-static bool _streamConnection_Send(IoOperations *ops, const Address *nexthop,
-    Message *message);
-static bool _streamConnection_SendIOVBuffer(IoOperations *ops, struct
-    iovec *msg, size_t size);
-static const Address *_streamConnection_GetRemoteAddress(
-    const IoOperations *ops);
-static const AddressPair *_streamConnection_GetAddressPair(
-    const IoOperations *ops);
-static unsigned _streamConnection_GetConnectionId(const IoOperations *ops);
-static bool _streamConnection_IsUp(const IoOperations *ops);
-static bool _streamConnection_IsLocal(const IoOperations *ops);
-static void _streamConnection_DestroyOperations(IoOperations **opsPtr);
-
-static void _setConnectionState(_StreamState *stream, bool isUp);
-static list_connections_type _streamConnection_GetConnectionType(
-    const IoOperations *ops);
-static void _sendProbe(IoOperations *ops, uint8_t *message);
-static connection_state_t _streamConnection_getState(const IoOperations *ops);
-static void _streamConnection_setState(IoOperations *ops, connection_state_t state);
-static connection_state_t _streamConnection_getAdminState(const IoOperations *ops);
-static void _streamConnection_setAdminState(IoOperations *ops, connection_state_t admin_state);
-#ifdef WITH_POLICY
-static uint32_t _streamConnection_getPriority(const IoOperations *ops);
-static void _streamConnection_setPriority(IoOperations *ops, uint32_t priority);
-#endif /* WITH_POLICY */
-static const char * _streamConnection_getInterfaceName(const IoOperations *ops);
-
-/*
- * This assigns a unique pointer to the void * which we use
- * as a GUID for this class.
- */
-static const void *_ioOperationsGuid = __FILE__;
-
-/*
- * Return our GUID
- */
-static const void *_streamConnection_Class(const IoOperations *ops) {
-  return _ioOperationsGuid;
-}
-
-static IoOperations _template = {
-    .closure = NULL,
-    .send = &_streamConnection_Send,
-    .sendIOVBuffer = &_streamConnection_SendIOVBuffer,
-    .getRemoteAddress = &_streamConnection_GetRemoteAddress,
-    .getAddressPair = &_streamConnection_GetAddressPair,
-    .getConnectionId = &_streamConnection_GetConnectionId,
-    .isUp = &_streamConnection_IsUp,
-    .isLocal = &_streamConnection_IsLocal,
-    .destroy = &_streamConnection_DestroyOperations,
-    .class = &_streamConnection_Class,
-    .getConnectionType = &_streamConnection_GetConnectionType,
-    .sendProbe = &_sendProbe,
-    .getState = &_streamConnection_getState,
-    .setState = &_streamConnection_setState,
-    .getAdminState = &_streamConnection_getAdminState,
-    .setAdminState = &_streamConnection_setAdminState,
-#ifdef WITH_POLICY
-    .getPriority = &_streamConnection_getPriority,
-    .setPriority = &_streamConnection_setPriority,
-#endif /* WITH_POLICY */
-    .getInterfaceName = &_streamConnection_getInterfaceName,
-};
-
-IoOperations *streamConnection_AcceptConnection(Forwarder *forwarder, int fd,
-                                                AddressPair *pair,
-                                                bool isLocal) {
-  _StreamState *stream = parcMemory_AllocateAndClear(sizeof(_StreamState));
-  parcAssertNotNull(stream, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(_StreamState));
-
-  Dispatcher *dispatcher = forwarder_GetDispatcher(forwarder);
-  PARCEventScheduler *eventBase = dispatcher_GetEventScheduler(dispatcher);
-  stream->bufferEventVector = parcEventQueue_Create(
-      eventBase, fd,
-      PARCEventQueueOption_CloseOnFree | PARCEventQueueOption_DeferCallbacks);
-
-  stream->forwarder = forwarder;
-  stream->interfaceName = NULL;
-  stream->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-  stream->fd = fd;
-  stream->id = forwarder_GetNextConnectionId(forwarder);
-  stream->addressPair = pair;
-  stream->isClosed = false;
-
-#ifdef WITH_POLICY
-  stream->priority = 0;
-#endif /* WITH_POLICY */
-
-  // allocate a connection
-  IoOperations *io_ops = parcMemory_AllocateAndClear(sizeof(IoOperations));
-  parcAssertNotNull(io_ops, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(IoOperations));
-  memcpy(io_ops, &_template, sizeof(IoOperations));
-  io_ops->closure = stream;
-  stream->isLocal = isLocal;
-
-  parcEventQueue_SetCallbacks(stream->bufferEventVector, _conn_readcb, NULL,
-                              _conn_eventcb, (void *)io_ops);
-  parcEventQueue_Enable(stream->bufferEventVector, PARCEventType_Read);
-
-  messenger_Send(forwarder_GetMessenger(stream->forwarder),
-                 missive_Create(MissiveType_ConnectionCreate, stream->id));
-
-  // As we are acceting a connection, we begin in the UP state
-  _setConnectionState(stream, true);
-
-  if (logger_IsLoggable(stream->logger, LoggerFacility_IO,
-                        PARCLogLevel_Debug)) {
-    char *pair_str = addressPair_ToString(pair);
-    logger_Log(stream->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-               "StreamConnection %p accept for address pair %s", (void *)stream,
-               pair_str);
-    free(pair_str);
-  }
-
-  return io_ops;
-}
-
-IoOperations *streamConnection_OpenConnection(Forwarder *forwarder,
-                                              AddressPair *pair, bool isLocal) {
-  parcAssertNotNull(forwarder, "Parameter hicn-light must be non-null");
-  parcAssertNotNull(pair, "Parameter pair must be non-null");
-
-  // if there's an error on the bind or connect, will return NULL
-  PARCEventQueue *bufferEventVector =
-      dispatcher_StreamBufferConnect(forwarder_GetDispatcher(forwarder), pair);
-  if (bufferEventVector == NULL) {
-    // error opening connection
-    return NULL;
-  }
-
-  _StreamState *stream = parcMemory_AllocateAndClear(sizeof(_StreamState));
-  parcAssertNotNull(stream, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(_StreamState));
-
-  stream->forwarder = forwarder;
-  stream->interfaceName = NULL;
-  stream->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-  stream->fd = parcEventQueue_GetFileDescriptor(bufferEventVector);
-  stream->bufferEventVector = bufferEventVector;
-  stream->id = forwarder_GetNextConnectionId(forwarder);
-  stream->addressPair = pair;
-  stream->isClosed = false;
-
-  // allocate a connection
-  IoOperations *io_ops = parcMemory_AllocateAndClear(sizeof(IoOperations));
-  parcAssertNotNull(io_ops, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(IoOperations));
-  memcpy(io_ops, &_template, sizeof(IoOperations));
-  io_ops->closure = stream;
-  stream->isLocal = isLocal;
-
-  parcEventQueue_SetCallbacks(stream->bufferEventVector, _conn_readcb, NULL,
-                              _conn_eventcb, (void *)io_ops);
-  parcEventQueue_Enable(stream->bufferEventVector, PARCEventType_Read);
-
-  // we start in DOWN state, until remote side answers
-  messenger_Send(forwarder_GetMessenger(stream->forwarder),
-                 missive_Create(MissiveType_ConnectionCreate, stream->id));
-  _setConnectionState(stream, false);
-
-  if (logger_IsLoggable(stream->logger, LoggerFacility_IO, PARCLogLevel_Info)) {
-    char *pair_str = addressPair_ToString(pair);
-    logger_Log(stream->logger, LoggerFacility_IO, PARCLogLevel_Info, __func__,
-               "StreamConnection %p connect for address pair %s",
-               (void *)stream, pair_str);
-    free(pair_str);
-  }
-
-  return io_ops;
-}
-
-static void _streamConnection_DestroyOperations(IoOperations **opsPtr) {
-  parcAssertNotNull(opsPtr, "Parameter opsPtr must be non-null double pointer");
-  parcAssertNotNull(*opsPtr,
-                    "Parameter opsPtr must dereference to non-null pointer");
-
-  IoOperations *ops = *opsPtr;
-  parcAssertNotNull(ioOperations_GetClosure(ops),
-                    "ops->context must not be null");
-
-  _StreamState *stream = (_StreamState *)ioOperations_GetClosure(ops);
-
-  parcEventQueue_Destroy(&stream->bufferEventVector);
-
-  addressPair_Release(&stream->addressPair);
-
-  if (!stream->isClosed) {
-    stream->isClosed = true;
-    messenger_Send(forwarder_GetMessenger(stream->forwarder),
-                   missive_Create(MissiveType_ConnectionClosed, stream->id));
-  }
-
-  messenger_Send(forwarder_GetMessenger(stream->forwarder),
-                 missive_Create(MissiveType_ConnectionDestroyed, stream->id));
-
-  if (logger_IsLoggable(stream->logger, LoggerFacility_IO, PARCLogLevel_Info)) {
-    logger_Log(stream->logger, LoggerFacility_IO, PARCLogLevel_Info, __func__,
-               "StreamConnection %p destroyed", (void *)stream);
-  }
-
-  logger_Release(&stream->logger);
-  parcMemory_Deallocate((void **)&stream);
-  parcMemory_Deallocate((void **)&ops);
-
-  *opsPtr = NULL;
-}
-
-static bool _streamConnection_IsUp(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _StreamState *stream =
-      (const _StreamState *)ioOperations_GetClosure(ops);
-  return stream->isUp;
-}
-
-static bool _streamConnection_IsLocal(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _StreamState *stream =
-      (const _StreamState *)ioOperations_GetClosure(ops);
-  return stream->isLocal;
-}
-
-static const Address *_streamConnection_GetRemoteAddress(
-    const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _StreamState *stream =
-      (const _StreamState *)ioOperations_GetClosure(ops);
-  return addressPair_GetRemote(stream->addressPair);
-}
-
-static const AddressPair *_streamConnection_GetAddressPair(
-    const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _StreamState *stream =
-      (const _StreamState *)ioOperations_GetClosure(ops);
-  return stream->addressPair;
-}
-
-static unsigned _streamConnection_GetConnectionId(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _StreamState *stream =
-      (const _StreamState *)ioOperations_GetClosure(ops);
-  return stream->id;
-}
-
-bool _streamConnection_SendIOVBuffer(IoOperations *ops,
-    struct iovec * message, size_t size) {
-  parcAssertNotNull(ops, "Parameter ops must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
-
-  _StreamState *conn = (_StreamState *)ioOperations_GetClosure(ops);
-
-  if (!conn->isUp) {
-    if (logger_IsLoggable(conn->logger, LoggerFacility_IO,
-                          PARCLogLevel_Error)) {
-      logger_Log(
-          conn->logger, LoggerFacility_IO, PARCLogLevel_Error, __func__,
-          "connid %u tried to send to down connection (isUp %d isClosed %d)",
-          conn->id, conn->isUp, conn->isClosed);
-    }
-    return false;
-  }
-
-  PARCEventBuffer *buffer =
-      parcEventBuffer_GetQueueBufferOutput(conn->bufferEventVector);
-  size_t buffer_backlog = parcEventBuffer_GetLength(buffer);
-  parcEventBuffer_Destroy(&buffer);
-
-  if (buffer_backlog >= OUTPUT_QUEUE_BYTES) {
-    if (logger_IsLoggable(conn->logger, LoggerFacility_IO,
-                          PARCLogLevel_Warning)) {
-      logger_Log(conn->logger, LoggerFacility_IO, PARCLogLevel_Warning,
-                 __func__,
-                 "connid %u Writing to buffer backlog %zu bytes DROP MESSAGE",
-                 conn->id, buffer_backlog);
-    }
-    return false;
-  }
-
-  if (logger_IsLoggable(conn->logger, LoggerFacility_IO,
-                        PARCLogLevel_Debug)) {
-    size_t length = 0;
-    for (int i = 0; i < size; i++)
-      length += message[i].iov_len;
-
-    logger_Log( conn->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-            "connid %u Writing %zu bytes to buffer with backlog %zu bytes",
-            conn->id, length, buffer_backlog);
-  }
-
-  /* Write directly into the parcEventQueue without passing through message */
-  for (int i = 0; i < size; i++) {
-    if (parcEventQueue_Write(conn->bufferEventVector, message[i].iov_base,
-                message[i].iov_len) != 0)
-        return false;
-  }
-
-  return true;
-}
-
-/**
- * @function streamConnection_Send
- * @abstract Non-destructive send of the message.
- * @discussion
- *   Send uses message_CopyToStreamBuffer, which is a non-destructive write.
- *   The send may fail if there's no buffer space in the output queue.
- *
- * @param dummy is ignored.  A stream has only one peer.
- * @return <#return#>
- */
-static bool _streamConnection_Send(IoOperations *ops, const Address *dummy,
-                                   Message *message) {
-  parcAssertNotNull(ops, "Parameter ops must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
-  _StreamState *stream = (_StreamState *)ioOperations_GetClosure(ops);
-
-  bool success = false;
-  if (stream->isUp) {
-    PARCEventBuffer *buffer =
-        parcEventBuffer_GetQueueBufferOutput(stream->bufferEventVector);
-    size_t buffer_backlog = parcEventBuffer_GetLength(buffer);
-    parcEventBuffer_Destroy(&buffer);
-
-    if (buffer_backlog < OUTPUT_QUEUE_BYTES) {
-      if (logger_IsLoggable(stream->logger, LoggerFacility_IO,
-                            PARCLogLevel_Debug)) {
-        logger_Log(
-            stream->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-            "connid %u Writing %zu bytes to buffer with backlog %zu bytes",
-            stream->id, message_Length(message), buffer_backlog);
-      }
-
-      int failure = message_Write(stream->bufferEventVector, message);
-      if (failure == 0) {
-        success = true;
-      }
-    } else {
-      if (logger_IsLoggable(stream->logger, LoggerFacility_IO,
-                            PARCLogLevel_Warning)) {
-        logger_Log(stream->logger, LoggerFacility_IO, PARCLogLevel_Warning,
-                   __func__,
-                   "connid %u Writing to buffer backlog %zu bytes DROP MESSAGE",
-                   stream->id, buffer_backlog);
-      }
-    }
-  } else {
-    if (logger_IsLoggable(stream->logger, LoggerFacility_IO,
-                          PARCLogLevel_Error)) {
-      logger_Log(
-          stream->logger, LoggerFacility_IO, PARCLogLevel_Error, __func__,
-          "connid %u tried to send to down connection (isUp %d isClosed %d)",
-          stream->id, stream->isUp, stream->isClosed);
-    }
-  }
-
-  return success;
-}
-
-list_connections_type _streamConnection_GetConnectionType(
-    const IoOperations *ops) {
-  return CONN_TCP;
-}
-
-static void _sendProbe(IoOperations *ops, uint8_t *message) {
-  // we don't need to implemet this here, it is a local connection
-}
-
-// =================================================================
-// the actual I/O functions
-
-int _isACommand(PARCEventBuffer *input) {
-  size_t bytesAvailable = parcEventBuffer_GetLength(input);
-  parcAssertTrue(bytesAvailable >= sizeof(header_control_message),
-                 "Called with too short an input: %zu", bytesAvailable);
-
-  uint8_t *msg = parcEventBuffer_Pullup(input, bytesAvailable);
-  // read first byte of the header
-
-  // first byte: must be a REQUEST_LIGHT
-  if (msg[0] != REQUEST_LIGHT) {
-    return LAST_COMMAND_VALUE;
-  }
-
-  // second byte: must be a command_id
-  if (msg[1] < 0 || msg[1] >= LAST_COMMAND_VALUE) {
-    return LAST_COMMAND_VALUE;
-  }
-
-  return msg[1];
-}
-
-PARCEventBuffer *_tryReadControlMessage(_StreamState *stream,
-                                        PARCEventBuffer *input,
-                                        command_id command,
-                                        struct iovec **request) {
-  size_t bytesAvailable = parcEventBuffer_GetLength(input);
-
-  if (stream->nextMessageLength == 0) {
-    stream->nextMessageLength =
-        sizeof(header_control_message) +
-        payloadLengthDaemon(command);  // consider the whole packet.
-  }
-
-  if (bytesAvailable >= stream->nextMessageLength) {
-    PARCEventBuffer *message = parcEventBuffer_Create();
-    int bytesRead = parcEventBuffer_ReadIntoBuffer(input, message,
-                                                   stream->nextMessageLength);
-    parcAssertTrue(bytesRead == stream->nextMessageLength,
-                   "Partial read, expected %zu got %d",
-                   stream->nextMessageLength, bytesRead);
-
-    uint8_t *control =
-        parcEventBuffer_Pullup(message, stream->nextMessageLength);
-    if (!(*request = (struct iovec *)parcMemory_AllocateAndClear(
-              sizeof(struct iovec) * 2))) {
-      return NULL;
-    }
-    (*request)[0].iov_base = control;  // header
-    (*request)[0].iov_len = sizeof(header_control_message);
-    if (payloadLengthDaemon(command) > 0) {
-      (*request)[1].iov_base =
-          control + sizeof(header_control_message);  // payload
-    } else {
-      (*request)[1].iov_base = NULL;
-    }
-    (*request)[1].iov_len = payloadLengthDaemon(command);
-    // now reset message length for next packet
-
-    stream->nextMessageLength = 0;
-
-    return message;
-  }
-
-  return NULL;
-}
-
-static bool _isAnHicnPacket(PARCEventBuffer *input) {
-  size_t bytesAvailable = parcEventBuffer_GetLength(input);
-  parcAssertTrue(bytesAvailable >= sizeof(header_control_message),
-                 "Called with too short an input: %zu", bytesAvailable);
-
-  uint8_t *fh = parcEventBuffer_Pullup(input, sizeof(header_control_message));
-  return messageHandler_IsValidHicnPacket(fh);
-}
-
-static Message *_readMessage(_StreamState *stream, Ticks time,
-                             PARCEventBuffer *input) {
-  Message *message = message_CreateFromEventBuffer(
-      input, stream->nextMessageLength, stream->id, time, stream->logger);
-
-  return message;
-}
-
-static void _startNewMessage(_StreamState *stream, PARCEventBuffer *input,
-                             size_t inputBytesAvailable) {
-  parcAssertTrue(stream->nextMessageLength == 0,
-                 "Invalid state, nextMessageLength not zero: %zu",
-                 stream->nextMessageLength);
-  parcAssertTrue(inputBytesAvailable >= sizeof(header_control_message),
-                 "read_length not a whole fixed header!: %zd",
-                 inputBytesAvailable);
-
-  // this linearizes the first messageHandler_GetIPv6HeaderLength() bytes of the
-  // input buffer's iovecs and returns a pointer to it.
-  uint8_t *fh = parcEventBuffer_Pullup(input, sizeof(header_control_message));
-
-  // Calculate the total message size based on the fixed header
-  stream->nextMessageLength = messageHandler_GetTotalPacketLength(fh);
-}
-
-static Message *_tryReadMessage(PARCEventBuffer *input, _StreamState *stream) {
-  size_t bytesAvailable = parcEventBuffer_GetLength(input);
-  parcAssertTrue(bytesAvailable >= sizeof(header_control_message),
-                 "Called with too short an input: %zu", bytesAvailable);
-
-  if (stream->nextMessageLength == 0) {
-    _startNewMessage(stream, input, bytesAvailable);
-  }
-
-  // This is not an ELSE statement.  We can both start a new message then
-  // check if there's enough bytes to read the whole thing.
-
-  if (bytesAvailable >= stream->nextMessageLength) {
-    Message *message =
-        _readMessage(stream, forwarder_GetTicks(stream->forwarder), input);
-
-    // now reset message length for next packet
-    stream->nextMessageLength = 0;
-
-    return message;
-  }
-
-  return NULL;
-}
-
-/**
- * @function conn_readcb
- * @abstract Event callback for reads
- * @discussion
- *   Will read messages off the input.  Continues reading as long as we
- *   can get a header to determine the next message length or as long as we
- *   can read a complete message.
- *
- *   This function manipulates the read low water mark.  (1) read a fixed header
- * plus complete message, then set the low water mark to FIXED_HEADER_LEN.  (2)
- * read a fixed header, but not a complete message, then set low water mark to
- * the total mesage length.  Using the low water mark like this means the buffer
- * event will only trigger on meaningful byte boundaries when we can get actual
- *   work done.
- *
- * @param <#param1#>
- * @return <#return#>
- */
-static void _conn_readcb(PARCEventQueue *event, PARCEventType type,
-                         void *ioOpsVoid) {
-  command_id command;
-  IoOperations *ops = (IoOperations *)ioOpsVoid;
-  _StreamState *stream = (_StreamState *)ioOperations_GetClosure(ops);
-
-  PARCEventBuffer *input = parcEventBuffer_GetQueueBufferInput(event);
-
-  // drain the input buffer
-
-  // notice that we always try to read at least 8 bytes
-  // (sizeof(header_control_message)). This is enough to read the length of all
-  // kind of packets
-  while (parcEventBuffer_GetLength(input) >= sizeof(header_control_message) &&
-         parcEventBuffer_GetLength(input) >= stream->nextMessageLength) {
-
-    if ((command = _isACommand(input)) != LAST_COMMAND_VALUE) {
-      struct iovec *rx;
-      // Get message from the stream and set the stream->nextMessageLength
-      PARCEventBuffer *message =
-          _tryReadControlMessage(stream, input, command, &rx);
-      // If received correctly the whole message, send to dispatcher
-      if (message) {
-        forwarder_ReceiveCommand(stream->forwarder, command, rx, stream->id);
-        //parcMemory_Deallocate((void **)&rx);
-        parcEventBuffer_Destroy(&message);
-      }
-
-    } else if (_isAnHicnPacket(input)) {
-      // this is an Hicn packet (here we should distinguish between IPv4 and
-      // IPv6 tryReadMessage may set nextMessageLength
-      Message *message = _tryReadMessage(input, stream);
-
-      if (message) {
-        forwarder_Receive(stream->forwarder, message);
-      }
-
-    } else {
-      parcAssertTrue(false,
-                     "(Local stream connection) malformed packet received");
-    }
-  }
-
-  if (stream->nextMessageLength == 0) {
-    // we don't have the next header, so set it to the header length
-    streamBuffer_SetWatermark(event, true, false,
-                              sizeof(header_control_message), 0);
-  } else {
-    // set it to the packet length
-    streamBuffer_SetWatermark(event, true, false, stream->nextMessageLength, 0);
-  }
-  parcEventBuffer_Destroy(&input);
-}
-
-static void _setConnectionState(_StreamState *stream, bool isUp) {
-  parcAssertNotNull(stream, "Parameter stream must be non-null");
-
-  Messenger *messenger = forwarder_GetMessenger(stream->forwarder);
-
-  bool oldStateIsUp = stream->isUp;
-  stream->isUp = isUp;
-
-  if (oldStateIsUp && !isUp) {
-    // bring connection DOWN
-    Missive *missive = missive_Create(MissiveType_ConnectionDown, stream->id);
-    messenger_Send(messenger, missive);
-    return;
-  }
-
-  if (!oldStateIsUp && isUp) {
-    // bring connection UP
-    Missive *missive = missive_Create(MissiveType_ConnectionUp, stream->id);
-    messenger_Send(messenger, missive);
-    return;
-  }
-}
-
-static void _conn_eventcb(PARCEventQueue *event, PARCEventQueueEventType events,
-                          void *ioOpsVoid) {
-  IoOperations *ops = (IoOperations *)ioOpsVoid;
-  _StreamState *stream = (_StreamState *)ioOperations_GetClosure(ops);
-
-  if (events & PARCEventQueueEventType_Connected) {
-    if (logger_IsLoggable(stream->logger, LoggerFacility_IO,
-                          PARCLogLevel_Info)) {
-      logger_Log(stream->logger, LoggerFacility_IO, PARCLogLevel_Info, __func__,
-                 "Connection %u is connected", stream->id);
-    }
-
-    // if the stream was closed, do not transition to an UP state
-    if (!stream->isClosed) {
-      _setConnectionState(stream, true);
-    }
-  } else if (events & PARCEventQueueEventType_EOF) {
-    if (logger_IsLoggable(stream->logger, LoggerFacility_IO,
-                          PARCLogLevel_Info)) {
-      logger_Log(stream->logger, LoggerFacility_IO, PARCLogLevel_Info, __func__,
-                 "connid %u closed.", stream->id);
-    }
-
-    parcEventQueue_Disable(stream->bufferEventVector, PARCEventType_Read);
-
-    _setConnectionState(stream, false);
-
-    if (!stream->isClosed) {
-      stream->isClosed = true;
-      // this will cause the connection manager to destroy the connection later
-      messenger_Send(forwarder_GetMessenger(stream->forwarder),
-                     missive_Create(MissiveType_ConnectionClosed, stream->id));
-    }
-  } else if (events & PARCEventQueueEventType_Error) {
-    if (logger_IsLoggable(stream->logger, LoggerFacility_IO,
-                          PARCLogLevel_Error)) {
-      logger_Log(stream->logger, LoggerFacility_IO, PARCLogLevel_Error,
-                 __func__, "Got an error on the connection %u: %s", stream->id,
-                 strerror(errno));
-    }
-
-    parcEventQueue_Disable(stream->bufferEventVector,
-                           PARCEventType_Read | PARCEventType_Write);
-
-    _setConnectionState(stream, false);
-
-    if (!stream->isClosed) {
-      stream->isClosed = true;
-      // this will cause the connection manager to destroy the connection later
-      messenger_Send(forwarder_GetMessenger(stream->forwarder),
-                     missive_Create(MissiveType_ConnectionClosed, stream->id));
-    }
-  }
-  /* None of the other events can happen here, since we haven't enabled
-   * timeouts */
-}
-
-static connection_state_t _streamConnection_getState(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _StreamState *stream =
-      (const _StreamState *)ioOperations_GetClosure(ops);
-  return stream->state;
-}
-
-static void _streamConnection_setState(IoOperations *ops, connection_state_t state) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  _StreamState *stream =
-      (_StreamState *)ioOperations_GetClosure(ops);
-  stream->state = state;
-}
-
-static connection_state_t _streamConnection_getAdminState(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _StreamState *stream =
-      (const _StreamState *)ioOperations_GetClosure(ops);
-  return stream->admin_state;
-}
-
-static void _streamConnection_setAdminState(IoOperations *ops, connection_state_t admin_state) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  _StreamState *stream =
-      (_StreamState *)ioOperations_GetClosure(ops);
-  stream->admin_state = admin_state;
-}
-
-#ifdef WITH_POLICY
-static uint32_t _streamConnection_getPriority(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _StreamState *stream =
-      (const _StreamState *)ioOperations_GetClosure(ops);
-  return stream->priority;
-}
-
-static void _streamConnection_setPriority(IoOperations *ops, uint32_t priority) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  _StreamState *stream =
-      (_StreamState *)ioOperations_GetClosure(ops);
-  stream->priority = priority;
-}
-#endif /* WITH_POLICY */
-
-static const char * _streamConnection_getInterfaceName(const IoOperations *ops)
-{
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  _StreamState *stream =
-      (_StreamState *)ioOperations_GetClosure(ops);
-  return stream->interfaceName;
-}
diff --git a/hicn-light/src/hicn/io/streamConnection.h b/hicn-light/src/hicn/io/streamConnection.h
deleted file mode 100644
index f483d0b82..000000000
--- a/hicn-light/src/hicn/io/streamConnection.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * Methods common to TCP and PF_LOCAL stream-based listeners
- */
-
-#ifndef streamConnection_h
-#define streamConnection_h
-
-#include <hicn/core/forwarder.h>
-#include <hicn/core/messagePacketType.h>
-#include <hicn/io/addressPair.h>
-#include <hicn/io/ioOperations.h>
-#include <hicn/utils/address.h>
-
-/**
- * @function streamConnection_AcceptConnection
- * @abstract Receive a connection from a remote peer
- * @discussion
- *   We are the "server side" of the stream connection, so we need to accept the
- * client connection and setup state for her.
- *
- * @param <#param1#>
- * @return <#return#>
- */
-IoOperations *streamConnection_AcceptConnection(Forwarder *forwarder, int fd,
-                                                AddressPair *pair,
-                                                bool isLocal);
-
-/**
- * @function streamConnection_OpenConnection
- * @abstract Initiate a connection to a remote peer
- * @discussion
- *   We are the "client side" of the stream connection.  We'll create state for
- * the peer, but it will be in the "down" state until the connection
- * establishes.
- *
- *   For TCP, both address pairs need to be the same address family: both INET
- * or both INET6.  The remote address must have the complete socket information
- * (address, port).  The local socket could be wildcarded or may specify down to
- * the (address, port) pair.
- *
- *   If the local address is IPADDR_ANY and the port is 0, then it is a normal
- * call to "connect" that will use whatever local IP address and whatever local
- * port for the connection.  If either the address or port is set, the local
- * socket will first be bound (via bind(2)), and then call connect().
- *
- *   AF_UNIX is not yet supported
- *
- *   If there's an error binding to the specified address or connecting to the
- * remote address, will return NULL.
- *
- * @param pair (takes ownership of this) is the complete socket pair of
- * (address, port) for each end, if INET or INET6.
- * @return NULL on error, otherwise the connections IO operations.
- */
-IoOperations *streamConnection_OpenConnection(Forwarder *forwarder,
-                                              AddressPair *pair, bool isLocal);
-
-bool streamState_SendIOVBuffer(IoOperations *ops, struct iovec *response,
-    size_t size);
-
-#endif  // streamConnection_h
diff --git a/hicn-light/src/hicn/io/tcp.c b/hicn-light/src/hicn/io/tcp.c
new file mode 100644
index 000000000..69ad32d16
--- /dev/null
+++ b/hicn-light/src/hicn/io/tcp.c
@@ -0,0 +1,535 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Common activity for STREAM based listeners.
+ */
+
+#include <errno.h>
+#ifndef _WIN32
+#include <unistd.h>  // fcntl
+#endif               /* _WIN32 */
+#include <fcntl.h>   // fcntl
+#include <hicn/hicn-light/config.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <hicn/hicn.h>
+#include <hicn/util/log.h>
+
+#include "base.h"
+#include "../core/connection.h"
+#include "../core/connection_vft.h"
+#include "../core/listener.h"
+#include "../core/listener_vft.h"
+#include "../core/msgbuf.h"
+#include "../core/forwarder.h"
+#include "../core/messageHandler.h"
+
+// 128 KB output queue
+#define OUTPUT_QUEUE_BYTES (128 * 1024)
+
+#define TCP_RECV_BUFLEN 8192
+//#define MTU 1500
+
+/******************************************************************************
+ * Listener
+ ******************************************************************************/
+
+typedef struct {
+  void *_;
+} listener_tcp_data_t;
+
+static int listener_tcp_initialize(listener_t *listener) {
+  ERROR("[listener_tcp_initialize] Not implemented");
+
+  return 0;
+}
+
+static void listener_tcp_finalize(listener_t *listener) {
+  ERROR("[listener_tcp_finalize] Not implemented");
+}
+
+static int listener_tcp_punt(const listener_t *listener, const char *prefix_s) {
+  ERROR("[listener_tcp_punt] Not implemented");
+  return -1;
+}
+
+static int listener_tcp_get_socket(const listener_t *listener,
+                                   const address_t *local,
+                                   const address_t *remote,
+                                   const char *interface_name) {
+  ERROR("[listener_tcp_get_socket] Not implemented");
+  return -1;
+}
+
+#define listener_tcp_read_single io_read_single_socket
+#define listener_tcp_read_batch NULL
+
+DECLARE_LISTENER(tcp);
+
+/******************************************************************************
+ * Connection
+ ******************************************************************************/
+
+typedef struct {
+  /* Partial receive buffer */
+  u8 buf[TCP_RECV_BUFLEN];
+  size_t roff; /**< Read offset */
+  size_t woff; /**< Write offset */
+
+  // XXX this should be initialized with the header length, and tells what we
+  // expect to receive next...
+  size_t next_len;
+  struct bufferevent *bufferevent;
+} connection_tcp_data_t;
+
+// XXX This seems more a listener code !
+// XXX we must have accept to the connection table to spawn new ones !!
+// XXX equivalent to initialize
+int connection_tcp_accept(connection_t *connection, listener_t *listener,
+                          int fd, address_pair_t *pair, bool local,
+                          unsigned connection_id) {
+  assert(connection);
+  assert(listener);
+
+  *connection = (connection_t){
+      .id = connection_id,
+      .interface_name = NULL,
+      .type = FACE_TYPE_TCP,
+      .pair = *pair,
+      .fd = fd,
+      .local = local,
+      // As we are accepting a connection, we begin in the UP state
+      .state = FACE_STATE_UP,
+      .admin_state = FACE_STATE_UP,
+#ifdef WITH_POLICY
+      .priority = 0,
+#endif /* WITH_POLICY */
+
+      .listener = listener,
+      .closed = false,
+  };
+
+  WITH_INFO({
+    char addr_str[NI_MAXHOST];
+    int port;
+    address_to_string(&(pair->local), addr_str, &port);
+    INFO("%s connection %p created for address %s:%d (local=%s)",
+         face_type_str(connection->type), connection, addr_str, port,
+         connection_is_local(connection) ? "true" : "false");
+  })
+
+  return 0;
+}
+
+int make_socket(address_pair_t *pair) {
+#ifndef _WIN32
+  int fd = socket(address_family(&pair->local), SOCK_STREAM, 0);
+  if (fd < 0) {
+    perror("socket");
+    goto ERR_SOCKET;
+  }
+#else
+  SOCKET fd = socket(address_family(&pair->local), SOCK_STREAM, 0);
+  if (fd == INVALID_SOCKET) {
+    perror("socket");
+    goto ERR_SOCKET;
+  }
+#endif /* _WIN32 */
+
+  /* Set non-blocking flag */
+#ifndef _WIN32
+  int flags = fcntl(fd, F_GETFL, NULL);
+  if (flags == -1) {
+    perror("F_GETFL");
+    goto ERR;
+  }
+  if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
+    perror("F_SETFL");
+    goto ERR;
+  }
+#else
+  if (ioctlsocket(fd, FIONBIO, &(u_long){1}) != NO_ERROR) {
+    perror("ioctlsocket");
+    goto ERR;
+  }
+#endif /* _WIN32 */
+
+  if (bind(fd, address_sa(&pair->local), address_socklen(&pair->local)) == -1) {
+    perror("bind");
+    goto ERR;
+  }
+
+  if (connect(fd, address_sa(&pair->remote), address_socklen(&pair->remote)) <
+      0) {
+    perror("connect");
+    goto ERR;
+  }
+
+  return 0;
+
+ERR:
+#ifndef _WIN32
+  close(fd);
+#else
+  closesocket(fd);
+#endif
+
+ERR_SOCKET:
+  return -1;
+}
+
+static int connection_tcp_initialize(connection_t *connection) {
+  assert(connection);
+  assert(connection->type == FACE_TYPE_TCP);
+
+  connection_tcp_data_t *data = connection->data;
+  assert(data);
+
+  data->roff = 0;
+  data->woff = 0;
+
+  connection->fd = make_socket(connection_get_pair(connection));
+  if (connection->fd < 0) {
+    ERROR("Error creating TCP socket");
+    return -1;
+  }
+
+  WITH_INFO({
+    char local_addr_str[NI_MAXHOST];
+    char remote_addr_str[NI_MAXHOST];
+    int local_port;
+    int remote_port;
+    address_to_string(&(connection->pair.local), local_addr_str, &local_port);
+    address_to_string(&(connection->pair.remote), remote_addr_str,
+                      &remote_port);
+    INFO("%s connection %p connect for address pair %s:%d (local=%s) - %s:%d",
+         face_type_str(connection->type), connection, local_addr_str,
+         local_port, connection_is_local(connection) ? "true" : "false",
+         remote_addr_str, remote_port);
+  })
+
+  return 0;
+}
+
+// XXX a part needs to be handled in the connection.c
+static void connection_tcp_finalize(connection_t *connection) {
+  if (!connection->closed) {
+    connection->closed = true;
+    // XXX need to delete the connection like previously in the connection
+    // manager
+  }
+
+  INFO("%s connection %p destroyed", face_type_str(connection->type),
+       connection);
+  // XXX need to release the "connection"
+}
+
+#if 0
+static
+bool
+connection_tcp_sendv(connnection_t * connection, struct iovec * iov,
+        size_t size)
+{
+    assert(connection);
+    assert(iov);
+
+    if (!connection_is_up(connection)) {
+        ERROR("Connection #%u tried to send to down connection (up=%d closed=%d)",
+                connection_get_id(connection),
+                connection_get_up(connection) ? "true" : "false",
+                connection_get_closed(connection) ? "true" : "false");
+        return false;
+    }
+
+    PARCEventBuffer *buffer =
+        parcEventBuffer_GetQueueBufferOutput(connection->events);
+    size_t buffer_backlog = parcEventBuffer_GetLength(buffer);
+    parcEventBuffer_Destroy(&buffer);
+
+    if (buffer_backlog >= OUTPUT_QUEUE_BYTES) {
+        WARN("Connection #%u Writing to buffer backlog %zu bytes DROP MESSAGE",
+                connection_get_id(connection), buffer_backlog);
+        return false;
+    }
+
+#if 0
+    /* DEBUG */
+    size_t length = 0;
+    for (int i = 0; i < size; i++)
+        length += message[i].iov_len;
+    DEBUG("Connection #%u writing %zu bytes to buffer with backlog %zu bytes",
+            connection_get_id(connection), length, buffer_backlog);
+#endif
+
+    /* Write directly into the parcEventQueue without passing through message */
+    for (int i = 0; i < size; i++) {
+        if (parcEventQueue_Write(conn->events, iov[i].iov_base,
+                    iov[i].iov_len) != 0)
+            return false;
+    }
+
+    return true;
+}
+#endif
+
+static bool connection_tcp_flush(const connection_t *connection) {
+  return true;
+}
+
+/**
+ * @function streamConnection_Send
+ * @abstract Non-destructive send of the message.
+ * @discussion
+ *   Send uses message_CopyToStreamBuffer, which is a non-destructive write.
+ *   The send may fail if there's no buffer space in the output queue.
+ *
+ * @param dummy is ignored.  A stream has only one peer.
+ * @return <#return#>
+ */
+// XXX address not used anywhere
+// XXX too much repeated code with sendv here
+static bool connection_tcp_send(const connection_t *connection,
+                                msgbuf_t *msgbuf, bool queue) {
+  assert(connection);
+  assert(msgbuf);
+
+  if (!connection_is_up(connection)) {
+    ERROR("Connection #%u tried to send to down connection (up=%d closed=%d)",
+          connection_get_id(connection),
+          connection_is_up(connection) ? "true" : "false",
+          connection_is_closed(connection) ? "true" : "false");
+    return false;
+  }
+
+  // XXX TODO write to fd
+#if 0
+    PARCEventBuffer *buffer =
+        parcEventBuffer_GetQueueBufferOutput(connection->events);
+    size_t buffer_backlog = parcEventBuffer_GetLength(buffer);
+    parcEventBuffer_Destroy(&buffer);
+
+    if (buffer_backlog >= OUTPUT_QUEUE_BYTES) {
+        WARN("Connection #%u Writing to buffer backlog %zu bytes DROP MESSAGE",
+                connection_get_id(connection), buffer_backlog);
+        return false;
+    }
+
+    DEBUG("Connection #%u Writing %zu bytes to buffer with backlog %zu bytes",
+            connection_get_id(connection), msgbuf_len(message), buffer_backlog);
+
+    return (parcEventQueue_Write(connection->events, msgbuf_packet(message),
+                msgbuf_len(message)) == 0);
+#endif
+  return true;
+}
+
+static int connection_tcp_send_packet(const connection_t *connection,
+                                      const uint8_t *packet, size_t size) {
+  /* Not implemented for local connections */
+  // XXX shall we set the pointer to NULL and add a check ?
+
+  ERROR("[connection_tcp_send_packet] Not implemented");
+
+  return -1;
+}
+
+// =================================================================
+// the actual I/O functions
+
+// not needed anymore ?
+#if 0
+// XXX this is called iif there is sufficient data to read, otherwise it raises
+// an assertion error. This was a problem before I guess
+static
+int
+connection_tcp_read_message(connection_t * connection, msgbuf_t * msgbuf)
+{
+    assert(connection);
+    assert(msgbuf);
+
+    connection_tcp_data_t * data = connection->data;
+    assert(data);
+
+    size_t n = evbuffer_get_length(data->evbuffer);
+    // XXX this check was wrong
+    // parcAssertTrue(n >= sizeof(cmd_header_t),
+            "Called with too short an input: %zu", n);
+
+    // XXX WTF
+    if (stream->next_len == 0) {
+        // this linearizes the first messageHandler_GetIPv6HeaderLength() bytes of the
+        // input buffer's iovecs and returns a pointer to it.
+        uint8_t *fh = parcEventBuffer_Pullup(data->evbuffer, sizeof(cmd_header_t));
+
+        // Calculate the total message size based on the fixed header
+        stream->next_len = messageHandler_GetTotalPacketLength(fh);
+    }
+    // This is not an ELSE statement.  We can both start a new message then
+    // check if there's enough bytes to read the whole thing.
+
+    if (n < stream->next_len)
+        return -1;
+
+    uint8_t packet_type;
+    if (messageHandler_IsInterest(packet)) {
+        packet_type = MESSAGE_TYPE_INTEREST;
+    } else if (messageHandler_IsData(packet)) {
+        packet_type = MESSAGE_TYPE_DATA;
+    } else {
+        ERROR("Dropped packet that is not interest nor data");
+        goto ERR;
+    }
+
+    if (evbuffer_remove(data->evbuffer, data->packet, data->next_len) < 0)
+        return -1;
+
+    msgbuf_from_packet(msgbuf, data->packet, packet_type, stream->id,
+            ticks_now());
+
+    // now reset message length for next packet
+    data->next_len = 0;
+    return 0;
+
+ERR:
+    evbuffer_drain(data->evbuffer, data->next_len);
+    return -1;
+}
+#endif
+
+/**
+ * @function conn_readcb
+ * @abstract Event callback for reads
+ * @discussion
+ *   Will read messages off the input.  Continues reading as long as we
+ *   can get a header to determine the next message length or as long as we
+ *   can read a complete message.
+ *
+ *   This function manipulates the read low water mark.  (1) read a fixed header
+ * plus complete message, then set the low water mark to FIXED_HEADER_LEN.  (2)
+ * read a fixed header, but not a complete message, then set low water mark to
+ * the total mesage length.  Using the low water mark like this means the buffer
+ * event will only trigger on meaningful byte boundaries when we can get actual
+ *   work done.
+ *
+ * @param <#param1#>
+ * @return <#return#>
+ */
+#if 0
+static
+void
+connection_tcp_read_callback(connection_t * connection, int fd, void * user_data)
+{
+    assert(connection);
+    /* user_data can be NULL */
+
+    connection_tcp_data_t * data = connection->data;
+    assert(TCP_RECV_BUFLEN - data->woff > MTU);
+
+    /* No batching here as code is not expected to receive much throughput */
+    for (;;) {
+        ssize_t n = recv(connection->fd, data->buf + data->woff,
+                TCP_RECV_BUFLEN - data->woff, 0);
+        if (n == 0) /* EOF */
+            return; // XXX close connection
+        if (n < 0) {
+            if (errno == EWOULDBLOCK)
+                break;
+            perror("recv");
+            return; // XXX close connection
+        }
+        data->woff += n;
+
+        /* Process */
+        uint8_t * packet = data->buf + data->roff;
+        size_t size = data->woff - data->roff; /* > 0 */
+
+        ssize_t used = listener_read_callback(NULL, fd,
+                address_pair_get_local(&connection->pair), packet, size);
+        if (used < 0)
+            return; // XXX close connection ?
+        if (used == 0)
+            break; /* We would have received more if there was still packets to be read */
+        data->roff += used;
+        assert(data->roff <= data->woff);
+
+        if (data->roff == data->woff) {
+            /* Reset state whenever possible to avoid memcpy's */
+            data->roff = 0;
+            data->woff = 0;
+            return;
+        }
+    }
+
+    /* Make sure there is enough remaining space in the buffer */
+    if (TCP_RECV_BUFLEN - data->woff < MTU) {
+        /*
+         * There should be no overlap provided a sufficiently large BUFLEN, but
+         * who knows.
+         */
+        memmove(data->buf, data->buf + data->roff, data->woff - data->roff);
+        data->woff -= data->roff;
+        data->roff = 0;
+    }
+
+    return;
+}
+#endif
+
+#if 0
+static
+void
+connection_tcp_callback(connection_t * connection, int fd, void * user_data)
+{
+    if (events & PARCEventQueueEventType_Connected) {
+        INFO("Connection %u is connected", stream->id);
+
+        // if the stream was closed, do not transition to an UP state
+        if (!stream->isClosed) {
+            _setConnectionState(stream, true);
+        }
+    } else if (events & PARCEventQueueEventType_EOF) {
+        INFO("connid %u closed.", stream->id);
+
+        parcEventQueue_Disable(stream->events, PARCEventType_Read);
+
+        _setConnectionState(stream, false);
+
+        if (!stream->isClosed) {
+            stream->isClosed = true;
+            // XXX TODO destroy the connection
+        }
+    } else if (events & PARCEventQueueEventType_Error) {
+        ERROR("Got an error on the connection %u: %s", stream->id,
+                strerror(errno));
+
+        parcEventQueue_Disable(stream->events,
+                PARCEventType_Read | PARCEventType_Write);
+
+        _setConnectionState(stream, false);
+
+        if (!stream->isClosed) {
+            stream->isClosed = true;
+            // XXX TODO destroy the connection
+        }
+    }
+    /* None of the other events can happen here, since we haven't enabled
+     * timeouts */
+}
+#endif
+
+DECLARE_CONNECTION(tcp)
diff --git a/hicn-light/src/hicn/io/tcpListener.c b/hicn-light/src/hicn/io/tcpListener.c
deleted file mode 100644
index e2b80c215..000000000
--- a/hicn-light/src/hicn/io/tcpListener.c
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
- * 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 <errno.h>
-#include <hicn/hicn-light/config.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <hicn/core/connectionTable.h>
-#include <hicn/core/forwarder.h>
-#include <hicn/io/listener.h>
-#include <hicn/io/streamConnection.h>
-#include <hicn/io/tcpListener.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-#include <parc/assert/parc_Assert.h>
-
-typedef struct tcp_listener {
-  char *listenerName;
-  Forwarder *forwarder;
-  Logger *logger;
-
-  PARCEventSocket *listener;
-
-  Address *localAddress;
-
-  unsigned id;
-  char *interfaceName;
-
-  // is the localAddress as 127.0.0.0 address?
-  bool isLocalAddressLocal;
-} _TcpListener;
-
-static void _tcpListener_Destroy(_TcpListener **listenerPtr);
-
-static void _tcpListener_OpsDestroy(ListenerOps **listenerOpsPtr);
-
-static const char *_tcpListener_ListenerName(const ListenerOps *ops);
-
-static unsigned _tcpListener_OpsGetInterfaceIndex(const ListenerOps *ops);
-
-static const Address *_tcpListener_OpsGetListenAddress(const ListenerOps *ops);
-
-static const char *_tcpListener_InterfaceName(const ListenerOps *ops);
-
-static EncapType _tcpListener_OpsGetEncapType(const ListenerOps *ops);
-
-static ListenerOps _tcpTemplate = {
-    .context = NULL,
-    .destroy = &_tcpListener_OpsDestroy,
-    .getListenerName = &_tcpListener_ListenerName,
-    .getInterfaceIndex = &_tcpListener_OpsGetInterfaceIndex,
-    .getListenAddress = &_tcpListener_OpsGetListenAddress,
-    .getEncapType = &_tcpListener_OpsGetEncapType,
-    .getInterfaceName = &_tcpListener_InterfaceName,
-    .getSocket = NULL};
-
-// STREAM daemon listener callback
-static void _tcpListener_Listen(int, struct sockaddr *, int socklen,
-                                void *tcpVoid);
-
-ListenerOps *tcpListener_CreateInet6(Forwarder *forwarder, char *listenerName,
-                                     struct sockaddr_in6 sin6, char *interfaceName) {
-
-  _TcpListener *tcp = parcMemory_AllocateAndClear(sizeof(_TcpListener));
-  parcAssertNotNull(tcp, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(_TcpListener));
-
-  tcp->forwarder = forwarder;
-  tcp->listenerName = parcMemory_StringDuplicate(listenerName, strlen(listenerName));
-  tcp->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-  tcp->interfaceName = parcMemory_StringDuplicate(interfaceName, strlen(interfaceName));
-
-  tcp->listener = dispatcher_CreateListener(
-      forwarder_GetDispatcher(forwarder), _tcpListener_Listen, (void *)tcp, -1,
-      (struct sockaddr *)&sin6, sizeof(sin6));
-
-  if (tcp->listener == NULL) {
-    logger_Log(tcp->logger, LoggerFacility_IO, PARCLogLevel_Error, __func__,
-               "dispatcher_CreateListener failed to create listener (%d) %s",
-               errno, strerror(errno));
-    logger_Release(&tcp->logger);
-    parcMemory_Deallocate((void **)&tcp);
-    return NULL;
-  }
-
-  tcp->localAddress = addressCreateFromInet6(&sin6);
-  tcp->id = forwarder_GetNextConnectionId(forwarder);
-  tcp->isLocalAddressLocal =
-      parcNetwork_IsSocketLocal((struct sockaddr *)&sin6);
-
-  ListenerOps *ops = parcMemory_AllocateAndClear(sizeof(ListenerOps));
-  parcAssertNotNull(ops, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(ListenerOps));
-
-  memcpy(ops, &_tcpTemplate, sizeof(ListenerOps));
-  ops->context = tcp;
-
-  if (logger_IsLoggable(tcp->logger, LoggerFacility_IO, PARCLogLevel_Debug)) {
-    char *str = addressToString(tcp->localAddress);
-    logger_Log(tcp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-               "TcpListener %p created for address %s (isLocal %d)",
-               (void *)tcp, str, tcp->isLocalAddressLocal);
-    parcMemory_Deallocate((void **)&str);
-  }
-
-  return ops;
-}
-
-ListenerOps *tcpListener_CreateInet(Forwarder *forwarder, char *listenerName,
-                                    struct sockaddr_in sin, char *interfaceName) {
-  _TcpListener *tcp = parcMemory_AllocateAndClear(sizeof(_TcpListener));
-  parcAssertNotNull(tcp, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(_TcpListener));
-
-  tcp->forwarder = forwarder;
-  tcp->listenerName = parcMemory_StringDuplicate(listenerName, strlen(listenerName));
-  tcp->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-  tcp->interfaceName = parcMemory_StringDuplicate(interfaceName, strlen(interfaceName));
-
-  tcp->listener = dispatcher_CreateListener(
-      forwarder_GetDispatcher(forwarder), _tcpListener_Listen, (void *)tcp, -1,
-      (struct sockaddr *)&sin, sizeof(sin));
-
-  if (tcp->listener == NULL) {
-    logger_Log(tcp->logger, LoggerFacility_IO, PARCLogLevel_Error, __func__,
-               "dispatcher_CreateListener failed to create listener (%d) %s",
-               errno, strerror(errno));
-
-    logger_Release(&tcp->logger);
-    parcMemory_Deallocate((void **)&tcp);
-    return NULL;
-  }
-
-  tcp->localAddress = addressCreateFromInet(&sin);
-  tcp->id = forwarder_GetNextConnectionId(forwarder);
-  tcp->isLocalAddressLocal = parcNetwork_IsSocketLocal((struct sockaddr *)&sin);
-
-  ListenerOps *ops = parcMemory_AllocateAndClear(sizeof(ListenerOps));
-  parcAssertNotNull(ops, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(ListenerOps));
-
-  memcpy(ops, &_tcpTemplate, sizeof(ListenerOps));
-  ops->context = tcp;
-
-  if (logger_IsLoggable(tcp->logger, LoggerFacility_IO, PARCLogLevel_Debug)) {
-    char *str = addressToString(tcp->localAddress);
-    logger_Log(tcp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-               "TcpListener %p created for address %s (isLocal %d)",
-               (void *)tcp, str, tcp->isLocalAddressLocal);
-    parcMemory_Deallocate((void **)&str);
-  }
-
-  return ops;
-}
-
-static void _tcpListener_Destroy(_TcpListener **listenerPtr) {
-  parcAssertNotNull(listenerPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*listenerPtr,
-                    "Parameter must derefernce to non-null pointer");
-  _TcpListener *tcp = *listenerPtr;
-
-  if (logger_IsLoggable(tcp->logger, LoggerFacility_IO, PARCLogLevel_Debug)) {
-    char *str = addressToString(tcp->localAddress);
-    logger_Log(tcp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-               "TcpListener %p destroyed", (void *)tcp);
-    parcMemory_Deallocate((void **)&str);
-  }
-
-  parcMemory_Deallocate((void **)&tcp->listenerName);
-  parcMemory_Deallocate((void **)&tcp->interfaceName);
-  logger_Release(&tcp->logger);
-  dispatcher_DestroyListener(forwarder_GetDispatcher(tcp->forwarder),
-                             &tcp->listener);
-  addressDestroy(&tcp->localAddress);
-  parcMemory_Deallocate((void **)&tcp);
-  *listenerPtr = NULL;
-}
-
-// ==================================================
-
-static const char *_tcpListener_ListenerName(const ListenerOps *ops) {
-  _TcpListener *tcp = (_TcpListener *)ops->context;
-  return tcp->listenerName;
-}
-
-static const char *_tcpListener_InterfaceName(const ListenerOps *ops) {
-  _TcpListener *tcp = (_TcpListener *)ops->context;
-  return tcp->interfaceName;
-}
-
-static void _tcpListener_Listen(int fd, struct sockaddr *sa, int socklen,
-                                void *tcpVoid) {
-  _TcpListener *tcp = (_TcpListener *)tcpVoid;
-
-  Address *remote;
-
-  switch (sa->sa_family) {
-    case AF_INET:
-      remote = addressCreateFromInet((struct sockaddr_in *)sa);
-      break;
-
-    case AF_INET6:
-      remote = addressCreateFromInet6((struct sockaddr_in6 *)sa);
-      break;
-
-    default:
-      parcTrapIllegalValue(sa, "Expected INET or INET6, got %d", sa->sa_family);
-      abort();
-  }
-
-  AddressPair *pair = addressPair_Create(tcp->localAddress, remote);
-
-  IoOperations *ops = streamConnection_AcceptConnection(
-      tcp->forwarder, fd, pair, tcp->isLocalAddressLocal);
-  Connection *conn = connection_Create(ops);
-
-  connectionTable_Add(forwarder_GetConnectionTable(tcp->forwarder), conn);
-
-  if (logger_IsLoggable(tcp->logger, LoggerFacility_IO, PARCLogLevel_Debug)) {
-    logger_Log(tcp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-               "TcpListener %p listen started", (void *)tcp);
-  }
-
-  addressDestroy(&remote);
-}
-
-static void _tcpListener_OpsDestroy(ListenerOps **listenerOpsPtr) {
-  ListenerOps *ops = *listenerOpsPtr;
-  _TcpListener *tcp = (_TcpListener *)ops->context;
-  _tcpListener_Destroy(&tcp);
-  parcMemory_Deallocate((void **)&ops);
-  *listenerOpsPtr = NULL;
-}
-
-static unsigned _tcpListener_OpsGetInterfaceIndex(const ListenerOps *ops) {
-  _TcpListener *tcp = (_TcpListener *)ops->context;
-  return tcp->id;
-}
-
-static const Address *_tcpListener_OpsGetListenAddress(const ListenerOps *ops) {
-  _TcpListener *tcp = (_TcpListener *)ops->context;
-  return tcp->localAddress;
-}
-
-static EncapType _tcpListener_OpsGetEncapType(const ListenerOps *ops) {
-  return ENCAP_TCP;
-}
diff --git a/hicn-light/src/hicn/io/tcpListener.h b/hicn-light/src/hicn/io/tcpListener.h
deleted file mode 100644
index a841738e5..000000000
--- a/hicn-light/src/hicn/io/tcpListener.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * 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 tcpListener.h
- * @brief Listens for in coming TCP connections
- *
- * This is the "server socket" of hicn-light for TCP connections.  The actual
- * I/O is handled by {@link StreamConnection}.
- *
- */
-
-#ifndef tcpListener_h
-#define tcpListener_h
-
-#ifndef _WIN32
-#include <netinet/in.h>
-#endif
-
-#include <hicn/core/forwarder.h>
-#include <hicn/io/listener.h>
-#include <stdlib.h>
-
-ListenerOps *tcpListener_CreateInet6(Forwarder *forwarder, char *listenerName,
-                                     struct sockaddr_in6 sin6, char *interfaceName);
-ListenerOps *tcpListener_CreateInet(Forwarder *forwarder, char *listenerName,
-                                    struct sockaddr_in sin, char *interfaceName);
-#endif  // tcpListener_h
diff --git a/hicn-light/src/hicn/io/tcpTunnel.c b/hicn-light/src/hicn/io/tcpTunnel.c
deleted file mode 100644
index 7a04a4222..000000000
--- a/hicn-light/src/hicn/io/tcpTunnel.c
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * 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 <errno.h>
-#include <hicn/hicn-light/config.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <parc/assert/parc_Assert.h>
-#include <hicn/io/streamConnection.h>
-#include <hicn/io/tcpListener.h>
-#include <hicn/io/tcpTunnel.h>
-
-IoOperations *tcpTunnel_Create(Forwarder *forwarder,
-                               const Address *localAddress,
-                               const Address *remoteAddress) {
-  IoOperations *ops = NULL;
-
-  address_type localType = addressGetType(localAddress);
-  address_type remoteType = addressGetType(remoteAddress);
-
-  if (localType == remoteType) {
-    AddressPair *pair = addressPair_Create(localAddress, remoteAddress);
-    bool isLocal = false;
-
-    ops = streamConnection_OpenConnection(forwarder, pair, isLocal);
-  }
-
-  return ops;
-}
diff --git a/hicn-light/src/hicn/io/tcpTunnel.h b/hicn-light/src/hicn/io/tcpTunnel.h
deleted file mode 100644
index d1d2a8524..000000000
--- a/hicn-light/src/hicn/io/tcpTunnel.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * 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 tcpTunnel.h
- * @brief Establish a tunnel to a remote system
- *
- */
-
-#ifndef tcpTunnel_h
-#define tcpTunnel_h
-
-#include <hicn/core/forwarder.h>
-#include <hicn/io/ioOperations.h>
-#include <hicn/io/listener.h>
-#include <hicn/utils/address.h>
-
-/**
- */
-// IoOperations *tcpTunnel_CreateOnListener(Forwarder *forwarder,
-//                                            ListenerOps *localListener,
-//                                            const Address *remoteAddress);
-
-/**
- */
-IoOperations *tcpTunnel_Create(Forwarder *forwarder,
-                               const Address *localAddress,
-                               const Address *remoteAddress);
-
-#endif  // tcpTunnel_h
diff --git a/hicn-light/src/hicn/io/udp.c b/hicn-light/src/hicn/io/udp.c
new file mode 100644
index 000000000..3301e2178
--- /dev/null
+++ b/hicn-light/src/hicn/io/udp.c
@@ -0,0 +1,566 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file udp.c
+ * #brief Implementation of the UDP face
+ *
+ * Old comment:
+ * - The Send() function may overflow the output buffer
+ *
+ */
+
+/* This has to be included early as other modules are including socket.h */
+
+#ifndef _WIN32
+#include <arpa/inet.h>
+#endif
+#include <errno.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef _WIN32
+#include <sys/uio.h>
+#include <unistd.h>
+#endif
+#include <sys/socket.h>
+
+#ifdef WITH_GSO
+#include <netinet/if_ether.h>  // ETH_DATA_LEN
+#include <linux/ipv6.h>        // struct ipv6hdr
+#include <netinet/udp.h>       // struct udphdr, SOL_UDP
+//#include <linux/udp.h> // UDP_GRO
+#define UDP_GRO 104
+#endif /* WITH_GSO */
+
+#include <hicn/util/log.h>
+#include <hicn/util/sstrncpy.h>
+
+#include "base.h"
+#include "../base/loop.h"
+#include "../base/ring.h"
+#include "../core/address_pair.h"
+#include "../core/connection.h"
+#include "../core/connection_vft.h"
+#include "../core/forwarder.h"
+#include "../core/listener.h"
+#include "../core/listener_vft.h"
+#include "../core/messageHandler.h"
+#include "../core/msgbuf.h"
+//#include "../hicn-light/config.h"
+
+// Batching based on recvmmsg is also generic
+// the difference is the handling of packet as in tcp we need to go through the
+// ring buffer first to do the framing, while in UDP this is already done
+//
+// each module should have a function to process a packet, then call a callback
+// in the forwarder again
+
+#define BATCH_SOCKET_BUFFER 512 * 1024 /* 256k */
+
+/******************************************************************************
+ * Listener
+ ******************************************************************************/
+
+typedef struct {
+  uint16_t port;  // in address ?
+} listener_udp_data_t;
+
+#ifdef __ANDROID__
+extern int bindSocket(int sock, const char *interface_name);
+#endif
+
+#if 0
+#include <arpa/inet.h>
+char *get_ip_str(const struct sockaddr *sa, char *s, size_t maxlen) {
+  switch (sa->sa_family) {
+    case AF_INET:
+      inet_ntop(AF_INET, &(((struct sockaddr_in *)sa)->sin_addr), s, maxlen);
+      break;
+
+    case AF_INET6:
+      inet_ntop(AF_INET6, &(((struct sockaddr_in6 *)sa)->sin6_addr), s, maxlen);
+      break;
+
+    default:
+      strncpy(s, "Unknown AF", maxlen);
+      return NULL;
+  }
+
+  return s;
+}
+#endif
+
+/* socket options */
+int socket_set_options(int fd) {
+#ifndef _WIN32
+  // Set non-blocking flag
+  int flags = fcntl(fd, F_GETFL, NULL);
+  if (flags < 0) {
+    perror("fcntl");
+    return -1;
+  }
+
+  if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
+    perror("fcntl");
+    return -1;
+  }
+#else
+  // Set non-blocking flag
+  int result = ioctlsocket(fd, FIONBIO, &(int){1});
+  if (result != NO_ERROR) {
+    perror("ioctlsocket");
+    return -1;
+  }
+#endif
+
+  // don't hang onto address after listener has closed
+  if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &(int){1}, sizeof(int)) < 0) {
+    perror("setsockopt");
+    return -1;
+  }
+
+#ifdef WITH_GSO
+  int gso_size = ETH_DATA_LEN - sizeof(struct ipv6hdr) - sizeof(struct udphdr);
+  if (setsockopt(fd, SOL_UDP, UDP_SEGMENT, &gso_size, sizeof(gso_size)) < 0) {
+    perror("setsockopt");
+    return -1;
+  }
+#endif /* WITH_GSO */
+
+#ifdef WITH_GRO
+  if (setsockopt(fd, IPPROTO_UDP, UDP_GRO, &(int){1}, sizeof(int)) < 0) {
+    perror("setsockopt");
+    return -1;
+  }
+#endif /* WITH_GRO */
+
+#ifdef WITH_ZEROCOPY
+  if (setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &(int){1}, sizeof(int))) {
+    perror("setsockopt");
+    return -1;
+  }
+#endif /* WITH_ZEROCOPY */
+
+  if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &(int){BATCH_SOCKET_BUFFER},
+                 sizeof(int)) < 0) {
+    perror("setsockopt");
+    return -1;
+  }
+  if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &(int){BATCH_SOCKET_BUFFER},
+                 sizeof(int)) < 0) {
+    perror("setsockopt");
+    return -1;
+  }
+  return 0;
+}
+
+#ifdef __linux__
+/* bind to device */
+int socket_bind_to_device(int fd, const char *interface_name) {
+  if (strncmp("lo", interface_name, 2) == 0) return 0;
+
+  if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, interface_name,
+                 strnlen_s(interface_name, IFNAMSIZ)) < 0) {
+    perror("setsockopt");
+    goto ERR_BIND_TO_DEVICE;
+  }
+
+  return 0;
+
+ERR_BIND_TO_DEVICE:
+#ifdef __ANDROID__
+  if (bindSocket(fd, interface_name) < 0) return -1;
+  return 0;
+#else
+  return -1;
+#endif /* __ANDROID__ */
+}
+#endif /* __linux__ */
+
+static int listener_udp_initialize(listener_t *listener) {
+  assert(listener);
+
+#if 0
+    listener_udp_data_t * data = listener->data;
+    assert(data);
+#endif
+  return 0;
+}
+
+static void listener_udp_finalize(listener_t *listener) {
+  assert(listener);
+  assert(listener->type == FACE_TYPE_UDP_LISTENER);
+
+  return;
+}
+
+static int listener_udp_punt(const listener_t *listener, const char *prefix_s) {
+  return -1;
+}
+
+static int listener_udp_get_socket(const listener_t *listener,
+                                   const address_t *local,
+                                   const address_t *remote,
+                                   const char *interface_name) {
+  int fd = socket(address_family(local), SOCK_DGRAM, 0);
+  if (fd < 0) goto ERR_SOCKET;
+
+  if (socket_set_options(fd) < 0) {
+    goto ERR;
+  }
+
+  if (bind(fd, address_sa(local), address_socklen(local)) < 0) {
+    perror("bind");
+    goto ERR;
+  }
+
+#ifdef __linux__
+  if (socket_bind_to_device(fd, interface_name) < 0) {
+    goto ERR;
+  }
+#endif /* __linux__ */
+
+  // DEBUG("UDP remote ?");
+  if (remote) {
+    // DEBUG("UDP connected socket ");
+    if (connect(fd, address_sa(remote), address_socklen(remote)) < 0) {
+      perror("connect");
+      goto ERR;
+    }
+  }
+
+  return fd;
+
+ERR:
+#ifndef _WIN32
+  close(fd);
+#else
+  closesocket(fd);
+#endif
+ERR_SOCKET:
+  return -1;
+}
+
+#define listener_udp_read_single io_read_single_socket
+
+#ifdef __linux__
+#define listener_udp_read_batch io_read_batch_socket
+#else
+#define listener_udp_read_batch NULL
+#endif /* __linux__ */
+
+DECLARE_LISTENER(udp);
+
+/******************************************************************************
+ * Connection
+ ******************************************************************************/
+
+#define RING_LEN 5 * MAX_MSG
+
+typedef struct {
+  /*
+   * Ring buffer
+   *
+   * This is sized to more than a batch to cope with transient failures of
+   * sendmmsg.
+   */
+  off_t *ring;
+
+#ifdef __linux__
+  struct mmsghdr msghdr[MAX_MSG];
+  struct iovec iovecs[MAX_MSG];
+#endif /* __linux__ */
+} connection_udp_data_t;
+
+static int connection_udp_initialize(connection_t *connection) {
+  assert(connection);
+  assert(connection->type == FACE_TYPE_UDP);
+  assert(connection->interface_name);
+
+#ifdef __linux__
+  connection_udp_data_t *data = connection->data;
+  assert(data);
+
+  ring_init(data->ring, RING_LEN);
+
+  void *name = NULL;
+  int namelen = 0;
+
+  /*
+   * If the connection does not use a connected socket, we need to set the
+   * different destination addresses
+   */
+  if (!connection->connected) {
+    const address_t *remote = connection_get_remote(connection);
+    name = address_sa(remote);
+    namelen = address_socklen(remote);
+  }
+
+  memset(data->msghdr, 0, MAX_MSG * sizeof(struct mmsghdr));
+  for (unsigned i = 0; i < MAX_MSG; i++) {
+    struct mmsghdr *msg = &data->msghdr[i];
+    *msg = (struct mmsghdr){
+        .msg_hdr =
+            {
+                .msg_iov = &data->iovecs[i],
+                .msg_iovlen = 1,
+                .msg_name = name,
+                .msg_namelen = namelen,
+#if 0
+                .msg_control = NULL,
+                .msg_controllen = 0,
+                .msg_flags = 0,
+#endif
+            },
+    };
+  }
+#endif /* __linux__ */
+
+  return 0;
+}
+
+static void connection_udp_finalize(connection_t *connection) {
+  assert(connection);
+  assert(connection->type == FACE_TYPE_UDP);
+
+  connection_udp_data_t *data = connection->data;
+  assert(data);
+
+  ring_free(data->ring);
+}
+
+static bool connection_udp_flush(const connection_t *connection) {
+#ifdef __linux__
+  int retry = 0;
+  off_t msgbuf_id = 0;
+  unsigned cpt;
+  size_t i;
+  int n;
+
+  assert(connection);
+  forwarder_t *forwarder = listener_get_forwarder(connection->listener);
+  msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(forwarder);
+  connection_udp_data_t *data = connection->data;
+  assert(data);
+
+  TRACE("[connection_udp_send] Flushing connection queue");
+
+  /* Flush operation */
+#ifdef WITH_ZEROCOPY
+  int flags = MSG_ZEROCOPY;
+#else
+  int flags = 0;
+#endif /* WITH_ZEROCOPY */
+
+SEND:
+  /* Consume up to MSG_MSG packets in ring buffer */
+  cpt = 0;
+
+  ring_enumerate_n(data->ring, i, &msgbuf_id, MAX_MSG, {
+    msgbuf_t *msgbuf = msgbuf_pool_at(msgbuf_pool, msgbuf_id);
+
+    // update path label
+    if (msgbuf_get_type(msgbuf) == MSGBUF_TYPE_DATA)
+      msgbuf_update_pathlabel(msgbuf, connection_get_id(connection));
+
+    data->iovecs[i].iov_base = msgbuf_get_packet(msgbuf);
+    data->iovecs[i].iov_len = msgbuf_get_len(msgbuf);
+    cpt++;
+  });
+
+SENDMMSG:
+  n = sendmmsg(connection->fd, data->msghdr, cpt, flags);
+  if (n == -1) {
+    /* man(2)sendmmsg / BUGS
+     *
+     * If an error occurs after at least one message has been sent, the call
+     * succeeds, and returns the number of messages sent.  The error code is
+     * lost.  The caller can retry the transmission, starting at the first
+     * failed message, but there is no guarantee that, if an error is
+     * returned, it will be the same as the one that was lost on the previous
+     * call.
+     */
+    WARN("sendmmsg failed %s", strerror(errno));
+    if (retry < 1) {
+      retry++;
+      goto SENDMMSG;
+    }
+    return false;
+  }
+
+  ring_advance(data->ring, n);
+
+  if (n < cpt) {
+    WARN("Unknown error after sending n=%d packets...", n);
+    if (retry < 1) {
+      retry++;
+      goto SEND;
+    }
+  }
+
+  if (ring_get_size(data->ring) > 0) {
+    retry = 0;
+    goto SEND;
+  }
+#endif /* __linux__ */
+  return true;
+}
+
+/**
+ * @function metisUdpConnection_Send
+ * @abstract Non-destructive send of the message.
+ * @discussion
+ *   sends a message to the peer.
+ *
+ * @param dummy is ignored.  A udp connection has only one peer.
+ * @return <#return#>
+ */
+static bool connection_udp_send(const connection_t *connection,
+                                msgbuf_t *msgbuf, bool queue) {
+  assert(connection);
+  assert(msgbuf);
+
+#ifdef __linux__
+  connection_udp_data_t *data = connection->data;
+  assert(data);
+
+  forwarder_t *forwarder = listener_get_forwarder(connection->listener);
+  msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(forwarder);
+
+  /* Queue packet ? */
+  if (queue) {
+    off_t msgbuf_id;
+    if (ring_is_full(data->ring)) connection_udp_flush(connection);
+
+    msgbuf_id = msgbuf_pool_get_id(msgbuf_pool, msgbuf);
+    ring_add(data->ring, &msgbuf_id);
+
+  } else {
+#endif /* __linux__ */
+    /* Send one */
+    // update the path label befor send the packet
+    if (msgbuf_get_type(msgbuf) == MSGBUF_TYPE_DATA)
+      msgbuf_update_pathlabel(msgbuf, connection_get_id(connection));
+
+    ssize_t writeLength = write(connection->fd, msgbuf_get_packet(msgbuf),
+                                msgbuf_get_len(msgbuf));
+
+    if (writeLength < 0) {
+      if (errno == EAGAIN || errno == EWOULDBLOCK) {
+        return false;
+      } else {
+        // this print is for debugging
+        printf("Incorrect write length %zd, expected %u: (%d) %s\n",
+               writeLength, msgbuf_get_len(msgbuf), errno, strerror(errno));
+        return false;
+      }
+    }
+#ifdef __linux__
+  }
+#endif /* __linux__ */
+
+  return true;
+}
+
+#if 0
+static
+bool
+connection_udp_sendv(const connection_t * connection, struct iovec * iov,
+        size_t size)
+{
+
+    assert(connetion);
+    assert(iov);
+
+    connection_udp_data_t * data = connection->data;
+    assert(data);
+
+#ifndef _WIN32
+    // Perform connect before to establish association between this peer and
+    // the remote peer. This is required to use writev.
+    // Connection association can be changed at any time.
+
+    if (writev(connection->fd, iov, (int)size) < 0)
+        return false;
+#else
+    WSABUF *buf = (WSABUF *) malloc(size * sizeof(WSABUF));
+
+    DWORD bytes_sent = 0;
+
+    for (int i = 0; i < size; i++) {
+        buf[i].buf = iov[i].iov_base;
+        buf[i].len = (ULONG)iov[i].iov_len;
+    }
+
+    int rc = WSASendTo(udp->fd, buf, size, &bytes_sent, 0,
+            (SOCKADDR *)address_sa(address_pair_remote(&udp->pair)),
+            address_socklen(address_pair_remote(&udp->pair)), NULL, NULL);
+    free(dataBuf);
+    if (rc == SOCKET_ERROR)
+        return false;
+#endif
+
+    return true;
+}
+#endif
+
+static int connection_udp_send_packet(const connection_t *connection,
+                                      const uint8_t *packet, size_t size) {
+  assert(connection);
+  assert(packet);
+
+  // XXX: in case of two connections this functions may have wrong behaviour. We
+  // noticed that the packet is sent by the forwarder on the right socket (fd)
+  // but from tcpdump we see that the packet goes on the other connection. In
+  // other cases the packet is sent twice, first on the wrong socket and later
+  // on the right one, even if we log a single send from the forwarder. The
+  // same behaviour was observed with the write executed in the function
+  // connection_udp_send with the queue flag set to false. A workaround that
+  // seems to solve the problem is to use connection_udp_send with queue = true
+  // and force the flush of the connection if needed.
+
+  // TODO: commented otherwise unable to do tests locally
+  // if(connection_is_local(connection))
+  //     return -1;
+
+#ifdef USE_CONNECTED_SOCKETS
+  ssize_t n = send(connection->fd, packet, size, 0);
+  if (n < 0) {
+    perror("sendto");
+    return -1;
+  }
+#else
+  const address_t *remote = connection_get_remote(connection);
+  ssize_t n = sendto(connection->fd, packet, size, 0, address_sa(remote),
+                     address_socklen(remote));
+  if (n < 0) return -1;
+#endif
+
+  return 0;
+}
+
+#define connection_udp_read_single \
+  listener_read_batch_socket listener_single_socket
+
+#ifdef __linux__
+#define connection_udp_read_batch listener_read_batch_socket
+#else
+#define connection_udp_read_batch NULL
+#endif /* __linux__ */
+
+DECLARE_CONNECTION(udp);
diff --git a/hicn-light/src/hicn/io/udpConnection.c b/hicn-light/src/hicn/io/udpConnection.c
deleted file mode 100644
index 2747b7ef4..000000000
--- a/hicn-light/src/hicn/io/udpConnection.c
+++ /dev/null
@@ -1,495 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * Embodies the reader/writer for a UDP connection
- *
- * NB The Send() function may overflow the output buffer
- *
- */
-
-#ifndef _WIN32
-#include <sys/uio.h>
-#endif
-#include <errno.h>
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <hicn/core/messageHandler.h>
-#include <hicn/io/udpConnection.h>
-
-#include <parc/algol/parc_Hash.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/core/connection.h>
-#include <hicn/core/forwarder.h>
-#include <hicn/core/message.h>
-
-typedef struct udp_state {
-  Forwarder *forwarder;
-  char * interfaceName;
-  Logger *logger;
-
-  // the udp listener socket we receive packets on
-  int udpListenerSocket;
-
-  AddressPair *addressPair;
-
-  // We need to access this all the time, so grab it out
-  // of the addressPair;
-  struct sockaddr *peerAddress;
-  socklen_t peerAddressLength;
-
-  bool isLocal;
-  bool isUp;
-  unsigned id;
-
-  unsigned delay;
-
-  /* This information would better be stored in the connection data structure
-   * but it is currently not reachable from within the implementation. */
-  connection_state_t state;
-  connection_state_t admin_state;
-#ifdef WITH_POLICY
-  uint32_t priority;
-#endif /* WITH_POLICY */
-} _UdpState;
-
-// Prototypes
-static bool _send(IoOperations *ops, const Address *nexthop, Message *message);
-static bool _sendIOVBuffer(IoOperations *ops, struct iovec *message,
-    size_t size);
-static const Address *_getRemoteAddress(const IoOperations *ops);
-static const AddressPair *_getAddressPair(const IoOperations *ops);
-static unsigned _getConnectionId(const IoOperations *ops);
-static bool _isUp(const IoOperations *ops);
-static bool _isLocal(const IoOperations *ops);
-static void _destroy(IoOperations **opsPtr);
-static list_connections_type _getConnectionType(const IoOperations *ops);
-static void _sendProbe(IoOperations *ops, uint8_t *message);
-static connection_state_t _getState(const IoOperations *ops);
-static void _setState(IoOperations *ops, connection_state_t state);
-static connection_state_t _getAdminState(const IoOperations *ops);
-static void _setAdminState(IoOperations *ops, connection_state_t admin_state);
-#ifdef WITH_POLICY
-static uint32_t _getPriority(const IoOperations *ops);
-static void _setPriority(IoOperations *ops, uint32_t priority);
-#endif /* WITH_POLICY */
-static const char * _getInterfaceName(const IoOperations *ops);
-
-/*
- * This assigns a unique pointer to the void * which we use
- * as a GUID for this class.
- */
-static const void *_IoOperationsGuid = __FILE__;
-
-/*
- * Return our GUID
- */
-static const void *_streamConnection_Class(const IoOperations *ops) {
-  return _IoOperationsGuid;
-}
-
-static IoOperations _template = {
-  .closure = NULL,
-  .send = &_send,
-  .sendIOVBuffer = &_sendIOVBuffer,
-  .getRemoteAddress = &_getRemoteAddress,
-  .getAddressPair = &_getAddressPair,
-  .getConnectionId = &_getConnectionId,
-  .isUp = &_isUp,
-  .isLocal = &_isLocal,
-  .destroy = &_destroy,
-  .class = &_streamConnection_Class,
-  .getConnectionType = &_getConnectionType,
-  .sendProbe = &_sendProbe,
-  .getState = &_getState,
-  .setState = &_setState,
-  .getAdminState = &_getAdminState,
-  .setAdminState = &_setAdminState,
-#ifdef WITH_POLICY
-  .getPriority = &_getPriority,
-  .setPriority = &_setPriority,
-#endif /* WITH_POLICY */
-  .getInterfaceName = &_getInterfaceName,
-};
-
-// =================================================================
-
-static void _setConnectionState(_UdpState *Udp, bool isUp);
-static bool _saveSockaddr(_UdpState *udpConnState, const AddressPair *pair);
-
-IoOperations *udpConnection_Create(Forwarder *forwarder, const char * interfaceName, int fd,
-                                   const AddressPair *pair, bool isLocal) {
-  IoOperations *io_ops = NULL;
-
-  _UdpState *udpConnState = parcMemory_AllocateAndClear(sizeof(_UdpState));
-  parcAssertNotNull(udpConnState,
-                    "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(_UdpState));
-
-  udpConnState->forwarder = forwarder;
-  udpConnState->interfaceName = strdup(interfaceName);
-  udpConnState->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-
-  bool saved = _saveSockaddr(udpConnState, pair);
-  if (saved) {
-    udpConnState->udpListenerSocket = fd;
-    udpConnState->id = forwarder_GetNextConnectionId(forwarder);
-    udpConnState->addressPair = addressPair_Acquire(pair);
-    udpConnState->isLocal = isLocal;
-
-    // allocate a connection
-    io_ops = parcMemory_AllocateAndClear(sizeof(IoOperations));
-    parcAssertNotNull(io_ops, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                      sizeof(IoOperations));
-    memcpy(io_ops, &_template, sizeof(IoOperations));
-    io_ops->closure = udpConnState;
-
-    _setConnectionState(udpConnState, true);
-
-#ifdef WITH_POLICY
-    udpConnState->priority = 0;
-#endif /* WITH_POLICY */
-
-    if (logger_IsLoggable(udpConnState->logger, LoggerFacility_IO,
-                          PARCLogLevel_Info)) {
-      char *str = addressPair_ToString(udpConnState->addressPair);
-      logger_Log(udpConnState->logger, LoggerFacility_IO, PARCLogLevel_Info,
-                 __func__,
-                 "UdpConnection %p created for address %s (isLocal %d)",
-                 (void *)udpConnState, str, udpConnState->isLocal);
-      free(str);
-    }
-
-    messenger_Send(
-        forwarder_GetMessenger(forwarder),
-        missive_Create(MissiveType_ConnectionCreate, udpConnState->id));
-    messenger_Send(forwarder_GetMessenger(forwarder),
-                   missive_Create(MissiveType_ConnectionUp, udpConnState->id));
-  } else {
-    // _saveSockaddr will already log an error, no need for extra log message
-    // here
-    logger_Release(&udpConnState->logger);
-
-    free(udpConnState->interfaceName);
-    parcMemory_Deallocate((void **)&udpConnState);
-  }
-
-  return io_ops;
-}
-
-// =================================================================
-// I/O Operations implementation
-
-static void _destroy(IoOperations **opsPtr) {
-  parcAssertNotNull(opsPtr, "Parameter opsPtr must be non-null double pointer");
-  parcAssertNotNull(*opsPtr,
-                    "Parameter opsPtr must dereference to non-null pointer");
-
-  IoOperations *ops = *opsPtr;
-  parcAssertNotNull(ioOperations_GetClosure(ops),
-                    "ops->context must not be null");
-
-  _UdpState *udpConnState = (_UdpState *)ioOperations_GetClosure(ops);
-  addressPair_Release(&udpConnState->addressPair);
-  parcMemory_Deallocate((void **)&(udpConnState->peerAddress));
-
-  messenger_Send(
-      forwarder_GetMessenger(udpConnState->forwarder),
-      missive_Create(MissiveType_ConnectionDestroyed, udpConnState->id));
-
-  if (logger_IsLoggable(udpConnState->logger, LoggerFacility_IO,
-                        PARCLogLevel_Info)) {
-    logger_Log(udpConnState->logger, LoggerFacility_IO, PARCLogLevel_Info,
-               __func__, "UdpConnection %p destroyed", (void *)udpConnState);
-  }
-
-  // do not close udp->udpListenerSocket, the listener will close
-  // that when its done
-
-  logger_Release(&udpConnState->logger);
-  free(udpConnState->interfaceName);
-  parcMemory_Deallocate((void **)&udpConnState);
-  parcMemory_Deallocate((void **)&ops);
-
-  *opsPtr = NULL;
-}
-
-static bool _isUp(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _UdpState *udpConnState =
-      (const _UdpState *)ioOperations_GetClosure(ops);
-  return udpConnState->isUp;
-}
-
-static bool _isLocal(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _UdpState *udpConnState =
-      (const _UdpState *)ioOperations_GetClosure(ops);
-  return udpConnState->isLocal;
-}
-
-static const Address *_getRemoteAddress(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _UdpState *udpConnState =
-      (const _UdpState *)ioOperations_GetClosure(ops);
-  return addressPair_GetRemote(udpConnState->addressPair);
-}
-
-static const AddressPair *_getAddressPair(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _UdpState *udpConnState =
-      (const _UdpState *)ioOperations_GetClosure(ops);
-  return udpConnState->addressPair;
-}
-
-static unsigned _getConnectionId(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _UdpState *udpConnState =
-      (const _UdpState *)ioOperations_GetClosure(ops);
-  return udpConnState->id;
-}
-
-/**
- * @function metisUdpConnection_Send
- * @abstract Non-destructive send of the message.
- * @discussion
- *   sends a message to the peer.
- *
- * @param dummy is ignored.  A udp connection has only one peer.
- * @return <#return#>
- */
-static bool _send(IoOperations *ops, const Address *dummy, Message *message) {
-  parcAssertNotNull(ops, "Parameter ops must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
-  _UdpState *udpConnState = (_UdpState *)ioOperations_GetClosure(ops);
-
-  // NAT for HICN
-  // in this particular connection we don't need natting beacause we send the
-  // packet to the next hop using upd connection
-
-  ssize_t writeLength =
-      sendto(udpConnState->udpListenerSocket, message_FixedHeader(message),
-             (int)message_Length(message), 0, udpConnState->peerAddress,
-             udpConnState->peerAddressLength);
-
-  if (writeLength < 0) {
-    if (errno == EAGAIN || errno == EWOULDBLOCK) {
-      return false;
-    } else {
-      // this print is for debugging
-      printf("Incorrect write length %zd, expected %zd: (%d) %s\n", writeLength,
-             message_Length(message), errno, strerror(errno));
-      return false;
-    }
-  }
-
-  return true;
-}
-
-static bool _sendIOVBuffer(IoOperations *ops, struct iovec *message,
-    size_t size) {
-  parcAssertNotNull(ops, "Parameter ops must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
-  _UdpState *udpConnState = (_UdpState *)ioOperations_GetClosure(ops);
-
-#ifndef _WIN32
-  // Perform connect before to establish association between this peer and
-  // the remote peer. This is required to use writev.
-  // Connection association can be changed at any time.
-  connect(udpConnState->udpListenerSocket,
-          udpConnState->peerAddress,
-          udpConnState->peerAddressLength);
-
-  ssize_t writeLength = writev(udpConnState->udpListenerSocket, message, (int)size);
-
-  struct sockaddr any_address = {0};
-  any_address.sa_family = AF_UNSPEC;
-  connect(udpConnState->udpListenerSocket,
-          &any_address, (socklen_t)sizeof(any_address));
-
-  if (writeLength < 0) {
-      return false;
-  }
-#else
-
-  WSABUF *dataBuf = (WSABUF *) malloc(size * sizeof (dataBuf));
-  DWORD BytesSent = 0;
-
-  for (int i = 0; i < size; i++) {
-    dataBuf[i].buf = message[i].iov_base;
-    dataBuf[i].len = (ULONG)message[i].iov_len;
-  }
-
-  int rc = WSASendTo(udpConnState->udpListenerSocket, dataBuf, (DWORD)size,
-    &BytesSent, 0, (SOCKADDR *)udpConnState->peerAddress,
-    udpConnState->peerAddressLength, NULL, NULL);
-  free(dataBuf);
-  if (rc == SOCKET_ERROR) {
-    return false;
-  }
-#endif
-  return true;
-}
-
-static list_connections_type _getConnectionType(const IoOperations *ops) {
-  return CONN_UDP;
-}
-
-static void _sendProbe(IoOperations *ops, uint8_t *message) {
-  parcAssertNotNull(ops, "Parameter ops must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
-  _UdpState *udpConnState = (_UdpState *)ioOperations_GetClosure(ops);
-
-  if(udpConnState->isLocal)
-    return;
-
-  ssize_t writeLength =
-    sendto(udpConnState->udpListenerSocket, message,
-             messageHandler_GetTotalPacketLength(message), 0, udpConnState->peerAddress,
-             udpConnState->peerAddressLength);
-
-  if (writeLength < 0) {
-     return;
-  }
-}
-
-// =================================================================
-// Internal API
-
-static bool _saveSockaddr(_UdpState *udpConnState, const AddressPair *pair) {
-  bool success = false;
-  const Address *remoteAddress = addressPair_GetRemote(pair);
-
-  switch (addressGetType(remoteAddress)) {
-    case ADDR_INET: {
-      size_t bytes = sizeof(struct sockaddr_in);
-      udpConnState->peerAddress = parcMemory_Allocate(bytes);
-      parcAssertNotNull(udpConnState->peerAddress,
-                        "parcMemory_Allocate(%zu) returned NULL", bytes);
-
-      addressGetInet(remoteAddress,
-                     (struct sockaddr_in *)udpConnState->peerAddress);
-      udpConnState->peerAddressLength = (socklen_t)bytes;
-
-      success = true;
-      break;
-    }
-
-    case ADDR_INET6: {
-      size_t bytes = sizeof(struct sockaddr_in6);
-      udpConnState->peerAddress = parcMemory_Allocate(bytes);
-      parcAssertNotNull(udpConnState->peerAddress,
-                        "parcMemory_Allocate(%zu) returned NULL", bytes);
-
-      addressGetInet6(remoteAddress,
-                      (struct sockaddr_in6 *)udpConnState->peerAddress);
-      udpConnState->peerAddressLength = (socklen_t)bytes;
-
-      success = true;
-      break;
-    }
-
-    default:
-      if (logger_IsLoggable(udpConnState->logger, LoggerFacility_IO,
-                            PARCLogLevel_Error)) {
-        char *str = addressToString(remoteAddress);
-        logger_Log(udpConnState->logger, LoggerFacility_IO, PARCLogLevel_Error,
-                   __func__, "Remote address is not INET or INET6: %s", str);
-        parcMemory_Deallocate((void **)&str);
-      }
-      break;
-  }
-  return success;
-}
-
-static void _setConnectionState(_UdpState *udpConnState, bool isUp) {
-  parcAssertNotNull(udpConnState, "Parameter Udp must be non-null");
-
-  Messenger *messenger = forwarder_GetMessenger(udpConnState->forwarder);
-
-  bool oldStateIsUp = udpConnState->isUp;
-  udpConnState->isUp = isUp;
-
-  if (oldStateIsUp && !isUp) {
-    // bring connection DOWN
-    Missive *missive =
-        missive_Create(MissiveType_ConnectionDown, udpConnState->id);
-    messenger_Send(messenger, missive);
-    return;
-  }
-
-  if (!oldStateIsUp && isUp) {
-    // bring connection UP
-    Missive *missive =
-        missive_Create(MissiveType_ConnectionUp, udpConnState->id);
-    messenger_Send(messenger, missive);
-    return;
-  }
-}
-
-static connection_state_t _getState(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _UdpState *udpConnState =
-      (const _UdpState *)ioOperations_GetClosure(ops);
-  return udpConnState->state;
-}
-
-static void _setState(IoOperations *ops, connection_state_t state) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  _UdpState *udpConnState =
-      (_UdpState *)ioOperations_GetClosure(ops);
-  udpConnState->state = state;
-}
-
-static connection_state_t _getAdminState(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _UdpState *udpConnState =
-      (const _UdpState *)ioOperations_GetClosure(ops);
-  return udpConnState->admin_state;
-}
-
-static void _setAdminState(IoOperations *ops, connection_state_t admin_state) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  _UdpState *udpConnState =
-      (_UdpState *)ioOperations_GetClosure(ops);
-  udpConnState->admin_state = admin_state;
-}
-
-#ifdef WITH_POLICY
-static uint32_t _getPriority(const IoOperations *ops) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  const _UdpState *udpConnState =
-      (const _UdpState *)ioOperations_GetClosure(ops);
-  return udpConnState->priority;
-}
-
-static void _setPriority(IoOperations *ops, uint32_t priority) {
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  _UdpState *udpConnState =
-      (_UdpState *)ioOperations_GetClosure(ops);
-  udpConnState->priority = priority;
-}
-#endif /* WITH_POLICY */
-
-static const char * _getInterfaceName(const IoOperations *ops)
-{
-  parcAssertNotNull(ops, "Parameter must be non-null");
-  _UdpState *udpConnState =
-      (_UdpState *)ioOperations_GetClosure(ops);
-  return udpConnState->interfaceName;
-}
diff --git a/hicn-light/src/hicn/io/udpConnection.h b/hicn-light/src/hicn/io/udpConnection.h
deleted file mode 100644
index 9fbc5348b..000000000
--- a/hicn-light/src/hicn/io/udpConnection.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * 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 udpConnection.h
- * @brief Represents a UDP connection (socket) for the connection table
- *
- * <#Detailed Description#>
- *
- */
-
-#ifndef udpConnection_h
-#define udpConnection_h
-
-#include <hicn/core/forwarder.h>
-#include <hicn/io/addressPair.h>
-#include <hicn/io/ioOperations.h>
-#include <hicn/utils/address.h>
-
-/**
- * Creates a UDP connection that can send to the remote address
- *
- * The address pair must both be same type (i.e. INET or INET6).
- *
- * @param [in] metis An allocated MetisForwarder (saves reference)
- * @param [in] fd The socket to use
- * @param [in] pair An allocated address pair for the connection (saves
- * reference)
- * @param [in] isLocal determines if the remote address is on the current system
- *
- * @retval non-null An allocated Io operations
- * @retval null An error
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-IoOperations *udpConnection_Create(Forwarder *forwarder, const char * interfaceName, int fd,
-                                   const AddressPair *pair, bool isLocal);
-#endif  // udpConnection_h
diff --git a/hicn-light/src/hicn/io/udpListener.c b/hicn-light/src/hicn/io/udpListener.c
deleted file mode 100644
index 3b318c500..000000000
--- a/hicn-light/src/hicn/io/udpListener.c
+++ /dev/null
@@ -1,653 +0,0 @@
-/*
- * 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 _WIN32
-#include <arpa/inet.h>
-#include <unistd.h>
-#endif
-#include <errno.h>
-#include <fcntl.h>
-#include <hicn/hicn-light/config.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <hicn/core/messageHandler.h>
-
-#include <hicn/io/udpConnection.h>
-#include <hicn/io/udpListener.h>
-
-#include <parc/algol/parc_Network.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/core/connection.h>
-#include <hicn/core/forwarder.h>
-#include <hicn/core/messagePacketType.h>
-
-#define IPv4 4
-#define IPv6 6
-
-struct udp_listener {
-  char *listenerName;
-  Forwarder *forwarder;
-  Logger *logger;
-
-  PARCEvent *udp_event;
-  SocketType udp_socket;
-  uint16_t port;
-
-  unsigned id;
-  char *interfaceName;
-  Address *localAddress;
-};
-
-static void _destroy(ListenerOps **listenerOpsPtr);
-static const char *_getListenerName(const ListenerOps *ops);
-static unsigned _getInterfaceIndex(const ListenerOps *ops);
-static const Address *_getListenAddress(const ListenerOps *ops);
-static EncapType _getEncapType(const ListenerOps *ops);
-static const char *_getInterfaceName(const ListenerOps *ops);
-static int _getSocket(const ListenerOps *ops);
-static unsigned _createNewConnection(ListenerOps *listener, int fd, const AddressPair *pair);
-static const Connection * _lookupConnection(ListenerOps * listener, const AddressPair *pair);
-
-static ListenerOps udpTemplate = {
-  .context = NULL,
-  .destroy = &_destroy,
-  .getInterfaceIndex = &_getInterfaceIndex,
-  .getListenAddress = &_getListenAddress,
-  .getEncapType = &_getEncapType,
-  .getSocket = &_getSocket,
-  .getListenerName = &_getListenerName,
-  .createConnection = &_createNewConnection,
-  .lookupConnection = &_lookupConnection,
-  .getInterfaceName = &_getInterfaceName,
-};
-
-
-static void _readcb(int fd, PARCEventType what, void * listener_void);
-
-#ifdef __ANDROID__
-extern int bindSocket(int sock, const char* ifname);
-#endif
-
-ListenerOps *udpListener_CreateInet6(Forwarder *forwarder, char *listenerName,
-                                     struct sockaddr_in6 sin6, const char *interfaceName) {
-  ListenerOps *ops = NULL;
-
-  UdpListener *udp = parcMemory_AllocateAndClear(sizeof(UdpListener));
-  parcAssertNotNull(udp, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(UdpListener));
-  udp->forwarder = forwarder;
-  udp->listenerName = parcMemory_StringDuplicate(listenerName, strlen(listenerName));
-  udp->interfaceName = parcMemory_StringDuplicate(interfaceName, strlen(interfaceName));
-  udp->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-  udp->localAddress = addressCreateFromInet6(&sin6);
-  udp->id = forwarder_GetNextConnectionId(forwarder);
-
-  udp->udp_socket = (SocketType)socket(AF_INET6, SOCK_DGRAM, 0);
-  parcAssertFalse(udp->udp_socket < 0, "Error opening UDP socket: (%d) %s",
-                  errno, strerror(errno));
-
-  int failure = 0;
-#ifndef _WIN32
-  // Set non-blocking flag
-  int flags = fcntl(udp->udp_socket, F_GETFL, NULL);
-  parcAssertTrue(flags != -1,
-                 "fcntl failed to obtain file descriptor flags (%d)", errno);
-  failure = fcntl(udp->udp_socket, F_SETFL, flags | O_NONBLOCK);
-  parcAssertFalse(failure, "fcntl failed to set file descriptor flags (%d)",
-                  errno);
-#else
-  // Set non-blocking flag
-  u_long mode = 1;
-  int result = ioctlsocket(udp->udp_socket, FIONBIO, &mode);
-  if (result != NO_ERROR) {
-    parcAssertTrue(result != NO_ERROR,
-                   "ioctlsocket failed to set file descriptor");
-  }
-#endif
-
-  int one = 1;
-  // don't hang onto address after listener has closed
-  failure = setsockopt(udp->udp_socket, SOL_SOCKET, SO_REUSEADDR, (void *)&one,
-                       (socklen_t)sizeof(one));
-  parcAssertFalse(failure, "failed to set REUSEADDR on socket(%d)", errno);
-
-  failure = bind(udp->udp_socket, (struct sockaddr *)&sin6, sizeof(sin6));
-
-  if (failure == 0) {
-#ifdef __linux__
-    if (strncmp("lo", interfaceName, 2) != 0) {
-      int ret = setsockopt(udp->udp_socket, SOL_SOCKET, SO_BINDTODEVICE,
-                       interfaceName, strlen(interfaceName) + 1);
-      if (ret < 0) {
-        logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-                   "setsockopt(%d, SO_BINDTODEVICE, %s) failed (%d) %s",
-                   udp->udp_socket, interfaceName, errno, strerror(errno));
-#ifdef __ANDROID__
-        ret = bindSocket(udp->udp_socket, interfaceName);
-        if (ret < 0) {
-          logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-                   "bindSocket(%d, %s) failed", udp->udp_socket, interfaceName);
-          close(udp->udp_socket);
-          addressDestroy(&udp->localAddress);
-          logger_Release(&udp->logger);
-          parcMemory_Deallocate((void **)&udp);
-          return NULL;
-        } else {
-          logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-                   "bindSocket(%d, %s) success", udp->udp_socket, interfaceName);
-        }
-#else
-        close(udp->udp_socket);
-        addressDestroy(&udp->localAddress);
-        logger_Release(&udp->logger);
-        parcMemory_Deallocate((void **)&udp);
-        return NULL;
-#endif
-      }
-    }
-#endif
-
-    ops = parcMemory_AllocateAndClear(sizeof(ListenerOps));
-    parcAssertNotNull(ops, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                      sizeof(ListenerOps));
-    memcpy(ops, &udpTemplate, sizeof(ListenerOps));
-    ops->context = udp;
-
-    udp->udp_event =
-        dispatcher_CreateNetworkEvent(forwarder_GetDispatcher(forwarder), true,
-                                      _readcb, (void*)ops, udp->udp_socket);
-    dispatcher_StartNetworkEvent(forwarder_GetDispatcher(forwarder),
-                                 udp->udp_event);
-
-    if (logger_IsLoggable(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug)) {
-      char *str = addressToString(udp->localAddress);
-      logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-                 "UdpListener %p created for address %s", (void *)udp, str);
-      parcMemory_Deallocate((void **)&str);
-    }
-  } else {
-    if (logger_IsLoggable(udp->logger, LoggerFacility_IO, PARCLogLevel_Error)) {
-      int myerrno = errno;
-      char *str = addressToString(udp->localAddress);
-      logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Error, __func__,
-                 "Error binding UDP socket to address %s: (%d) %s", str,
-                 myerrno, strerror(myerrno));
-      parcMemory_Deallocate((void **)&str);
-    }
-    parcMemory_Deallocate((void **)&udp->listenerName);
-    parcMemory_Deallocate((void **)&udp->interfaceName);
-#ifndef _WIN32
-    close(udp->udp_socket);
-#else
-    closesocket(udp->udp_socket);
-#endif
-    addressDestroy(&udp->localAddress);
-    logger_Release(&udp->logger);
-    parcMemory_Deallocate((void **)&udp);
-  }
-
-  return ops;
-}
-
-ListenerOps *udpListener_CreateInet(Forwarder *forwarder, char *listenerName,
-                                    struct sockaddr_in sin, const char *interfaceName) {
-  ListenerOps *ops = NULL;
-
-  UdpListener *udp = parcMemory_AllocateAndClear(sizeof(UdpListener));
-  parcAssertNotNull(udp, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(UdpListener));
-  udp->forwarder = forwarder;
-  udp->listenerName = parcMemory_StringDuplicate(listenerName, strlen(listenerName));
-  udp->interfaceName = parcMemory_StringDuplicate(interfaceName, strlen(interfaceName));
-  udp->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-  udp->localAddress = addressCreateFromInet(&sin);
-  udp->id = forwarder_GetNextConnectionId(forwarder);
-
-  udp->udp_socket = (SocketType)socket(AF_INET, SOCK_DGRAM, 0);
-  parcAssertFalse(udp->udp_socket < 0, "Error opening UDP socket: (%d) %s",
-                  errno, strerror(errno));
-
-  int failure = 0;
-#ifndef _WIN32
-  // Set non-blocking flag
-  int flags = fcntl(udp->udp_socket, F_GETFL, NULL);
-  parcAssertTrue(flags != -1,
-                 "fcntl failed to obtain file descriptor flags (%d)", errno);
-  failure = fcntl(udp->udp_socket, F_SETFL, flags | O_NONBLOCK);
-  parcAssertFalse(failure, "fcntl failed to set file descriptor flags (%d)",
-                  errno);
-#else
-  u_long mode = 1;
-  int result = ioctlsocket(udp->udp_socket, FIONBIO, &mode);
-  if (result != NO_ERROR) {
-    parcAssertTrue(result != NO_ERROR,
-                   "ioctlsocket failed to set file descriptor");
-  }
-#endif
-
-  int one = 1;
-  // don't hang onto address after listener has closed
-  failure = setsockopt(udp->udp_socket, SOL_SOCKET, SO_REUSEADDR, (void *)&one,
-                       (socklen_t)sizeof(one));
-  parcAssertFalse(failure, "failed to set REUSEADDR on socket(%d)", errno);
-
-  failure = bind(udp->udp_socket, (struct sockaddr *)&sin, sizeof(sin));
-  if (failure == 0) {
-#ifdef __linux__
-    if (strncmp("lo", interfaceName, 2) != 0) { 
-      int ret = setsockopt(udp->udp_socket, SOL_SOCKET, SO_BINDTODEVICE,
-                       interfaceName, strlen(interfaceName) + 1);
-      if (ret < 0) {
-        logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-                   "setsockopt(%d, SO_BINDTODEVICE, %s) failed (%d) %s",
-                   udp->udp_socket, interfaceName, errno, strerror(errno));
-#ifdef __ANDROID__
-        ret = bindSocket(udp->udp_socket, interfaceName);
-        if (ret < 0) {
-          logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-                   "bindSocket(%d, %s) failed", udp->udp_socket, interfaceName);
-          close(udp->udp_socket);
-          addressDestroy(&udp->localAddress);
-          logger_Release(&udp->logger);
-          parcMemory_Deallocate((void **)&udp);
-          return NULL;
-        } else {
-          logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-                   "bindSocket(%d, %s) success", udp->udp_socket, interfaceName);
-        }
-#else
-        close(udp->udp_socket);
-        addressDestroy(&udp->localAddress);
-        logger_Release(&udp->logger);
-        parcMemory_Deallocate((void **)&udp);
-        return NULL;
-#endif
-      }
-    }
-#endif
-    ops = parcMemory_AllocateAndClear(sizeof(ListenerOps));
-    parcAssertNotNull(ops, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                      sizeof(ListenerOps));
-    memcpy(ops, &udpTemplate, sizeof(ListenerOps));
-    ops->context = udp;
-
-    udp->udp_event =
-        dispatcher_CreateNetworkEvent(forwarder_GetDispatcher(forwarder), true,
-                                      _readcb, (void *)ops, udp->udp_socket);
-    dispatcher_StartNetworkEvent(forwarder_GetDispatcher(forwarder),
-                                 udp->udp_event);
-
-
-    if (logger_IsLoggable(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug)) {
-      char *str = addressToString(udp->localAddress);
-      logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-                 "UdpListener %p created for address %s", (void *)udp, str);
-      parcMemory_Deallocate((void **)&str);
-    }
-  } else {
-    if (logger_IsLoggable(udp->logger, LoggerFacility_IO, PARCLogLevel_Error)) {
-      int myerrno = errno;
-      char *str = addressToString(udp->localAddress);
-      logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Error, __func__,
-                 "Error binding UDP socket to address %s: (%d) %s", str,
-                 myerrno, strerror(myerrno));
-      parcMemory_Deallocate((void **)&str);
-    }
-    parcMemory_Deallocate((void **)&udp->listenerName);
-    parcMemory_Deallocate((void **)&udp->interfaceName);
-#ifndef _WIN32
-    close(udp->udp_socket);
-#else
-    closesocket(udp->udp_socket);
-#endif
-    addressDestroy(&udp->localAddress);
-    logger_Release(&udp->logger);
-    parcMemory_Deallocate((void **)&udp);
-  }
-
-  return ops;
-}
-
-static void udpListener_Destroy(UdpListener **listenerPtr) {
-  parcAssertNotNull(listenerPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*listenerPtr,
-                    "Parameter must derefernce to non-null pointer");
-
-  UdpListener *udp = *listenerPtr;
-
-  if (logger_IsLoggable(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug)) {
-    logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-               "UdpListener %p destroyed", (void *)udp);
-  }
-
-  parcMemory_Deallocate((void **)&udp->listenerName);
-  parcMemory_Deallocate((void **)&udp->interfaceName);
-#ifndef _WIN32
-  close(udp->udp_socket);
-#else
-  closesocket(udp->udp_socket);
-#endif
-
-  addressDestroy(&udp->localAddress);
-  dispatcher_DestroyNetworkEvent(forwarder_GetDispatcher(udp->forwarder),
-                                 &udp->udp_event);
-  logger_Release(&udp->logger);
-  parcMemory_Deallocate((void **)&udp);
-  *listenerPtr = NULL;
-}
-
-static const char *_getListenerName(const ListenerOps *ops) {
-  UdpListener *udp = (UdpListener *)ops->context;
-  return udp->listenerName;
-}
-
-static const char *_getInterfaceName(const ListenerOps *ops) {
-  UdpListener *udp = (UdpListener *)ops->context;
-  return udp->interfaceName;
-}
-
-static void _destroy(ListenerOps **listenerOpsPtr) {
-  ListenerOps *ops = *listenerOpsPtr;
-  UdpListener *udp = (UdpListener *)ops->context;
-  udpListener_Destroy(&udp);
-  parcMemory_Deallocate((void **)&ops);
-  *listenerOpsPtr = NULL;
-}
-
-static unsigned _getInterfaceIndex(const ListenerOps *ops) {
-  UdpListener *udp = (UdpListener *)ops->context;
-  return udp->id;
-}
-
-static const Address *_getListenAddress(const ListenerOps *ops) {
-  UdpListener *udp = (UdpListener *)ops->context;
-  return udp->localAddress;
-}
-
-static EncapType _getEncapType(const ListenerOps *ops) { return ENCAP_UDP; }
-
-static int _getSocket(const ListenerOps *ops) {
-  UdpListener *udp = (UdpListener *)ops->context;
-  return (int)udp->udp_socket;
-}
-
-// =====================================================================
-
-/**
- * @function _constructAddressPair
- * @abstract Creates the address pair that uniquely identifies the connection
- * @discussion
- *   The peerIpAddress must be of AF_INET or AF_INET6 family.
- *
- * @param <#param1#>
- * @return Allocated MetisAddressPair, must be destroyed
- */
-static AddressPair *_constructAddressPair(UdpListener *udp,
-                                          struct sockaddr *peerIpAddress,
-                                          socklen_t peerIpAddressLength) {
-  Address *remoteAddress;
-
-  switch (peerIpAddress->sa_family) {
-    case AF_INET:
-      remoteAddress =
-          addressCreateFromInet((struct sockaddr_in *)peerIpAddress);
-      break;
-
-    case AF_INET6:
-      remoteAddress =
-          addressCreateFromInet6((struct sockaddr_in6 *)peerIpAddress);
-      break;
-
-    default:
-      parcTrapIllegalValue(peerIpAddress,
-                           "Peer address unrecognized family for IP: %d",
-                           peerIpAddress->sa_family);
-  }
-
-  AddressPair *pair = addressPair_Create(udp->localAddress, remoteAddress);
-  addressDestroy(&remoteAddress);
-
-  return pair;
-}
-
-static const Connection * _lookupConnection(ListenerOps * listener,
-                                const AddressPair *pair) {
-  UdpListener * udp = (UdpListener *)listener->context;
-  ConnectionTable *connTable = forwarder_GetConnectionTable(udp->forwarder);
-  return connectionTable_FindByAddressPair(connTable, pair);
-
-}
-
-/**
- * @function _createNewConnection
- * @abstract Creates a new Metis connection for the peer
- * @discussion
- *   PRECONDITION: you know there's not an existing connection with the address
- * pair
- *
- *   Creates a new connection and adds it to the connection table.
- *
- * @param <#param1#>
- * @return The connection id for the new connection
- */
-
-static unsigned _createNewConnection(ListenerOps * listener, int fd,
-                                     const AddressPair *pair) {
-  UdpListener * udp = (UdpListener *)listener->context;
-
-  //check it the connection is local
-  bool isLocal = false;
-  const Address *localAddress = addressPair_GetLocal(pair);
-  if(addressGetType(localAddress) == ADDR_INET){
-    struct sockaddr_in tmpAddr;
-    addressGetInet(localAddress, &tmpAddr);
-    if(parcNetwork_IsSocketLocal((struct sockaddr *)&tmpAddr))
-      isLocal = true;
-  }else{
-    struct sockaddr_in6 tmpAddr6;
-    addressGetInet6(localAddress, &tmpAddr6);
-    if(parcNetwork_IsSocketLocal((struct sockaddr *)&tmpAddr6))
-      isLocal = true;
-  }
-
-  // metisUdpConnection_Create takes ownership of the pair
-  IoOperations *ops = udpConnection_Create(udp->forwarder, udp->interfaceName, fd, pair, isLocal);
-  Connection *conn = connection_Create(ops);
-  // connection_AllowWldrAutoStart(conn);
-
-  connectionTable_Add(forwarder_GetConnectionTable(udp->forwarder), conn);
-  unsigned connid = ioOperations_GetConnectionId(ops);
-
-  return connid;
-}
-
-static void _handleWldrNotification(UdpListener *udp, unsigned connId,
-                                    uint8_t *msgBuffer) {
-  const Connection *conn = connectionTable_FindById(
-      forwarder_GetConnectionTable(udp->forwarder), connId);
-  if (conn == NULL) {
-    parcMemory_Deallocate((void **)&msgBuffer);
-    return;
-  }
-
-  Message *message = message_CreateFromByteArray(
-      connId, msgBuffer, MessagePacketType_WldrNotification,
-      forwarder_GetTicks(udp->forwarder), forwarder_GetLogger(udp->forwarder));
-
-  connection_HandleWldrNotification((Connection *)conn, message);
-
-  message_Release(&message);
-}
-
-static Message *_readMessage(ListenerOps * listener, int fd,
-                      AddressPair *pair, uint8_t * packet, bool * processed) {
-  UdpListener * udp = (UdpListener *)listener->context;
-
-  Message *message = NULL;
-
-  unsigned connid;
-  bool foundConnection;
-
-  const Connection *conn = _lookupConnection(listener, pair);
-  if (conn) {
-    connid = connection_GetConnectionId(conn);
-    foundConnection = true;
-  } else {
-    connid = 0;
-    foundConnection = false;
-  }
-
-  if (messageHandler_IsTCP(packet)) {
-    *processed = true;
-    MessagePacketType pktType;
-
-    if (messageHandler_IsData(packet)) {
-      pktType = MessagePacketType_ContentObject;
-      if (!foundConnection) {
-        parcMemory_Deallocate((void **)&packet);
-        return message;
-      }
-    } else if (messageHandler_IsInterest(packet)) {
-      pktType = MessagePacketType_Interest;
-      if (!foundConnection) {
-        connid = _createNewConnection(listener, fd, pair);
-      }
-    } else {
-      printf("Got a packet that is not a data nor an interest, drop it!\n");
-      parcMemory_Deallocate((void **)&packet);
-      return message;
-    }
-
-    message = message_CreateFromByteArray(
-        connid, packet, pktType, forwarder_GetTicks(udp->forwarder),
-        forwarder_GetLogger(udp->forwarder));
-
-    if (message == NULL) {
-      parcMemory_Deallocate((void **)&packet);
-    }
-  } else if (messageHandler_IsWldrNotification(packet)) {
-    *processed = true;
-    _handleWldrNotification(udp, connid, packet);
-  } else {
-
-    *processed = messageHandler_handleHooks(udp->forwarder, packet, listener, fd, pair);
-  }
-
-  return message;
-}
-
-static void _readCommand(ListenerOps * listener, int fd,
-                        AddressPair *pair, uint8_t * command) {
-  UdpListener * udp = (UdpListener *)listener->context;
-
-  if (*command != REQUEST_LIGHT){
-    printf("the message received is not a command, drop\n");
-    parcMemory_Deallocate((void **) &command);
-    return;
-  }
-
-  command_id id = *(command + 1);
-
-  if (id >= LAST_COMMAND_VALUE){
-    printf("the message received is not a valid command, drop\n");
-    parcMemory_Deallocate((void **) &command);
-    return;
-  }
-
-  unsigned connid;
-
-  const Connection *conn = _lookupConnection(listener, pair);
-  if (conn) {
-    connid = connection_GetConnectionId(conn);
-  } else {
-    connid = _createNewConnection(listener, fd, pair);
-  }
-
-  struct iovec *request;
-  if (!(request = (struct iovec *) parcMemory_AllocateAndClear(
-              sizeof(struct iovec) * 2))) {
-    return;
-  }
-
-  request[0].iov_base = command;
-  request[0].iov_len = sizeof(header_control_message);
-  request[1].iov_base = command + sizeof(header_control_message);
-  request[1].iov_len = payloadLengthDaemon(id);
-
-  forwarder_ReceiveCommand(udp->forwarder, id, request, connid);
-  parcMemory_Deallocate((void **) &command);
-  //parcMemory_Deallocate((void **) &request);
-}
-
-
-static bool _receivePacket(ListenerOps * listener, int fd,
-                           AddressPair *pair,
-                           uint8_t * packet) {
-  UdpListener * udp = (UdpListener *)listener->context;
-  bool processed = false;
-  Message *message = _readMessage(listener, fd, pair,
-                                   packet, &processed);
-  if (message) {
-    forwarder_Receive(udp->forwarder, message);
-  }
-  return processed;
-}
-
-static void _readcb(int fd, PARCEventType what, void * listener_void) {
-  ListenerOps * listener = (ListenerOps *)listener_void;
-  UdpListener * udp = (UdpListener *)listener->context;
-
-  if (logger_IsLoggable(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug)) {
-    logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-               "%s socket %d what %s%s%s%s data %p", __func__, fd,
-               (what & PARCEventType_Timeout) ? " timeout" : "",
-               (what & PARCEventType_Read) ? " read" : "",
-               (what & PARCEventType_Write) ? " write" : "",
-               (what & PARCEventType_Signal) ? " signal" : "", udp);
-  }
-
-  if (what & PARCEventType_Read) {
-    struct sockaddr_storage peerIpAddress;
-    socklen_t peerIpAddressLength = sizeof(peerIpAddress);
-
-    //packet it deallocated by _receivePacket or _readCommand
-    uint8_t * packet = parcMemory_AllocateAndClear(1500); //max MTU
-     ssize_t readLength = recvfrom(fd, packet, 1500, 0,
-      (struct sockaddr *)&peerIpAddress, &peerIpAddressLength);
-
-#ifdef __APPLE__
-    peerIpAddress.ss_len = 0x00;
-#endif
-
-    if(readLength < 0) {
-      printf("unable to read the message\n");
-      parcMemory_Deallocate(packet);
-      return;
-    }
-
-    AddressPair *pair = _constructAddressPair(
-      udp, (struct sockaddr *)&peerIpAddress, peerIpAddressLength);
-
-    bool done = _receivePacket(listener, fd, pair, packet);
-    if(!done){
-      _readCommand(listener, fd, pair, packet);
-    }
-
-    addressPair_Release(&pair);
-  }
-}
diff --git a/hicn-light/src/hicn/io/udpListener.h b/hicn-light/src/hicn/io/udpListener.h
deleted file mode 100644
index 62c09e4db..000000000
--- a/hicn-light/src/hicn/io/udpListener.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * 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 udpListener_h
-#define udpListener_h
-
-#ifndef _WIN32
-#include <netinet/in.h>
-#endif
-
-#include <hicn/core/forwarder.h>
-#include <hicn/io/listener.h>
-#include <stdlib.h>
-
-struct udp_listener;
-typedef struct udp_listener UdpListener;
-
-ListenerOps *udpListener_CreateInet6(Forwarder *forwarder, char *listenerName,
-                                     struct sockaddr_in6 sin6, const char *if_bind);
-ListenerOps *udpListener_CreateInet(Forwarder *forwarder, char *listenerName,
-                                    struct sockaddr_in sin, const char *if_bind);
-// void udpListener_SetPacketType(ListenerOps *ops, MessagePacketType type);
-#endif  // udpListener_h
diff --git a/hicn-light/src/hicn/io/udpTunnel.c b/hicn-light/src/hicn/io/udpTunnel.c
deleted file mode 100644
index 9f5249e3c..000000000
--- a/hicn-light/src/hicn/io/udpTunnel.c
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * 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 <errno.h>
-#include <hicn/hicn-light/config.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <parc/algol/parc_Network.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/io/udpConnection.h>
-#include <hicn/io/udpListener.h>
-#include <hicn/io/udpTunnel.h>
-
-IoOperations *udpTunnel_CreateOnListener(Forwarder *forwarder,
-                                         ListenerOps *localListener,
-                                         const Address *remoteAddress) {
-  parcAssertNotNull(forwarder, "Parameter metis must be non-null");
-  parcAssertNotNull(localListener, "Parameter localListener must be non-null");
-  parcAssertNotNull(remoteAddress, "Parameter remoteAddress must be non-null");
-
-  Logger *logger = forwarder_GetLogger(forwarder);
-
-  IoOperations *ops = NULL;
-  if (localListener->getEncapType(localListener) == ENCAP_UDP) {
-    const Address *localAddress =
-        localListener->getListenAddress(localListener);
-    address_type localType = addressGetType(localAddress);
-    address_type remoteType = addressGetType(remoteAddress);
-
-    if (localType == remoteType) {
-      AddressPair *pair = addressPair_Create(localAddress, remoteAddress);
-
-      //check it the connection is local
-      bool isLocal = false;
-      if(localType == ADDR_INET){
-        struct sockaddr_in tmpAddr;
-        addressGetInet(localAddress, &tmpAddr);
-        if(parcNetwork_IsSocketLocal((struct sockaddr *)&tmpAddr))
-          isLocal = true;
-      }else{
-        struct sockaddr_in6 tmpAddr6;
-        addressGetInet6(localAddress, &tmpAddr6);
-        if(parcNetwork_IsSocketLocal((struct sockaddr *)&tmpAddr6))
-          isLocal = true;
-      }
-      int fd = localListener->getSocket(localListener);
-      // udpListener_SetPacketType(localListener,
-      //                MessagePacketType_ContentObject);
-      ops = udpConnection_Create(forwarder, localListener->getInterfaceName(localListener), fd, pair, isLocal);
-
-      addressPair_Release(&pair);
-    } else {
-      if (logger_IsLoggable(logger, LoggerFacility_IO, PARCLogLevel_Error)) {
-        logger_Log(logger, LoggerFacility_IO, PARCLogLevel_Error, __func__,
-                   "Local listener of type %s and remote type %s, cannot "
-                   "establish tunnel",
-                   addressTypeToString(localType),
-                   addressTypeToString(remoteType));
-      }
-    }
-  } else {
-    if (logger_IsLoggable(logger, LoggerFacility_IO, PARCLogLevel_Error)) {
-      logger_Log(logger, LoggerFacility_IO, PARCLogLevel_Error, __func__,
-                 "Local listener %p is not type UDP, cannot establish tunnel",
-                 (void *)localListener);
-    }
-  }
-
-  return ops;
-}
-
-IoOperations *udpTunnel_Create(Forwarder *forwarder,
-                               const Address *localAddress,
-                               const Address *remoteAddress) {
-  ListenerSet *set = forwarder_GetListenerSet(forwarder);
-  ListenerOps *listener = listenerSet_Find(set, ENCAP_UDP, localAddress);
-  IoOperations *ops = NULL;
-  if (listener) {
-    ops = udpTunnel_CreateOnListener(forwarder, listener, remoteAddress);
-  } else {
-    if (logger_IsLoggable(forwarder_GetLogger(forwarder), LoggerFacility_IO,
-                          PARCLogLevel_Error)) {
-      char *str = addressToString(localAddress);
-      logger_Log(forwarder_GetLogger(forwarder), LoggerFacility_IO,
-                 PARCLogLevel_Error, __func__,
-                 "Could not find listener to match address %s", str);
-      parcMemory_Deallocate((void **)&str);
-    }
-  }
-  return ops;
-}
diff --git a/hicn-light/src/hicn/io/udpTunnel.h b/hicn-light/src/hicn/io/udpTunnel.h
deleted file mode 100644
index dacfdbb01..000000000
--- a/hicn-light/src/hicn/io/udpTunnel.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * 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 udpTunnel.h
- * @brief Establish a tunnel to a remote system
- *
- */
-
-#ifndef udpTunnel_h
-#define udpTunnel_h
-
-#include <hicn/core/forwarder.h>
-#include <hicn/io/ioOperations.h>
-#include <hicn/io/listener.h>
-#include <hicn/utils/address.h>
-
-/**
- */
-IoOperations *udpTunnel_CreateOnListener(Forwarder *forwarder,
-                                         ListenerOps *localListener,
-                                         const Address *remoteAddress);
-
-/**
- */
-IoOperations *udpTunnel_Create(Forwarder *forwarder,
-                               const Address *localAddress,
-                               const Address *remoteAddress);
-
-#endif  // udpTunnel_h
diff --git a/hicn-light/src/hicn/messenger/messenger.c b/hicn-light/src/hicn/messenger/messenger.c
deleted file mode 100644
index 45437539d..000000000
--- a/hicn-light/src/hicn/messenger/messenger.c
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
- * 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.
- */
-
-/**
- *
- * The messenger is contructued with a reference to the forwarder's dispatcher
- * so it can schedule future events.  When someone calls messenger_Send(...), it
- * will put the message on a queue.  If the queue was empty, it will scheudle
- * itself to be run. By running the queue in a future dispatcher slice, it
- * guarantees that there will be no re-entrant behavior between callers and
- * message listeners.
- *
- * A recipient will receive a reference counted copy of the missive, so it must
- * call
- * {@link missive_Release} on it.
- *
- */
-
-#include <parc/algol/parc_ArrayList.h>
-#include <parc/algol/parc_Event.h>
-#include <parc/algol/parc_EventScheduler.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <hicn/messenger/messenger.h>
-#include <hicn/messenger/missiveDeque.h>
-
-struct messenger {
-  PARCArrayList *callbacklist;
-  Dispatcher *dispatcher;
-  MissiveDeque *eventQueue;
-
-  PARCEventTimer *timerEvent;
-};
-
-static void messenger_Dequeue(int fd, PARCEventType which_event,
-                              void *messengerVoidPtr);
-
-// =========================================
-// Public API
-
-Messenger *messenger_Create(Dispatcher *dispatcher) {
-  Messenger *messenger = parcMemory_AllocateAndClear(sizeof(Messenger));
-  parcAssertNotNull(messenger, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Messenger));
-
-  // NULL destroyer because we're storing structures owned by the caller
-  messenger->dispatcher = dispatcher;
-  messenger->callbacklist = parcArrayList_Create(NULL);
-  messenger->eventQueue = missiveDeque_Create();
-
-  // creates the timer, but does not start it
-  messenger->timerEvent =
-      dispatcher_CreateTimer(dispatcher, false, messenger_Dequeue, messenger);
-
-  return messenger;
-}
-
-void messenger_Destroy(Messenger **messengerPtr) {
-  parcAssertNotNull(messengerPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*messengerPtr,
-                    "Parameter must dereference to non-null pointer");
-
-  Messenger *messenger = *messengerPtr;
-  parcArrayList_Destroy(&messenger->callbacklist);
-  missiveDeque_Release(&messenger->eventQueue);
-  dispatcher_DestroyTimerEvent(messenger->dispatcher, &messenger->timerEvent);
-  parcMemory_Deallocate((void **)&messenger);
-  *messengerPtr = NULL;
-}
-
-void messenger_Send(Messenger *messenger, Missive *missive) {
-  parcAssertNotNull(messenger, "Parameter messenger must be non-null");
-  parcAssertNotNull(missive, "Parameter event must be non-null");
-
-  missiveDeque_Append(messenger->eventQueue, missive);
-  if (missiveDeque_Size(messenger->eventQueue) == 1) {
-    // We need to scheudle ourself when an event is added to an empty queue
-
-    // precondition: timer should not be running.
-    struct timeval immediateTimeout = {0, 0};
-    dispatcher_StartTimer(messenger->dispatcher, messenger->timerEvent,
-                          &immediateTimeout);
-  }
-}
-
-static void removeRecipient(Messenger *messenger,
-                            const MessengerRecipient *recipient) {
-  // don't increment i in the loop
-  for (size_t i = 0; i < parcArrayList_Size(messenger->callbacklist);) {
-    const void *p = parcArrayList_Get(messenger->callbacklist, i);
-    if (p == recipient) {
-      // removing will compact the list, so next element will also be at i.
-      parcArrayList_RemoveAndDestroyAtIndex(messenger->callbacklist, i);
-    } else {
-      i++;
-    }
-  }
-}
-
-/**
- * @function eventMessenger_Register
- * @abstract Receive all event messages
- */
-void messenger_Register(Messenger *messenger,
-                        const MessengerRecipient *recipient) {
-  parcAssertNotNull(messenger, "Parameter messenger must be non-null");
-  parcAssertNotNull(recipient, "Parameter recipient must be non-null");
-
-  // do not allow duplicates
-  removeRecipient(messenger, recipient);
-
-  parcArrayList_Add(messenger->callbacklist, recipient);
-}
-
-/**
- * @function eventMessenger_Unregister
- * @abstract Stop receiving event messages
- */
-void messenger_Unregister(Messenger *messenger,
-                          const MessengerRecipient *recipient) {
-  parcAssertNotNull(messenger, "Parameter messenger must be non-null");
-  parcAssertNotNull(recipient, "Parameter recipient must be non-null");
-
-  removeRecipient(messenger, recipient);
-}
-
-/**
- * Called by event scheduler to give us a slice in which to dequeue events
- *
- * Called inside an event callback, so we now have exclusive access to the
- * system. Dequeues all pending events and calls all the listeners for each one.
- *
- * @param [in] fd unused, required for compliance with function prototype
- * @param [in] which_event unused, required for compliance with function
- * prototype
- * @param [in] messengerVoidPtr A void* to Messenger
- */
-static void messenger_Dequeue(int fd, PARCEventType which_event,
-                              void *messengerVoidPtr) {
-  Messenger *messenger = (Messenger *)messengerVoidPtr;
-  parcAssertNotNull(messenger, "Called with null messenger pointer");
-
-  Missive *missive;
-  while ((missive = missiveDeque_RemoveFirst(messenger->eventQueue)) != NULL) {
-    for (size_t i = 0; i < parcArrayList_Size(messenger->callbacklist); i++) {
-      MessengerRecipient *recipient =
-          parcArrayList_Get(messenger->callbacklist, i);
-      parcAssertTrue(recipient, "Recipient is null at index %zu", i);
-
-      messengerRecipient_Deliver(recipient, missive_Acquire(missive));
-    }
-
-    // now let go of our reference to the missive
-    missive_Release(&missive);
-  }
-}
diff --git a/hicn-light/src/hicn/messenger/messenger.h b/hicn-light/src/hicn/messenger/messenger.h
deleted file mode 100644
index 79d65cda6..000000000
--- a/hicn-light/src/hicn/messenger/messenger.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * The EventMessenger is the system that messages events between
- * producers and consumers.
- *
- * Events are delivered in a deferred event cycle to avoid event callbacks
- * firing when the event generator is still running.
- */
-
-#ifndef messenger_h
-#define messenger_h
-
-#include <hicn/core/dispatcher.h>
-#include <hicn/messenger/messengerRecipient.h>
-#include <hicn/messenger/missive.h>
-
-struct messenger;
-typedef struct messenger Messenger;
-
-/**
- * @function eventmessenger_Create
- * @abstract Creates an event notification system
- * @discussion
- *   Typically there's only one of these managed by forwarder.
- *
- * @param dispatcher is the event dispatcher to use to schedule events.
- */
-Messenger *messenger_Create(Dispatcher *dispatcher);
-
-/**
- * @function eventMessenger_Destroy
- * @abstract Destroys the messenger system, no notification is sent
- */
-void messenger_Destroy(Messenger **messengerPtr);
-
-/**
- * @function eventMessenger_Send
- * @abstract Send an event message, takes ownership of the event memory
- */
-void messenger_Send(Messenger *messenger, Missive *missive);
-
-/**
- * @function eventMessenger_Register
- * @abstract Receive all event messages
- */
-void messenger_Register(Messenger *messenger,
-                        const MessengerRecipient *recipient);
-
-/**
- * @function eventMessenger_Unregister
- * @abstract Stop receiving event messages
- */
-void messenger_Unregister(Messenger *messenger,
-                          const MessengerRecipient *recipient);
-#endif  // messenger_h
diff --git a/hicn-light/src/hicn/messenger/messengerRecipient.c b/hicn-light/src/hicn/messenger/messengerRecipient.c
deleted file mode 100644
index 17407030a..000000000
--- a/hicn-light/src/hicn/messenger/messengerRecipient.c
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * 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 <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <hicn/messenger/messenger.h>
-#include <hicn/messenger/messengerRecipient.h>
-
-struct messenger_recipient {
-  void *context;
-  MessengerRecipientCallback *notify;
-};
-
-MessengerRecipient *messengerRecipient_Create(
-    void *recipientContext, MessengerRecipientCallback *recipientCallback) {
-  parcAssertNotNull(recipientCallback,
-                    "Parameter recipientCallback must be non-null");
-
-  MessengerRecipient *recipient =
-      parcMemory_AllocateAndClear(sizeof(MessengerRecipient));
-  parcAssertNotNull(recipient, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(MessengerRecipient));
-  recipient->context = recipientContext;
-  recipient->notify = recipientCallback;
-  return recipient;
-}
-
-void messengerRecipient_Destroy(MessengerRecipient **recipientPtr) {
-  parcAssertNotNull(recipientPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*recipientPtr,
-                    "Parameter must dereference to non-null pointer");
-
-  parcMemory_Deallocate((void **)recipientPtr);
-  *recipientPtr = NULL;
-}
-
-void *messengerRecipient_GetRecipientContext(MessengerRecipient *recipient) {
-  parcAssertNotNull(recipient, "Parameter must be non-null");
-
-  return recipient->context;
-}
-
-void messengerRecipient_Deliver(MessengerRecipient *recipient,
-                                Missive *missive) {
-  parcAssertNotNull(recipient, "Parameter must be non-null");
-  recipient->notify(recipient, missive);
-}
diff --git a/hicn-light/src/hicn/messenger/messengerRecipient.h b/hicn-light/src/hicn/messenger/messengerRecipient.h
deleted file mode 100644
index cb5705b3a..000000000
--- a/hicn-light/src/hicn/messenger/messengerRecipient.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * 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 messengerRecipient.h
- * @brief A recipient represents the entity that will recieve a Missive from the
- * Messenger.
- *
- * A recipient is identified by the pair (contenxt, callback).  The context is
- * the recipients context, such as it's object pointer.  The callback is the
- * function the recipient uses to receive a Missive.
- *
- * If the receiver is going to do a lot of work or potentially send other
- * missives, the receiver should queue the received notifications and process
- * them in its own slice.
- *
- * A recipient will receive a reference counted copy of the missive, so it must
- * call
- * {@link missive_Release} on it.
- *
- *
- */
-
-#ifndef messengerRecipient_h
-#define messengerRecipient_h
-
-#include <hicn/messenger/missive.h>
-
-struct messenger_recipient;
-typedef struct messenger_recipient MessengerRecipient;
-
-/**
- * @typedef MessengerRecipientCallback
- * @abstract A recipient implements a callback to receive Missives.
- * @constant recipient The recipient to recieve the missive
- * @constant missive The missive, recipient must call {@link missive_Release} on
- * it
- */
-typedef void(MessengerRecipientCallback)(MessengerRecipient *recipient,
-                                         Missive *missive);
-
-/**
- * Creates a Recipient, which represents a reciever of missives.
- *
- * Creates a Recipient that can be registerd with the Messenger using {@link
- * messenger_Register}.
- *
- * @param [in] recipientContext This pointer will be passed back to the
- * recipient with each missive, may be NULL
- * @param [in] recipientCallback The function that receives the missive, must be
- * non-NULL.
- *
- * @return non-null A recipient object
- */
-MessengerRecipient *messengerRecipient_Create(
-    void *recipientContext, MessengerRecipientCallback *recipientCallback);
-
-/**
- * Destroys a recipient.  You should unregister it first.
- *
- * Destroying a recipient does not unregister it, so be sure to call
- * {@link messenger_Unregister} first.
- *
- * @param [in,out] recipientPtr Double pointer to the recipient to destroy, will
- * be NULL'd.
- */
-void messengerRecipient_Destroy(MessengerRecipient **recipientPtr);
-
-/**
- * Returns the recipient context passed on Create
- *
- * @param [in] recipient The recipient object
- *
- * @return pointer The context pointer used to create the object, maybe NULL
- */
-void *messengerRecipient_GetRecipientContext(MessengerRecipient *recipient);
-
-/**
- * Delivers a Missive to the recipient
- *
- * Passes the missive to the recipients callback.
- *
- * A recipient will receive a reference counted copy of the missive, so it must
- * call
- * {@link missive_Release} on it.
- *
- * @param [in] recipient The receiver
- * @param [in] missive The message to send
- */
-void messengerRecipient_Deliver(MessengerRecipient *recipient,
-                                Missive *missive);
-#endif  // messengerRecipient_h
diff --git a/hicn-light/src/hicn/messenger/missive.c b/hicn-light/src/hicn/messenger/missive.c
deleted file mode 100644
index 5162e683d..000000000
--- a/hicn-light/src/hicn/messenger/missive.c
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * 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 <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Object.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <hicn/messenger/missive.h>
-
-struct missive {
-  MissiveType missiveType;
-  unsigned connectionid;
-};
-
-parcObject_Override(Missive, PARCObject, .isLockable = false);
-
-Missive *missive_Create(MissiveType missiveType, unsigned connectionid) {
-  Missive *missive = parcObject_CreateInstance(Missive);
-  missive->missiveType = missiveType;
-  missive->connectionid = connectionid;
-  return missive;
-}
-
-Missive *missive_Acquire(const Missive *missive) {
-  return parcObject_Acquire(missive);
-}
-
-void missive_Release(Missive **missivePtr) {
-  parcObject_Release((void **)missivePtr);
-}
-
-MissiveType missive_GetType(const Missive *missive) {
-  parcAssertNotNull(missive, "Parameter missive must be non-null");
-  return missive->missiveType;
-}
-
-unsigned missive_GetConnectionId(const Missive *missive) {
-  parcAssertNotNull(missive, "Parameter missive must be non-null");
-  return missive->connectionid;
-}
diff --git a/hicn-light/src/hicn/messenger/missive.h b/hicn-light/src/hicn/messenger/missive.h
deleted file mode 100644
index fdeddce83..000000000
--- a/hicn-light/src/hicn/messenger/missive.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * 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 missive.h
- * @brief A Missive is a status message sent over a broadcast channel inside
- * hicn-light
- *
- * Recipients use {@link messenger_Register} to receive missives.  They are
- * broadcast to all recipients.
- *
- */
-#ifndef missive_h
-#define missive_h
-
-#include <hicn/messenger/missiveType.h>
-
-struct missive;
-typedef struct missive Missive;
-
-/**
- * Creates a Missive and sets the reference count to 1
- *
- * A Missive may be sent to listeners of the Messenger to inform them of events
- * on a connection id.
- *
- * @param [in] MissiveType The event type
- * @param [in] connectionid The relevant conneciton id
- *
- * @return non-null A message
- * @retrun null An error
- */
-Missive *missive_Create(MissiveType missiveType, unsigned connectionid);
-
-/**
- * Acquire a reference counted copy
- *
- * Increases the reference count by 1 and returns the original object.
- *
- * @param [in] missive An allocated missive
- *
- * @return non-null The original missive with increased reference count
- */
-Missive *missive_Acquire(const Missive *missive);
-
-/**
- * Releases a reference counted copy.
- *
- *  If it is the last reference, the missive is freed.
- *
- * @param [in,out] missivePtr Double pointer to a missive, will be nulled.
- */
-void missive_Release(Missive **missivePtr);
-
-/**
- * Returns the type of the missive
- *
- * Returns the type of event the missive represents
- *
- * @param [in] missive An allocated missive
- *
- * @return MissiveType The event type
- */
-MissiveType missive_GetType(const Missive *missive);
-
-/**
- * Returns the connection ID of the missive
- *
- * An event is usually associated with a connection id (i.e. the I/O channel
- * that originaged the event).
- *
- * @param [in] missive An allocated missive
- *
- * @return number The relevant connection id.
- */
-unsigned missive_GetConnectionId(const Missive *missive);
-#endif  // missive_h
diff --git a/hicn-light/src/hicn/messenger/missiveDeque.c b/hicn-light/src/hicn/messenger/missiveDeque.c
deleted file mode 100644
index ab94a4f18..000000000
--- a/hicn-light/src/hicn/messenger/missiveDeque.c
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * A type-safe wrapper for Missives around a {@link PARCDeque}.  We only
- * implement the subset of functions used.
- *
- */
-
-#include <parc/algol/parc_Deque.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <hicn/messenger/missive.h>
-#include <hicn/messenger/missiveDeque.h>
-
-struct missive_deque {
-  PARCDeque *queue;
-};
-
-MissiveDeque *missiveDeque_Create(void) {
-  MissiveDeque *missiveDeque =
-      parcMemory_AllocateAndClear(sizeof(MissiveDeque));
-  parcAssertNotNull(missiveDeque,
-                    "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(MissiveDeque));
-  missiveDeque->queue = parcDeque_Create();
-  return missiveDeque;
-}
-
-void missiveDeque_Release(MissiveDeque **dequePtr) {
-  parcAssertNotNull(dequePtr, "Double pointer must be non-null");
-  parcAssertNotNull(*dequePtr, "Double pointer must dereference to non-null");
-  MissiveDeque *missiveDeque = *dequePtr;
-
-  // flush the queue
-  while (!parcDeque_IsEmpty(missiveDeque->queue)) {
-    Missive *missive = missiveDeque_RemoveFirst(missiveDeque);
-    missive_Release(&missive);
-  }
-
-  parcDeque_Release(&missiveDeque->queue);
-  parcMemory_Deallocate((void **)&missiveDeque);
-  *dequePtr = NULL;
-}
-
-MissiveDeque *missiveDeque_Append(MissiveDeque *deque, Missive *missive) {
-  parcAssertNotNull(deque, "Parameter deque must be non-null");
-  parcAssertNotNull(missive, "Parameter missive must be non-null");
-
-  parcDeque_Append(deque->queue, missive);
-  return deque;
-}
-
-Missive *missiveDeque_RemoveFirst(MissiveDeque *deque) {
-  parcAssertNotNull(deque, "Parameter deque must be non-null");
-  return (Missive *)parcDeque_RemoveFirst(deque->queue);
-}
-
-size_t missiveDeque_Size(const MissiveDeque *deque) {
-  parcAssertNotNull(deque, "Parameter deque must be non-null");
-  return parcDeque_Size(deque->queue);
-}
diff --git a/hicn-light/src/hicn/messenger/missiveDeque.h b/hicn-light/src/hicn/messenger/missiveDeque.h
deleted file mode 100644
index c6f955ce0..000000000
--- a/hicn-light/src/hicn/messenger/missiveDeque.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * 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 missiveDeque
- * @brief Double ended queue of Missives
- *
- * Used to queue Missives.  This is a type-safe wrapper around {@link PARCDeque}
- *
- */
-
-#ifndef missiveDeque_h
-#define missiveDeque_h
-
-struct missive_deque;
-
-typedef struct missive_deque MissiveDeque;
-
-/**
- * Create a `PARCDeque` instance with the default element equals function.
- *
- * The queue is created with no elements.
- *
- * The default element equals function is used by the `parcDeque_Equals`
- * function and simply compares the values using the `==` operator. Users that
- * need more sophisticated comparisons of the elements need to supply their own
- * function via the `parcDeque_CreateCustom` function.
- *
- * @return non-NULL A pointer to a PARCDeque instance.
- */
-MissiveDeque *missiveDeque_Create(void);
-
-void missiveDeque_Release(MissiveDeque **dequePtr);
-
-/**
- * Appends the missive to the queue, taking ownership of the memory
- */
-MissiveDeque *missiveDeque_Append(MissiveDeque *deque, Missive *missive);
-
-Missive *missiveDeque_RemoveFirst(MissiveDeque *deque);
-
-size_t missiveDeque_Size(const MissiveDeque *deque);
-#endif  // missiveDeque_h
diff --git a/hicn-light/src/hicn/messenger/missiveType.h b/hicn-light/src/hicn/messenger/missiveType.h
deleted file mode 100644
index b0d9c7704..000000000
--- a/hicn-light/src/hicn/messenger/missiveType.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * 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 missiveType
- * @brief Defines what a Missive represents
- *
- * Currently, missives only carry information about the state of a connection
- * (created, up, down, closed, destroyed).
- *
- */
-
-#ifndef missiveType_h
-#define missiveType_h
-
-/**
- * @typedef Represents the state of a connection
- * @abstract CREATE is the initial state.  UP & DOWN are recurrent states.
- * CLOSED is transient.  DESTROYED is the terminal state.
- * @constant MissiveType_ConnectionCreate    Connection created (new)
- * @constant MissiveType_ConnectionUp        Connection is active and passing
- * data
- * @constant MissiveType_ConnectionDown      Connection is inactive and cannot
- * pass data
- * @constant MissiveType_ConnectionClosed    Connection closed and will be
- * destroyed
- * @constant MissiveType_ConnectionDestroyed Connection destroyed
- * @discussion State transitions:
- *                initial   -> CREATE
- *                CREATE    -> (UP | DOWN)
- *                UP        -> (DOWN | DESTROYED)
- *                DOWN      -> (UP | CLOSED | DESTROYED)
- *                CLOSED    -> DESTROYED
- *                DESTROYED -> terminal
- */
-typedef enum {
-  MissiveType_ConnectionCreate,
-  MissiveType_ConnectionUp,
-  MissiveType_ConnectionDown,
-  MissiveType_ConnectionClosed,
-  MissiveType_ConnectionDestroyed
-} MissiveType;
-#endif  // missiveType_h
diff --git a/hicn-light/src/hicn/platforms/CMakeLists.txt b/hicn-light/src/hicn/platforms/CMakeLists.txt
index 4073e0558..14237c976 100644
--- a/hicn-light/src/hicn/platforms/CMakeLists.txt
+++ b/hicn-light/src/hicn/platforms/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/hicn-light/src/hicn/platforms/README.txt b/hicn-light/src/hicn/platforms/README.txt
index a1293944c..18c63a5f9 100644
--- a/hicn-light/src/hicn/platforms/README.txt
+++ b/hicn-light/src/hicn/platforms/README.txt
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,4 +14,3 @@
  */
 
 Operating system dependent modules.
-
diff --git a/hicn-light/src/hicn/platforms/android/system.c b/hicn-light/src/hicn/platforms/android/system.c
index ba91748a0..80ca864ea 100644
--- a/hicn-light/src/hicn/platforms/android/system.c
+++ b/hicn-light/src/hicn/platforms/android/system.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+#if 0
 #include <errno.h>
 #include <hicn/hicn-light/config.h>
 #include <stdio.h>
@@ -181,3 +182,4 @@ unsigned system_InterfaceMtu(Forwarder *forwarder, const char *interfaceName) {
 
   return mtu;
 }
+#endif
\ No newline at end of file
diff --git a/hicn-light/src/hicn/platforms/darwin/system.c b/hicn-light/src/hicn/platforms/darwin/system.c
index d817248a8..b80fa9b69 100644
--- a/hicn-light/src/hicn/platforms/darwin/system.c
+++ b/hicn-light/src/hicn/platforms/darwin/system.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,6 +13,8 @@
  * limitations under the License.
  */
 
+#if 0
+
 #include <errno.h>
 #include <ifaddrs.h>
 #include <hicn/hicn-light/config.h>
@@ -144,3 +146,5 @@ unsigned system_InterfaceMtu(Forwarder *forwarder, const char *interfaceName) {
   }
   return mtu;
 }
+
+#endif
diff --git a/hicn-light/src/hicn/platforms/linux/system.c b/hicn-light/src/hicn/platforms/linux/system.c
index 3bf23cf57..4c14271a7 100644
--- a/hicn-light/src/hicn/platforms/linux/system.c
+++ b/hicn-light/src/hicn/platforms/linux/system.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,6 +13,8 @@
  * limitations under the License.
  */
 
+#if 0
+
 #include <errno.h>
 #include <ifaddrs.h>
 #include <hicn/hicn-light/config.h>
@@ -37,8 +39,6 @@
 
 #include <parc/assert/parc_Assert.h>
 
-#include <hicn/utils/addressList.h>
-
 /**
  * Returns the MTU for a named interface
  *
@@ -66,11 +66,9 @@ static int getMtu(const char *ifname) {
   return ifr.ifr_mtu;
 }
 
-InterfaceSet *system_Interfaces(Forwarder *forwarder) {
+InterfaceSet *system_Interfaces(forwarder_t * forwarder) {
   InterfaceSet *set = interfaceSetCreate();
 
-  Logger *logger = forwarder_GetLogger(forwarder);
-
   // this is the dynamically allocated head of the list
   struct ifaddrs *ifaddr;
   int failure = getifaddrs(&ifaddr);
@@ -93,60 +91,18 @@ InterfaceSet *system_Interfaces(Forwarder *forwarder) {
       interfaceSetAdd(set, iface);
     }
 
-    int family = next->ifa_addr->sa_family;
-    switch (family) {
-      case AF_INET: {
-        Address *address =
-            addressCreateFromInet((struct sockaddr_in *)next->ifa_addr);
-        interfaceAddAddress(iface, address);
-        break;
-      }
-
-      case AF_INET6: {
-        Address *address =
-            addressCreateFromInet6((struct sockaddr_in6 *)next->ifa_addr);
-        interfaceAddAddress(iface, address);
-        break;
-      }
-
-      case AF_PACKET: {
-        struct sockaddr_ll *addr_ll = (struct sockaddr_ll *)next->ifa_addr;
-
-        if (logger_IsLoggable(logger, LoggerFacility_IO, PARCLogLevel_Debug)) {
-          logger_Log(logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__,
-                     "sockaddr_ll family %d proto %d ifindex %d hatype %d "
-                     "pkttype %d halen %d",
-                     addr_ll->sll_family, addr_ll->sll_protocol,
-                     addr_ll->sll_ifindex, addr_ll->sll_hatype,
-                     addr_ll->sll_pkttype, addr_ll->sll_halen);
-        }
-
-        switch (addr_ll->sll_hatype) {
-          // list of the ARP hatypes we can extract a MAC address from
-          case ARPHRD_ETHER:
-          // fallthrough
-          case ARPHRD_IEEE802: {
-            Address *address = addressCreateFromLink(
-                (uint8_t *)addr_ll->sll_addr, addr_ll->sll_halen);
-            interfaceAddAddress(iface, address);
-            break;
-          }
-          default:
-            break;
-        }
-
-        break;
-      }
-    }
+    address_t * address = (address_t *)next->ifa_addr;
+    interfaceAddAddress(iface, address);
   }
 
   freeifaddrs(ifaddr);
   return set;
 }
 
-Address *system_GetMacAddressByName(Forwarder *forwarder,
+#if 0
+address_t *system_GetMacAddressByName(Forwarder *forwarder,
                                     const char *interfaceName) {
-  Address *linkAddress = NULL;
+  address_t *linkAddress = NULL;
 
   InterfaceSet *interfaceSet = system_Interfaces(forwarder);
   Interface *interface = interfaceSetGetByName(interfaceSet, interfaceName);
@@ -156,7 +112,7 @@ Address *system_GetMacAddressByName(Forwarder *forwarder,
 
     size_t length = addressListLength(addressList);
     for (size_t i = 0; i < length && !linkAddress; i++) {
-      const Address *a = addressListGetItem(addressList, i);
+      const address_t *a = addressListGetItem(addressList, i);
       if (addressGetType(a) == ADDR_LINK) {
         linkAddress = addressCopy(a);
       }
@@ -167,6 +123,7 @@ Address *system_GetMacAddressByName(Forwarder *forwarder,
 
   return linkAddress;
 }
+#endif
 
 unsigned system_InterfaceMtu(Forwarder *forwarder, const char *interfaceName) {
   unsigned mtu = 0;
@@ -182,3 +139,5 @@ unsigned system_InterfaceMtu(Forwarder *forwarder, const char *interfaceName) {
 
   return mtu;
 }
+
+#endif
diff --git a/hicn-light/src/hicn/platforms/windows/system.c b/hicn-light/src/hicn/platforms/windows/system.c
index 55d89f63a..6bd36a372 100644
--- a/hicn-light/src/hicn/platforms/windows/system.c
+++ b/hicn-light/src/hicn/platforms/windows/system.c
@@ -1,223 +1,223 @@
-/*

- * Copyright (c) 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 <parc/assert/parc_Assert.h>

-#include <hicn/hicn-light/config.h>

-

-#include <stdio.h>

-#include <stdlib.h>

-

-#include <sys/types.h>

-

-#include <errno.h>

-#include <string.h>

-

-#define WORKING_BUFFER_SIZE 15000

-#define MAX_TRIES 3

-

-#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))

-#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))

-

-#include <hicn/core/forwarder.h>

-#include <hicn/utils/interfaceSet.h>

-

-#include <hicn/utils/addressList.h>

-

-/**

- * Returns the MTU for a named interface

- *

- * On linux, we get the MTU by opening a socket and reading SIOCGIFMTU

- *

- * @param [in] ifname Interface name (e.g. "eth0")

- *

- * @retval number The MTU in bytes

- *

- * Example:

- * @code

- * <#example#>

- * @endcode

- */

-static int getMtu(const char *ifname) {

-  PIP_ADAPTER_ADDRESSES pAddresses = NULL;

-  PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;

-  ULONG outBufLen = 0;

-  ULONG flags = GAA_FLAG_INCLUDE_PREFIX;

-  ULONG family = AF_UNSPEC;

-

-  DWORD dwSize = 0;

-  DWORD dwRetVal = 0;

-  ULONG Iterations = 0;

-  do {

-    pAddresses = (IP_ADAPTER_ADDRESSES *)MALLOC(outBufLen);

-    if (pAddresses == NULL) {

-      printf("Memory allocation failed for IP_ADAPTER_ADDRESSES struct\n");

-      exit(1);

-    }

-

-    dwRetVal =

-        GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);

-

-    if (dwRetVal == ERROR_BUFFER_OVERFLOW) {

-      FREE(pAddresses);

-      pAddresses = NULL;

-    } else {

-      break;

-    }

-

-    Iterations++;

-

-  } while ((dwRetVal == ERROR_BUFFER_OVERFLOW) && (Iterations < MAX_TRIES));

-

-  if (dwRetVal == NO_ERROR) {

-    pCurrAddresses = pAddresses;

-    while (pCurrAddresses) {

-      if (strcmp(pCurrAddresses->AdapterName, ifname)) {

-        int mtu = pCurrAddresses->Mtu;

-        if (pAddresses) {

-          FREE(pAddresses);

-        }

-        return mtu;

-      }

-      pCurrAddresses = pCurrAddresses->Next;

-    }

-  }

-

-  if (pAddresses) {

-    FREE(pAddresses);

-  }

-  return -1;

-}

-

-InterfaceSet *system_Interfaces(Forwarder *forwarder) {

-  InterfaceSet *set = interfaceSetCreate();

-

-  Logger *logger = forwarder_GetLogger(forwarder);

-

-  DWORD dwSize = 0;

-  DWORD dwRetVal = 0;

-  unsigned int i = 0;

-  // Set the flags to pass to GetAdaptersAddresses

-  ULONG flags = GAA_FLAG_INCLUDE_PREFIX;

-

-  // default to unspecified address family (both)

-  ULONG family = AF_UNSPEC;

-

-  LPVOID lpMsgBuf = NULL;

-

-  PIP_ADAPTER_ADDRESSES pAddresses = NULL;

-  ULONG outBufLen = 0;

-  ULONG Iterations = 0;

-

-  PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;

-  PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;

-  PIP_ADAPTER_ANYCAST_ADDRESS pAnycast = NULL;

-  PIP_ADAPTER_MULTICAST_ADDRESS pMulticast = NULL;

-  IP_ADAPTER_DNS_SERVER_ADDRESS *pDnServer = NULL;

-  IP_ADAPTER_PREFIX *pPrefix = NULL;

-

-  outBufLen = WORKING_BUFFER_SIZE;

-

-  do {

-    pAddresses = (IP_ADAPTER_ADDRESSES *)MALLOC(outBufLen);

-    parcAssertNotNull(

-        pAddresses,

-        "Memory allocation failed for IP_ADAPTER_ADDRESSES struct\n");

-    dwRetVal =

-        GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);

-

-    if (dwRetVal == ERROR_BUFFER_OVERFLOW) {

-      FREE(pAddresses);

-      pAddresses = NULL;

-    } else {

-      break;

-    }

-

-    Iterations++;

-

-  } while ((dwRetVal == ERROR_BUFFER_OVERFLOW) && (Iterations < MAX_TRIES));

-  if (dwRetVal == NO_ERROR) {

-    // If successful, output some information from the data we received

-    pCurrAddresses = pAddresses;

-    while (pCurrAddresses) {

-      if (pCurrAddresses->OperStatus == IfOperStatusUp) {

-        Interface *iface =

-            interfaceSetGetByName(set, pCurrAddresses->AdapterName);

-        if (iface == NULL) {

-          pMulticast = pCurrAddresses->FirstMulticastAddress;

-          if (pMulticast) {

-            for (i = 0; pMulticast != NULL; i++) pMulticast = pMulticast->Next;

-          }

-

-          iface = interfaceCreate(

-              pCurrAddresses->AdapterName,

-              forwarder_GetNextConnectionId(forwarder),

-              pCurrAddresses->IfType == IF_TYPE_SOFTWARE_LOOPBACK, i > 0,

-              pCurrAddresses->Mtu);

-

-          interfaceSetAdd(set, iface);

-          for (pUnicast = pCurrAddresses->FirstUnicastAddress; pUnicast != NULL;

-               pUnicast = pUnicast->Next) {

-            int family = pUnicast->Address.lpSockaddr->sa_family;

-

-            switch (family) {

-              case AF_INET: {

-                char *ip = inet_ntoa(

-                    ((struct sockaddr_in *)(pUnicast->Address.lpSockaddr))

-                        ->sin_addr);

-                Address *address = addressCreateFromInet(

-                    (struct sockaddr_in *)(pUnicast->Address.lpSockaddr));

-                interfaceAddAddress(iface, address);

-                break;

-              }

-

-              case AF_INET6: {

-                char str[INET6_ADDRSTRLEN];

-                inet_ntop(

-                    AF_INET6,

-                    &((struct sockaddr_in6 *)(pUnicast->Address.lpSockaddr))

-                         ->sin6_addr,

-                    str, INET6_ADDRSTRLEN);

-                Address *address = addressCreateFromInet6(

-                    (struct sockaddr_in6 *)(pUnicast->Address.lpSockaddr));

-                interfaceAddAddress(iface, address);

-                break;

-              }

-

-              default:

-                break;

-            }

-          }

-        }

-      }

-      pCurrAddresses = pCurrAddresses->Next;

-    }

-  }

-

-  if (pAddresses) {

-    FREE(pAddresses);

-  }

-  return set;

-}

-

-Address *system_GetMacAddressByName(Forwarder *forwarder,

-                                    const char *interfaceName) {

-  return NULL;

-}

-

-unsigned system_InterfaceMtu(Forwarder *forwarder, const char *interfaceName) {

-  unsigned mtu = 0;

-

-  return mtu;

-}

+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <parc/assert/parc_Assert.h>
+#include <hicn/hicn-light/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <sys/types.h>
+
+#include <errno.h>
+#include <string.h>
+
+#define WORKING_BUFFER_SIZE 15000
+#define MAX_TRIES 3
+
+#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))
+#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))
+
+#include <hicn/core/forwarder.h>
+#include <hicn/utils/interfaceSet.h>
+
+#include <hicn/utils/addressList.h>
+
+/**
+ * Returns the MTU for a named interface
+ *
+ * On linux, we get the MTU by opening a socket and reading SIOCGIFMTU
+ *
+ * @param [in] ifname Interface name (e.g. "eth0")
+ *
+ * @retval number The MTU in bytes
+ *
+ * Example:
+ * @code
+ * <#example#>
+ * @endcode
+ */
+static int getMtu(const char *ifname) {
+  PIP_ADAPTER_ADDRESSES pAddresses = NULL;
+  PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
+  ULONG outBufLen = 0;
+  ULONG flags = GAA_FLAG_INCLUDE_PREFIX;
+  ULONG family = AF_UNSPEC;
+
+  DWORD dwSize = 0;
+  DWORD dwRetVal = 0;
+  ULONG Iterations = 0;
+  do {
+    pAddresses = (IP_ADAPTER_ADDRESSES *)MALLOC(outBufLen);
+    if (pAddresses == NULL) {
+      printf("Memory allocation failed for IP_ADAPTER_ADDRESSES struct\n");
+      exit(1);
+    }
+
+    dwRetVal =
+        GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);
+
+    if (dwRetVal == ERROR_BUFFER_OVERFLOW) {
+      FREE(pAddresses);
+      pAddresses = NULL;
+    } else {
+      break;
+    }
+
+    Iterations++;
+
+  } while ((dwRetVal == ERROR_BUFFER_OVERFLOW) && (Iterations < MAX_TRIES));
+
+  if (dwRetVal == NO_ERROR) {
+    pCurrAddresses = pAddresses;
+    while (pCurrAddresses) {
+      if (strcmp(pCurrAddresses->AdapterName, ifname)) {
+        int mtu = pCurrAddresses->Mtu;
+        if (pAddresses) {
+          FREE(pAddresses);
+        }
+        return mtu;
+      }
+      pCurrAddresses = pCurrAddresses->Next;
+    }
+  }
+
+  if (pAddresses) {
+    FREE(pAddresses);
+  }
+  return -1;
+}
+
+InterfaceSet *system_Interfaces(Forwarder *forwarder) {
+  InterfaceSet *set = interfaceSetCreate();
+
+  Logger *logger = forwarder_GetLogger(forwarder);
+
+  DWORD dwSize = 0;
+  DWORD dwRetVal = 0;
+  unsigned int i = 0;
+  // Set the flags to pass to GetAdaptersAddresses
+  ULONG flags = GAA_FLAG_INCLUDE_PREFIX;
+
+  // default to unspecified address family (both)
+  ULONG family = AF_UNSPEC;
+
+  LPVOID lpMsgBuf = NULL;
+
+  PIP_ADAPTER_ADDRESSES pAddresses = NULL;
+  ULONG outBufLen = 0;
+  ULONG Iterations = 0;
+
+  PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
+  PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
+  PIP_ADAPTER_ANYCAST_ADDRESS pAnycast = NULL;
+  PIP_ADAPTER_MULTICAST_ADDRESS pMulticast = NULL;
+  IP_ADAPTER_DNS_SERVER_ADDRESS *pDnServer = NULL;
+  IP_ADAPTER_PREFIX *pPrefix = NULL;
+
+  outBufLen = WORKING_BUFFER_SIZE;
+
+  do {
+    pAddresses = (IP_ADAPTER_ADDRESSES *)MALLOC(outBufLen);
+    parcAssertNotNull(
+        pAddresses,
+        "Memory allocation failed for IP_ADAPTER_ADDRESSES struct\n");
+    dwRetVal =
+        GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);
+
+    if (dwRetVal == ERROR_BUFFER_OVERFLOW) {
+      FREE(pAddresses);
+      pAddresses = NULL;
+    } else {
+      break;
+    }
+
+    Iterations++;
+
+  } while ((dwRetVal == ERROR_BUFFER_OVERFLOW) && (Iterations < MAX_TRIES));
+  if (dwRetVal == NO_ERROR) {
+    // If successful, output some information from the data we received
+    pCurrAddresses = pAddresses;
+    while (pCurrAddresses) {
+      if (pCurrAddresses->OperStatus == IfOperStatusUp) {
+        Interface *iface =
+            interfaceSetGetByName(set, pCurrAddresses->AdapterName);
+        if (iface == NULL) {
+          pMulticast = pCurrAddresses->FirstMulticastAddress;
+          if (pMulticast) {
+            for (i = 0; pMulticast != NULL; i++) pMulticast = pMulticast->Next;
+          }
+
+          iface = interfaceCreate(
+              pCurrAddresses->AdapterName,
+              forwarder_GetNextConnectionId(forwarder),
+              pCurrAddresses->IfType == IF_TYPE_SOFTWARE_LOOPBACK, i > 0,
+              pCurrAddresses->Mtu);
+
+          interfaceSetAdd(set, iface);
+          for (pUnicast = pCurrAddresses->FirstUnicastAddress; pUnicast != NULL;
+               pUnicast = pUnicast->Next) {
+            int family = pUnicast->Address.lpSockaddr->sa_family;
+
+            switch (family) {
+              case AF_INET: {
+                char *ip = inet_ntoa(
+                    ((struct sockaddr_in *)(pUnicast->Address.lpSockaddr))
+                        ->sin_addr);
+                Address *address = addressCreateFromInet(
+                    (struct sockaddr_in *)(pUnicast->Address.lpSockaddr));
+                interfaceAddAddress(iface, address);
+                break;
+              }
+
+              case AF_INET6: {
+                char str[INET6_ADDRSTRLEN];
+                inet_ntop(
+                    AF_INET6,
+                    &((struct sockaddr_in6 *)(pUnicast->Address.lpSockaddr))
+                         ->sin6_addr,
+                    str, INET6_ADDRSTRLEN);
+                Address *address = addressCreateFromInet6(
+                    (struct sockaddr_in6 *)(pUnicast->Address.lpSockaddr));
+                interfaceAddAddress(iface, address);
+                break;
+              }
+
+              default:
+                break;
+            }
+          }
+        }
+      }
+      pCurrAddresses = pCurrAddresses->Next;
+    }
+  }
+
+  if (pAddresses) {
+    FREE(pAddresses);
+  }
+  return set;
+}
+
+Address *system_GetMacAddressByName(Forwarder *forwarder,
+                                    const char *interfaceName) {
+  return NULL;
+}
+
+unsigned system_InterfaceMtu(Forwarder *forwarder, const char *interfaceName) {
+  unsigned mtu = 0;
+
+  return mtu;
+}
diff --git a/hicn-light/src/hicn/platforms/windows/win_portability.c b/hicn-light/src/hicn/platforms/windows/win_portability.c
index 3138640dd..e063cec24 100644
--- a/hicn-light/src/hicn/platforms/windows/win_portability.c
+++ b/hicn-light/src/hicn/platforms/windows/win_portability.c
@@ -1,50 +1,54 @@
-/*

- * Copyright (c) 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.

- */

-

-#pragma once

-

-#include <hicn/platforms/windows/win_portability.h>

-

-int getline(char **lineptr, size_t *n, FILE *stream) {

-  static char line[256];

-  char *ptr;

-  unsigned int len;

-

-  if (lineptr == NULL || n == NULL) {

-    errno = EINVAL;

-    return -1;

-  }

-

-  if (ferror(stream)) return -1;

-

-  if (feof(stream)) return -1;

-

-  fgets(line, 256, stream);

-

-  ptr = strchr(line, '\n');

-  if (ptr) *ptr = '\0';

-

-  len = (unsigned int)strlen(line);

-

-  if ((len + 1) < 256) {

-    ptr = (char *)realloc(*lineptr, 256);

-    if (ptr == NULL) return (-1);

-    *lineptr = ptr;

-    *n = 256;

-  }

-

-  strcpy(*lineptr, line);

-  return (len);

+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <hicn/platforms/windows/win_portability.h>
+#include <hicn/util/sstrncpy.h>
+
+int getline(char **lineptr, size_t *n, FILE *stream) {
+  static char line[256];
+  char *ptr;
+  unsigned int len;
+  int rc;
+
+  if (lineptr == NULL || n == NULL) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (ferror(stream)) return -1;
+
+  if (feof(stream)) return -1;
+
+  fgets(line, 256, stream);
+
+  ptr = strchr(line, '\n');
+  if (ptr) *ptr = '\0';
+
+  len = (unsigned int)strlen(line);
+
+  if ((len + 1) < 256) {
+    ptr = (char *)realloc(*lineptr, 256);
+    if (ptr == NULL) return (-1);
+    *lineptr = ptr;
+    *n = 256;
+  }
+
+  rc = strcpy_s(*lineptr, 256, line);
+  if (rc != EOK) return -1;
+
+  return (len);
 }
\ No newline at end of file
diff --git a/hicn-light/src/hicn/platforms/windows/win_portability.h b/hicn-light/src/hicn/platforms/windows/win_portability.h
index 5c25f4bb2..f42bf9d53 100644
--- a/hicn-light/src/hicn/platforms/windows/win_portability.h
+++ b/hicn-light/src/hicn/platforms/windows/win_portability.h
@@ -1,45 +1,45 @@
-/*

- * Copyright (c) 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.

- */

-

-#pragma once

-#include <parc/windows/parc_Utils.h>

-#include <afunix.h>

-#include <io.h>

-#include <iphlpapi.h>

-#include <process.h>

-#include <stdio.h>

-#pragma comment(lib, "IPHLPAPI.lib")

-

-#ifndef in_port_t

-#define in_port_t uint16_t

-#endif

-

-#ifndef in_addr_t

-#define in_addr_t uint32_t

-#endif

-

-#ifndef strncasecmp

-#define strncasecmp _strnicmp

-#endif

-

-#ifndef strcasecmp

-#define strcasecmp _stricmp

-#endif

-

-#define HAVE_STRUCT_TIMESPEC

-

-#ifndef getline

-int getline(char **lineptr, size_t *n, FILE *stream);

+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <parc/windows/parc_Utils.h>
+#include <afunix.h>
+#include <io.h>
+#include <iphlpapi.h>
+#include <process.h>
+#include <stdio.h>
+#pragma comment(lib, "IPHLPAPI.lib")
+
+#ifndef in_port_t
+#define in_port_t uint16_t
+#endif
+
+#ifndef in_addr_t
+#define in_addr_t uint32_t
+#endif
+
+#ifndef strncasecmp
+#define strncasecmp _strnicmp
+#endif
+
+#ifndef strcasecmp
+#define strcasecmp _stricmp
+#endif
+
+#define HAVE_STRUCT_TIMESPEC
+
+#ifndef getline
+int getline(char **lineptr, size_t *n, FILE *stream);
 #endif
\ No newline at end of file
diff --git a/hicn-light/src/hicn/processor/CMakeLists.txt b/hicn-light/src/hicn/processor/CMakeLists.txt
deleted file mode 100644
index 17c3b1f88..000000000
--- a/hicn-light/src/hicn/processor/CMakeLists.txt
+++ /dev/null
@@ -1,38 +0,0 @@
-# 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
-  ${CMAKE_CURRENT_SOURCE_DIR}/fibEntry.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/fibEntryList.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/messageProcessor.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/hashTableFunction.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/pit.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/fib.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/pitEntry.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/pitVerdict.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/pitStandard.h
-)
-
-list(APPEND SOURCE_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/hashTableFunction.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/fib.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/fibEntry.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/fibEntryList.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/messageProcessor.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/pit.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/pitEntry.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/pitStandard.c
-)
-
-set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
-set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
diff --git a/hicn-light/src/hicn/processor/fib.c b/hicn-light/src/hicn/processor/fib.c
deleted file mode 100644
index de0d1e2ef..000000000
--- a/hicn-light/src/hicn/processor/fib.c
+++ /dev/null
@@ -1,553 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <hicn/core/forwarder.h>
-#include <hicn/processor/fib.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-
-#include <parc/assert/parc_Assert.h>
-
-struct node;
-typedef struct node FibNode;
-
-struct node {
-  FibNode *left;
-  FibNode *right;
-  FibEntry *entry;
-  bool is_used;
-};
-
-struct fib {
-  Forwarder *forwarder;
-  FibNode *root;
-  unsigned size;
-};
-
-// =====================================================
-// Public API
-
-FibNode *_createNode(FibNode *left, FibNode *right, FibEntry *entry,
-                     bool is_used) {
-  FibNode *n = parcMemory_AllocateAndClear(sizeof(FibNode));
-  parcAssertNotNull(n, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(FibNode));
-
-  n->left = left;
-  n->right = right;
-  n->entry = entry;
-  n->is_used = is_used;
-
-  return n;
-}
-
-FIB *fib_Create(Forwarder *forwarder) {
-  FIB *hicnFib = parcMemory_AllocateAndClear(sizeof(FIB));
-  parcAssertNotNull(hicnFib, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(FIB));
-
-  hicnFib->forwarder = forwarder;
-  hicnFib->root = NULL;
-  hicnFib->size = 0;
-
-  return hicnFib;
-}
-
-void _destroyNode(FibNode *n) {
-  fibEntry_Release(&n->entry);
-  parcMemory_Deallocate((void **)&n);
-  n = NULL;
-}
-
-void _destroyFib(FibNode *n) {
-  if(n != NULL){
-    _destroyFib(n->right);
-    _destroyFib(n->left);
-    _destroyNode(n);
-  }
-}
-
-void fib_Destroy(FIB **fibPtr) {
-  parcAssertNotNull(fibPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*fibPtr, "Parameter must dereference to non-null pointer");
-
-  FIB *fib = *fibPtr;
-  _destroyFib(fib->root);
-
-  parcMemory_Deallocate((void **)&fib);
-  *fibPtr = NULL;
-}
-
-void fib_Add(FIB *fib, FibEntry *entry) {
-  parcAssertNotNull(fib, "Parameter must be non-null");
-  parcAssertNotNull(entry, "Parameter must be non-null");
-
-  NameBitvector *new_prefix = name_GetContentName(fibEntry_GetPrefix(entry));
-  uint32_t new_prefix_len = nameBitvector_GetLength(new_prefix);
-  FibNode * curr =  fib->root;
-  FibNode * last =  NULL;
-
-  NameBitvector *curr_name;
-  uint32_t curr_prefix_len;
-  uint32_t match_len;
-
-  while(curr != NULL){
-    curr_name = name_GetContentName(fibEntry_GetPrefix(curr->entry));
-
-    match_len =  nameBitvector_lpm(new_prefix, curr_name);
-    curr_prefix_len = nameBitvector_GetLength(curr_name);
-
-    if(curr_prefix_len != match_len || //the new entry does not match the curr
-        curr_prefix_len >= new_prefix_len) //in this case we cannot procede anymore
-          break;
-
-    last = curr;
-    bool bit;
-    int res = nameBitvector_testBit(new_prefix, curr_prefix_len, &bit);
-    parcAssertFalse(res < 0, "error testing name bit (fib_add)");
-    if(bit)
-      curr = curr->right;
-    else
-      curr = curr->left;
-  }
-
-  //this is the root (empty trie) or an empty child
-  if(curr == NULL){
-    FibNode * new_node = _createNode(NULL, NULL, entry, true);
-    if(last == NULL){
-      fib->root =  new_node;
-    }else{
-      uint32_t last_prefix_len = nameBitvector_GetLength(
-                      name_GetContentName(fibEntry_GetPrefix(last->entry)));
-      bool bit;
-      int res = nameBitvector_testBit(new_prefix, last_prefix_len, &bit);
-      parcAssertFalse(res < 0, "error testing name bit (fib_add)");
-      if(bit)
-        last->right = new_node;
-      else
-        last->left = new_node;
-    }
-    fib->size++;
-    return;
-  }
-
-  //curr is not null
-
-  //the node already exist
-  //if is not in use we turn it on and we set the rigth fib entry
-  if(curr_prefix_len == match_len && new_prefix_len == match_len){
-    if(!curr->is_used){
-      curr->is_used = true;
-      curr->entry = entry;
-      fib->size++;
-      return;
-    }else{
-      //this case should never happen beacuse of the way we add
-      //entries in the fib
-      const NumberSet * next_hops = fibEntry_GetNexthops(entry);
-      unsigned size = (unsigned)fibEntry_NexthopCount(entry);
-      for(unsigned i = 0; i < size; i++)
-        fibEntry_AddNexthop(curr->entry,numberSet_GetItem(next_hops, i));
-    }
-  }
-
-  //key is prefix of the curr node (so new_prefix_len < curr_prefix_len)
-  if(new_prefix_len == match_len){
-    FibNode * new_node = _createNode(NULL, NULL, entry, true);
-    if(last == NULL){
-      fib->root = new_node;
-    }else{
-      uint32_t last_prefix_len = nameBitvector_GetLength(
-                      name_GetContentName(fibEntry_GetPrefix(last->entry)));
-
-      bool bit;
-      int res = nameBitvector_testBit(new_prefix, last_prefix_len, &bit);
-      parcAssertFalse(res < 0, "error testing name bit (fib_add)");
-      if(bit)
-        last->right =  new_node;
-      else
-        last->left = new_node;
-    }
-    bool bit;
-    int res = nameBitvector_testBit(curr_name, match_len, &bit);
-    parcAssertFalse(res < 0, "error testing name bit (fib_add)");
-    if(bit)
-      new_node->right = curr;
-    else
-      new_node->left = curr;
-    fib->size++;
-    return;
-  }
-
-  //in the last case we need to add an inner node
-  Name * inner_prefix = name_Copy(fibEntry_GetPrefix(entry));
-  nameBitvector_clear(name_GetContentName(inner_prefix), match_len);
-  name_setLen(inner_prefix,  match_len);
-
-  //this is an inner node, we don't want an acctive strategy
-  //like low_latency that sends probes in this node
-  FibEntry * inner_entry = fibEntry_Create(inner_prefix,
-            SET_STRATEGY_LOADBALANCER, fib->forwarder);
-
-  FibNode * inner_node = _createNode(NULL, NULL, inner_entry, false);
-  FibNode * new_node = _createNode(NULL, NULL, entry, true);
-
-  if(last == NULL){
-    //we need to place the inner_node at the root
-    fib->root = inner_node;
-  }else{
-    uint32_t last_prefix_len = nameBitvector_GetLength(
-                      name_GetContentName(fibEntry_GetPrefix(last->entry)));
-    bool bit;
-    int res = nameBitvector_testBit(name_GetContentName(inner_prefix),
-                                                last_prefix_len, &bit);
-    parcAssertFalse(res < 0, "error testing name bit (fib_add)");
-    if(bit)
-      last->right =  inner_node;
-    else
-      last->left = inner_node;
-  }
-
-  bool bit;
-  int res = nameBitvector_testBit(new_prefix, match_len, &bit);
-  parcAssertFalse(res < 0, "error testing name bit (fib_add)");
-
-  if(bit){
-    inner_node -> left = curr;
-    inner_node ->right = new_node;
-  }else{
-    inner_node -> left = new_node;
-    inner_node ->right = curr;
-  }
-  fib->size ++;
-
-  name_Release(&inner_prefix);
-}
-
-FibEntry *fib_Contains(const FIB *fib, const Name *prefix) {
-  parcAssertNotNull(fib, "Parameter must be non-null");
-  parcAssertNotNull(prefix, "Parameter must be non-null");
-
-  NameBitvector *key_name = name_GetContentName(prefix);
-  uint32_t key_prefix_len = nameBitvector_GetLength(key_name);
-
-  FibNode * curr = fib->root;
-
-  while(curr != NULL){
-    NameBitvector *curr_name =
-          name_GetContentName(fibEntry_GetPrefix(curr->entry));
-    uint32_t match_len = nameBitvector_lpm(key_name, curr_name);
-    uint32_t curr_prefix_len = nameBitvector_GetLength(curr_name);
-
-    if(match_len < curr_prefix_len){
-      //the current node does not match completelly the key, so
-      //the key is not in the trie
-      //this implies curr_prefix_len > key_prefix_len
-      return NULL;
-    }
-
-    if(curr_prefix_len == key_prefix_len){ //== match_len
-        //this is an exact match
-        if(curr->is_used){
-          //we found the key
-          return curr->entry;
-        }else{
-          //the key does not exists
-          return NULL;
-        }
-    }
-
-    bool bit;
-    int res = nameBitvector_testBit(key_name, curr_prefix_len, &bit);
-    parcAssertFalse(res < 0, "error testing name bit (fib_contains)");
-
-    if(bit)
-      curr = curr->right;
-    else
-      curr = curr->left;
-  }
-
-  return NULL;
-}
-
-void _removeNode(FIB *fib, const Name *prefix){
-  parcAssertNotNull(fib, "Parameter must be non-null");
-  parcAssertNotNull(prefix, "Parameter must be non-null");
-
-  NameBitvector *key_name = name_GetContentName(prefix);
-  uint32_t key_prefix_len = nameBitvector_GetLength(key_name);
-
-  FibNode * curr = fib->root;
-  FibNode * parent = NULL;
-  FibNode * grandpa = NULL;
-
-  uint32_t match_len;
-  uint32_t curr_prefix_len;
-  while(curr != NULL){
-    NameBitvector *curr_name =
-          name_GetContentName(fibEntry_GetPrefix(curr->entry));
-    match_len = nameBitvector_lpm(key_name, curr_name);
-    curr_prefix_len = nameBitvector_GetLength(curr_name);
-
-    if(match_len < curr_prefix_len ||
-        curr_prefix_len == key_prefix_len){
-      break;
-    }
-
-    grandpa = parent;
-    parent = curr;
-
-    bool bit;
-    int res = nameBitvector_testBit(key_name, curr_prefix_len, &bit);
-    parcAssertFalse(res < 0, "error testing name bit (_removeNode)");
-
-    if(bit)
-      curr = curr->right;
-    else
-      curr = curr->left;
-  }
-
-  if(curr == NULL ||
-     !curr->is_used ||
-     (curr_prefix_len != key_prefix_len)){
-     //the node does not exists
-    return;
-  }
-
-  //curr has 2 children, leave it there and mark it as inner
-  if(curr->right != NULL && curr->left != NULL){
-    curr->is_used = false;
-    fib->size--;
-    return;
-  }
-
-  //curr has no children
-  if(curr->right == NULL && curr->left == NULL){
-    if (parent == NULL){
-      //curr is the root and is the only node in the fib
-      fib->root = NULL;
-      fib->size--;
-      _destroyNode(curr);
-      return;
-    }
-    if(grandpa == NULL){
-      //parent is the root
-      if(fib->root->left == curr)
-        fib->root->left = NULL;
-      else
-        fib->root->right = NULL;
-      fib->size--;
-      _destroyNode(curr);
-      return;
-    }
-    if(!parent->is_used){
-      //parent is an inner node
-      //remove curr and inner_node (parent), connect the other child
-      //of the parent to the grandpa
-      FibNode * tmp;
-      if(parent->right == curr)
-        tmp = parent->left;
-      else
-        tmp = parent->right;
-
-      if(grandpa->right == parent)
-        grandpa->right = tmp;
-      else
-        grandpa->left = tmp;
-
-      fib->size--;
-      _destroyNode(curr);
-      _destroyNode(parent);
-      return;
-    }
-    //parent is node not an inner_node
-    //just remove curr the node
-    if(parent->right == curr)
-      parent->right = NULL;
-    else
-       parent->left = NULL;
-    fib->size--;
-    _destroyNode(curr);
-    return;
-  }
-
-  //curr has one child
-  if(curr->right != NULL || curr->left != NULL){
-    if(parent == NULL){
-      //curr is the root
-      if(fib->root->right != NULL)
-        fib->root = fib->root->right;
-      else
-        fib->root = fib->root->left;
-      fib->size--;
-      _destroyNode(curr);
-      return;
-    }
-    //attach the child of curr to parent
-    FibNode * tmp;
-    if(curr->right != NULL)
-      tmp = curr->right;
-    else
-      tmp = curr->left;
-
-    if(parent->right == curr)
-      parent->right = tmp;
-    else
-      parent->left = tmp;
-
-    fib->size--;
-    _destroyNode(curr);
-    return;
-  }
-}
-
-void fib_Remove(FIB *fib, const Name *name, unsigned connId) {
-  parcAssertNotNull(fib, "Parameter must be non-null");
-  parcAssertNotNull(name, "Parameter must be non-null");
-
-  FibEntry *entry = fib_Contains(fib, name);
-
-  if (entry == NULL) {
-    return;
-  }
-
-  fibEntry_RemoveNexthopByConnectionId(entry, connId);
-#ifndef WITH_MAPME
-  if (fibEntry_NexthopCount(entry) == 0)
-    _removeNode(fib, name);
-#endif /* WITH_MAPME */
-
-  // XXX We never release the FIB entry here it seems, including the inner
-  // prefix
-
-}
-
-void _removeConnectionId(FibNode *n, unsigned connectionId,
-                         FibEntryList *list) {
-  if(n != NULL){
-    if(n->is_used){
-      fibEntry_RemoveNexthopByConnectionId(n->entry, connectionId);
-#ifndef WITH_MAPME
-      if (fibEntry_NexthopCount(n->entry) == 0) {
-        fibEntryList_Append(list, n->entry);
-      }
-#endif /* WITH_MAPME */
-    }
-    _removeConnectionId(n->right, connectionId, list);
-    _removeConnectionId(n->left, connectionId, list);
-  }
-}
-
-void fib_RemoveConnectionId(FIB *fib, unsigned connectionId) {
-  parcAssertNotNull(fib, "Parameter must be non-null");
-
-   FibEntryList *list = fibEntryList_Create();
-   _removeConnectionId(fib->root, connectionId, list);
-
-  for (int i = 0; i < fibEntryList_Length(list); i++) {
-    _removeNode(fib, fibEntry_GetPrefix(fibEntryList_Get(list, i)));
-  }
-
-  fibEntryList_Destroy(&list);
-}
-
-size_t fib_Length(const FIB *fib) {
-  parcAssertNotNull(fib, "Parameter must be non-null");
-  return fib->size;
-}
-
-FibEntry *fib_MatchMessage(const FIB *fib, const Message *interestMessage) {
-  parcAssertNotNull(fib, "Parameter must be non-null");
-  parcAssertNotNull(interestMessage, "Parameter must be non-null");
-  return fib_MatchBitvector(fib, name_GetContentName(
-                  message_GetName(interestMessage)));
-}
-
-FibEntry *fib_MatchName(const FIB *fib, const Name *name) {
-  parcAssertNotNull(fib, "Parameter must be non-null");
-  parcAssertNotNull(name, "Parameter must be non-null");
-  return fib_MatchBitvector(fib, name_GetContentName(name));
-}
-
-
-FibEntry *fib_MatchBitvector(const FIB *fib, const NameBitvector *name){
-  parcAssertNotNull(fib, "Parameter must be non-null");
-  parcAssertNotNull(name, "Parameter must be non-null");
-
-  uint32_t key_prefix_len = nameBitvector_GetLength(name);
-
-  FibNode * curr = fib->root;
-  FibNode * candidate = NULL;
-
-  while(curr != NULL){
-    NameBitvector *curr_name =
-          name_GetContentName(fibEntry_GetPrefix(curr->entry));
-    uint32_t match_len = nameBitvector_lpm(name, curr_name);
-    uint32_t curr_prefix_len = nameBitvector_GetLength(curr_name);
-
-    if(match_len < curr_prefix_len){
-      //the current node does not match completelly the key, so
-      //return the parent of this node (saved in candidate)
-      break;
-    }
-
-    if(curr->is_used)
-      candidate = curr;
-
-    //if we are here match_len == curr_prefix_len (can't be larger)
-    //so this node is actually a good candidate for a match
-    if(curr_prefix_len == key_prefix_len){
-      //this an exact match, do not continue
-      break;
-    }
-
-    bool bit;
-    int res = nameBitvector_testBit(name, curr_prefix_len, &bit);
-    parcAssertFalse(res < 0, "error testing name bit (fib_MatchBitvector)");
-
-    if(bit)
-      curr = curr->right;
-    else
-      curr = curr->left;
-  }
-
-  if(candidate != NULL){
-    return candidate->entry;
-  }
-
-  return NULL;
-}
-
-void _collectFibEntries(FibNode *n, FibEntryList *list){
-  if(n != NULL){
-    if(n->is_used)
-      fibEntryList_Append(list, n->entry);
-    _collectFibEntries(n->right, list);
-    _collectFibEntries(n->left, list);
-  }
-}
-
-FibEntryList *fib_GetEntries(const FIB *fib) {
-  parcAssertNotNull(fib, "Parameter must be non-null");
-  FibEntryList *list = fibEntryList_Create();
-
-  _collectFibEntries(fib->root, list);
-
-  return list;
-}
diff --git a/hicn-light/src/hicn/processor/fib.h b/hicn-light/src/hicn/processor/fib.h
deleted file mode 100644
index ef9e121b8..000000000
--- a/hicn-light/src/hicn/processor/fib.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * 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 fib_h
-#define fib_h
-
-#include <hicn/core/message.h>
-#include <hicn/core/name.h>
-#include <hicn/processor/fibEntry.h>
-#include <hicn/processor/fibEntryList.h>
-
-struct fib;
-typedef struct fib FIB;
-
-FIB *fib_Create(Forwarder *forwarder);
-
-void fib_Destroy(FIB **fibPtr);
-
-void fib_Add(FIB *fib, FibEntry *node);
-
-FibEntry *fib_Contains(const FIB *fib, const Name *prefix);
-
-void fib_Remove(FIB *fib, const Name *prefix, unsigned connId);
-
-void fib_RemoveConnectionId(FIB *fib, unsigned connectionId);
-
-FibEntry *fib_MatchMessage(const FIB *fib, const Message *interestMessage);
-FibEntry *fib_MatchName(const FIB *fib, const Name *name);
-FibEntry *fib_MatchBitvector(const FIB *fib, const NameBitvector *name);
-
-size_t fib_Length(const FIB *fib);
-
-FibEntryList *fib_GetEntries(const FIB *fib);
-#endif  // fib_h
diff --git a/hicn-light/src/hicn/processor/fibEntry.c b/hicn-light/src/hicn/processor/fibEntry.c
deleted file mode 100644
index 00e8dfa11..000000000
--- a/hicn-light/src/hicn/processor/fibEntry.c
+++ /dev/null
@@ -1,894 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <hicn/core/numberSet.h>
-#include <hicn/processor/fibEntry.h>
-
-#include <hicn/core/nameBitvector.h>
-
-#include <hicn/strategies/loadBalancer.h>
-#include <hicn/strategies/lowLatency.h>
-#include <hicn/strategies/rnd.h>
-#include <hicn/strategies/strategyImpl.h>
-#ifdef WITH_MAPME
-#include <parc/algol/parc_HashMap.h>
-#include <hicn/core/ticks.h>
-#endif /* WITH_MAPME */
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/core/connectionState.h>
-
-#ifdef WITH_POLICY
-#include <hicn/core/forwarder.h>
-#include <hicn/policy.h>
-
-#ifdef WITH_MAPME
-#include <hicn/core/mapme.h>
-#endif /* WITH_MAPME */
-
-#define ALPHA 0.5
-
-#endif /* WITH_POLICY */
-
-struct fib_entry {
-  Name *name;
-  unsigned refcount;
-  StrategyImpl *fwdStrategy;
-#ifdef WITH_POLICY
-  NumberSet *nexthops;
-  const Forwarder * forwarder;
-  hicn_policy_t policy;
-  policy_counters_t policy_counters;
-//  NumberSet *available_nexthops;
-#ifdef WITH_MAPME
-  /* In case of no multipath, this stores the previous decision taken by policy */
-#endif /* WITH_MAPME */
-#endif /* WITH_POLICY */
-#ifdef WITH_MAPME
-  NumberSet * previous_nexthops;
-  const void *userDataOwner;
-  void *userData;
-  void (*userDataRelease)(const void *owner, void **userData);
-#endif /* WITH_MAPME */
-};
-
-#ifdef WITH_POLICY
-FibEntry *fibEntry_Create(Name *name, strategy_type fwdStrategy, const Forwarder * forwarder) {
-#else
-FibEntry *fibEntry_Create(Name *name, strategy_type fwdStrategy) {
-#endif /* WITH_POLICY */
-  FibEntry *fibEntry = parcMemory_AllocateAndClear(sizeof(FibEntry));
-  parcAssertNotNull(fibEntry, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(FibEntry));
-  fibEntry->name = name_Acquire(name);
-
-  switch (fwdStrategy) {
-    case SET_STRATEGY_LOADBALANCER:
-      fibEntry->fwdStrategy = strategyLoadBalancer_Create();
-      break;
-
-    case SET_STRATEGY_RANDOM:
-      fibEntry->fwdStrategy = strategyRnd_Create();
-
-    case SET_STRATEGY_LOW_LATENCY:
-      fibEntry->fwdStrategy = strategyLowLatency_Create();
-      break;
-
-    default:
-      // LB is the default strategy
-      fwdStrategy = SET_STRATEGY_LOADBALANCER;
-      fibEntry->fwdStrategy = strategyLoadBalancer_Create();
-      break;
-  }
-
-  fibEntry->refcount = 1;
-
-#ifdef WITH_MAPME
-  fibEntry->userDataOwner = NULL;
-  fibEntry->userData = NULL;
-  fibEntry->userDataRelease = NULL;
-#endif /* WITH_MAPME */
-
-#ifdef WITH_POLICY
-  fibEntry->nexthops = numberSet_Create();
-  fibEntry->forwarder = forwarder;
-  fibEntry->policy = POLICY_NONE;
-  fibEntry->policy_counters = POLICY_COUNTERS_NONE;
-#endif /* WITH_POLICY */
-
-  if(fwdStrategy == SET_STRATEGY_LOW_LATENCY){
-    strategyLowLatency_SetStrategy(fibEntry->fwdStrategy,
-                                     fibEntry->forwarder, fibEntry,
-                                     0, NULL);
-  }
-  return fibEntry;
-}
-
-FibEntry *fibEntry_Acquire(const FibEntry *fibEntry) {
-  parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null");
-  FibEntry *copy = (FibEntry *)fibEntry;
-  copy->refcount++;
-  return copy;
-}
-
-void fibEntry_Release(FibEntry **fibEntryPtr) {
-  FibEntry *fibEntry = *fibEntryPtr;
-  parcAssertTrue(fibEntry->refcount > 0, "Illegal state: refcount is 0");
-  fibEntry->refcount--;
-  if (fibEntry->refcount == 0) {
-    name_Release(&fibEntry->name);
-    fibEntry->fwdStrategy->destroy(&(fibEntry->fwdStrategy));
-#ifdef WITH_MAPME
-    if (fibEntry->userData) {
-      fibEntry->userDataRelease(fibEntry->userDataOwner, &fibEntry->userData);
-    }
-#endif /* WITH_MAPME */
-#ifdef WITH_POLICY
-  numberSet_Release(&fibEntry->nexthops);
-#endif /* WITH_POLICY */
-    parcMemory_Deallocate((void **)&fibEntry);
-  }
-  *fibEntryPtr = NULL;
-}
-
-void fibEntry_SetStrategy(FibEntry *fibEntry, strategy_type strategy,
-                          unsigned related_prefixes_len,
-                          Name **related_prefixes) {
-  StrategyImpl *fwdStrategyImpl;
-
-  switch (strategy) {
-    case SET_STRATEGY_LOADBALANCER:
-      fwdStrategyImpl = strategyLoadBalancer_Create();
-      break;
-
-    case SET_STRATEGY_RANDOM:
-      fwdStrategyImpl = strategyRnd_Create();
-      break;
-
-    case SET_STRATEGY_LOW_LATENCY:
-      fwdStrategyImpl = strategyLowLatency_Create();
-      break;
-
-    default:
-      // LB is the default strategy
-      strategy = SET_STRATEGY_LOADBALANCER;
-      fwdStrategyImpl = strategyLoadBalancer_Create();
-      break;
-    }
-
-  if(strategy == SET_STRATEGY_LOW_LATENCY){
-    strategyLowLatency_SetStrategy(fwdStrategyImpl,
-                       fibEntry->forwarder, fibEntry,
-                       related_prefixes_len, related_prefixes);
-  }
-
-  const NumberSet *nexthops = fibEntry_GetNexthops(fibEntry);
-  unsigned size = (unsigned)fibEntry_NexthopCount(fibEntry);
-  for (unsigned i = 0; i < size; i++) {
-    fwdStrategyImpl->addNexthop(fwdStrategyImpl,
-                                numberSet_GetItem(nexthops, i));
-  }
-  fibEntry->fwdStrategy->destroy(&(fibEntry->fwdStrategy));
-  fibEntry->fwdStrategy = fwdStrategyImpl;
-}
-
-#ifdef WITH_POLICY
-
-/*
- * Update available next hops following policy update.
- */
-NumberSet *
-fibEntry_GetAvailableNextHops(const FibEntry *fibEntry, unsigned in_connection) {
-  ConnectionTable * table = forwarder_GetConnectionTable(fibEntry->forwarder);
-  NumberSet * nexthops;
-  bool dealloc_nexthops = false;
-  hicn_policy_t policy = fibEntry_GetPolicy(fibEntry);
-
-  /* Reset available next hops and start filtering */
-  NumberSet * available_nexthops = numberSet_Create();
-
-  /*
-   * Give absolute preference to local faces, with no policy, unless
-   * in_connection == ~0, which means we are searching faces on which to
-   * advertise our prefix
-   */
-  if (in_connection == ~0) {
-    /* We might advertise among all available up connections */
-    nexthops = numberSet_Create();
-    dealloc_nexthops = true;
-
-    ConnectionList * list = connectionTable_GetEntries(table);
-    for (size_t i = 0; i < connectionList_Length(list); i++) {
-      Connection *conn = connectionList_Get(list, i);
-      if (connection_IsLocal(conn))
-        continue;
-      if (connection_GetAdminState(conn) == CONNECTION_STATE_DOWN)
-        continue;
-      if (connection_GetState(conn) == CONNECTION_STATE_DOWN)
-        continue;
-      numberSet_Add(nexthops, connection_GetConnectionId(conn));
-    }
-    connectionList_Destroy(&list);
-  } else {
-    nexthops = (NumberSet*)fibEntry_GetNexthops(fibEntry);
-    for (size_t k = 0; k < numberSet_Length(nexthops); k++) {
-      unsigned conn_id = numberSet_GetItem(nexthops, k);
-      /* Filtering out ingress face */
-      if (conn_id == in_connection)
-        continue;
-      /* Filtering out DOWN faces */
-      const Connection *  conn = connectionTable_FindById(table, conn_id);
-      if (!conn)
-        continue;
-      if (connection_GetAdminState(conn) == CONNECTION_STATE_DOWN)
-        continue;
-      if (connection_GetState(conn) == CONNECTION_STATE_DOWN)
-        continue;
-      if (!connection_IsLocal(conn))
-        continue;
-      numberSet_Add(available_nexthops, conn_id);
-    }
-
-    /* Terminate selection if there are any local face available */
-    if (numberSet_Length(available_nexthops) > 0){
-      if(dealloc_nexthops){
-        numberSet_Release(&nexthops);
-      }
-      /* No filtering as all local faces are considered equivalent */
-      return available_nexthops;
-    }
-  }
-
-  for (size_t k = 0; k < numberSet_Length(nexthops); k++) {
-    unsigned conn_id = numberSet_GetItem(nexthops, k);
-    const Connection * conn;
-
-    /* Filtering out ingress face */
-    if (conn_id == in_connection)
-      continue;
-
-    /* Filtering out DOWN faces */
-    conn = connectionTable_FindById(table, conn_id);
-    if (!conn)
-      continue;
-    if (connection_GetAdminState(conn) == CONNECTION_STATE_DOWN)
-      continue;
-    if (connection_GetState(conn) == CONNECTION_STATE_DOWN)
-      continue;
-
-    /* Policy filtering : next hops */
-    if ((policy.tags[POLICY_TAG_WIRED].state == POLICY_STATE_REQUIRE) &&
-        (!connection_HasTag(conn, POLICY_TAG_WIRED)))
-      continue;
-    if ((policy.tags[POLICY_TAG_WIRED].state == POLICY_STATE_PROHIBIT) &&
-        (connection_HasTag(conn, POLICY_TAG_WIRED)))
-      continue;
-    if ((policy.tags[POLICY_TAG_WIFI].state == POLICY_STATE_REQUIRE) &&
-        (!connection_HasTag(conn, POLICY_TAG_WIFI)))
-      continue;
-    if ((policy.tags[POLICY_TAG_WIFI].state == POLICY_STATE_PROHIBIT) &&
-        (connection_HasTag(conn, POLICY_TAG_WIFI)))
-      continue;
-    if ((policy.tags[POLICY_TAG_CELLULAR].state == POLICY_STATE_REQUIRE) &&
-        (!connection_HasTag(conn, POLICY_TAG_CELLULAR)))
-      continue;
-    if ((policy.tags[POLICY_TAG_CELLULAR].state == POLICY_STATE_PROHIBIT) &&
-        (connection_HasTag(conn, POLICY_TAG_CELLULAR)))
-      continue;
-    if ((policy.tags[POLICY_TAG_TRUSTED].state == POLICY_STATE_REQUIRE) &&
-        (!connection_HasTag(conn, POLICY_TAG_TRUSTED)))
-      continue;
-    if ((policy.tags[POLICY_TAG_TRUSTED].state == POLICY_STATE_PROHIBIT) &&
-        (connection_HasTag(conn, POLICY_TAG_TRUSTED)))
-      continue;
-
-    numberSet_Add(available_nexthops, conn_id);
-  }
-
-  if(dealloc_nexthops)
-    numberSet_Release(&nexthops);
-
-  if (numberSet_Length(available_nexthops) == 0)
-    return available_nexthops;
-
-  /* We have at least one matching next hop, implement heuristic */
-
-  /*
-   * As VPN connections might trigger duplicate uses of one interface, we start
-   * by filtering out interfaces based on trust status.
-   */
-  NumberSet * filtered_nexthops = numberSet_Create();
-  if ((policy.tags[POLICY_TAG_TRUSTED].state == POLICY_STATE_REQUIRE) ||
-      (policy.tags[POLICY_TAG_TRUSTED].state == POLICY_STATE_PREFER)) {
-    /* Try to filter out NON TRUSTED faces */
-    for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) {
-      unsigned conn_id = numberSet_GetItem(available_nexthops, k);
-      const Connection * conn = connectionTable_FindById(table, conn_id);
-      if (!connection_HasTag(conn, POLICY_TAG_TRUSTED))
-          continue;
-      numberSet_Add(filtered_nexthops, conn_id);
-    }
-  } else {
-      /* Try to filter out TRUSTED faces */
-    for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) {
-      unsigned conn_id = numberSet_GetItem(available_nexthops, k);
-      const Connection * conn = connectionTable_FindById(table, conn_id);
-      if (connection_HasTag(conn, POLICY_TAG_TRUSTED))
-          continue;
-      numberSet_Add(filtered_nexthops, conn_id);
-    }
-  }
-  if (numberSet_Length(filtered_nexthops) > 0) {
-    numberSet_Release(&available_nexthops);
-    available_nexthops = numberSet_Create();
-    numberSet_AddSet(available_nexthops, filtered_nexthops);
-  }
-  numberSet_Release(&filtered_nexthops);
-
-  /* Other preferences */
-  if (policy.tags[POLICY_TAG_WIRED].state == POLICY_STATE_AVOID) {
-    filtered_nexthops = numberSet_Create();
-    for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) {
-      unsigned conn_id = numberSet_GetItem(available_nexthops, k);
-      const Connection * conn = connectionTable_FindById(table, conn_id);
-      if (connection_HasTag(conn, POLICY_TAG_WIRED))
-          continue;
-      numberSet_Add(filtered_nexthops, conn_id);
-    }
-    if (numberSet_Length(filtered_nexthops) > 0) {
-        numberSet_Release(&available_nexthops);
-        available_nexthops = numberSet_Create();
-        numberSet_AddSet(available_nexthops, filtered_nexthops);
-    }
-    numberSet_Release(&filtered_nexthops);
-  }
-  if (policy.tags[POLICY_TAG_WIFI].state == POLICY_STATE_AVOID) {
-    filtered_nexthops = numberSet_Create();
-    for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) {
-      unsigned conn_id = numberSet_GetItem(available_nexthops, k);
-      const Connection * conn = connectionTable_FindById(table, conn_id);
-      if (connection_HasTag(conn, POLICY_TAG_WIFI))
-          continue;
-      numberSet_Add(filtered_nexthops, conn_id);
-    }
-    if (numberSet_Length(filtered_nexthops) > 0) {
-        numberSet_Release(&available_nexthops);
-        available_nexthops = numberSet_Create();
-        numberSet_AddSet(available_nexthops, filtered_nexthops);
-    }
-    numberSet_Release(&filtered_nexthops);
-  }
-  if (policy.tags[POLICY_TAG_CELLULAR].state == POLICY_STATE_AVOID) {
-    filtered_nexthops = numberSet_Create();
-    for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) {
-      unsigned conn_id = numberSet_GetItem(available_nexthops, k);
-      const Connection * conn = connectionTable_FindById(table, conn_id);
-      if (connection_HasTag(conn, POLICY_TAG_CELLULAR))
-          continue;
-      numberSet_Add(filtered_nexthops, conn_id);
-    }
-    if (numberSet_Length(filtered_nexthops) > 0) {
-        numberSet_Release(&available_nexthops);
-        available_nexthops = numberSet_Create();
-        numberSet_AddSet(available_nexthops, filtered_nexthops);
-    }
-    numberSet_Release(&filtered_nexthops);
-  }
-
-  if (policy.tags[POLICY_TAG_WIRED].state == POLICY_STATE_PREFER) {
-    filtered_nexthops = numberSet_Create();
-    for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) {
-      unsigned conn_id = numberSet_GetItem(available_nexthops, k);
-      const Connection * conn = connectionTable_FindById(table, conn_id);
-      if (!connection_HasTag(conn, POLICY_TAG_WIRED))
-          continue;
-      numberSet_Add(filtered_nexthops, conn_id);
-    }
-    if (numberSet_Length(filtered_nexthops) > 0) {
-        numberSet_Release(&available_nexthops);
-        available_nexthops = numberSet_Create();
-        numberSet_AddSet(available_nexthops, filtered_nexthops);
-    }
-    numberSet_Release(&filtered_nexthops);
-  }
-  if (policy.tags[POLICY_TAG_WIFI].state == POLICY_STATE_PREFER) {
-    filtered_nexthops = numberSet_Create();
-    for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) {
-      unsigned conn_id = numberSet_GetItem(available_nexthops, k);
-      const Connection * conn = connectionTable_FindById(table, conn_id);
-      if (!connection_HasTag(conn, POLICY_TAG_WIFI))
-          continue;
-      numberSet_Add(filtered_nexthops, conn_id);
-    }
-    if (numberSet_Length(filtered_nexthops) > 0) {
-        numberSet_Release(&available_nexthops);
-        available_nexthops = numberSet_Create();
-        numberSet_AddSet(available_nexthops, filtered_nexthops);
-    }
-    numberSet_Release(&filtered_nexthops);
-  }
-  if (policy.tags[POLICY_TAG_CELLULAR].state == POLICY_STATE_PREFER) {
-    filtered_nexthops = numberSet_Create();
-    for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) {
-      unsigned conn_id = numberSet_GetItem(available_nexthops, k);
-      const Connection * conn = connectionTable_FindById(table, conn_id);
-      if (!connection_HasTag(conn, POLICY_TAG_CELLULAR))
-          continue;
-      numberSet_Add(filtered_nexthops, conn_id);
-    }
-    if (numberSet_Length(filtered_nexthops) > 0) {
-        numberSet_Release(&available_nexthops);
-        available_nexthops = numberSet_Create();
-        numberSet_AddSet(available_nexthops, filtered_nexthops);
-    }
-    numberSet_Release(&filtered_nexthops);
-  }
-
-  /* Priority */
-  NumberSet * priority_nexthops = numberSet_Create();
-
-  uint32_t max_priority = 0;
-  for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) {
-    unsigned conn_id = numberSet_GetItem(available_nexthops, k);
-    const Connection * conn = connectionTable_FindById(table, conn_id);
-    uint32_t priority = connection_GetPriority(conn);
-    if (priority < max_priority) {
-        continue;
-    } else if (priority == max_priority) {
-      numberSet_Add(priority_nexthops, conn_id);
-    } else { /* priority > max_priority */
-      numberSet_Release(&priority_nexthops);
-      priority_nexthops = numberSet_Create();
-      numberSet_Add(priority_nexthops, conn_id);
-      max_priority = priority;
-    }
-  }
-
-  numberSet_Release(&available_nexthops);
-
-  return priority_nexthops;
-}
-
-hicn_policy_t fibEntry_GetPolicy(const FibEntry *fibEntry) {
-  return fibEntry->policy;
-}
-
-void fibEntry_SetPolicy(FibEntry *fibEntry, hicn_policy_t policy) {
-  fibEntry->policy = policy;
-  mapme_reconsiderFibEntry(forwarder_getMapmeInstance(fibEntry->forwarder), fibEntry);
-}
-
-NumberSet *
-fibEntry_GetPreviousNextHops(const FibEntry *fibEntry)
-{
-    return fibEntry->previous_nexthops;
-}
-#endif /* WITH_POLICY */
-
-void
-fibEntry_SetPreviousNextHops(FibEntry *fibEntry, const NumberSet * nexthops)
-{
-    if (fibEntry->previous_nexthops)
-        numberSet_Release(&fibEntry->previous_nexthops);
-    fibEntry->previous_nexthops = numberSet_Create();
-    numberSet_AddSet(fibEntry->previous_nexthops, nexthops);
-}
-
-
-void fibEntry_AddNexthop(FibEntry *fibEntry, unsigned connectionId) {
-  parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null");
-#ifdef WITH_POLICY
-  if (!numberSet_Contains(fibEntry->nexthops, connectionId)) {
-    numberSet_Add(fibEntry->nexthops, connectionId);
-  }
-#endif /* WITH_POLICY */
-  fibEntry->fwdStrategy->addNexthop(fibEntry->fwdStrategy, connectionId);
-}
-
-void fibEntry_RemoveNexthopByConnectionId(FibEntry *fibEntry,
-                                          unsigned connectionId) {
-  parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null");
-#ifdef WITH_POLICY
-  if (numberSet_Contains(fibEntry->nexthops, connectionId)) {
-    numberSet_Remove(fibEntry->nexthops, connectionId);
-  }
-#endif /* WITH_POLICY */
-  fibEntry->fwdStrategy->removeNexthop(fibEntry->fwdStrategy, connectionId);
-}
-
-size_t fibEntry_NexthopCount(const FibEntry *fibEntry) {
-  parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null");
-#ifdef WITH_POLICY
-  return numberSet_Length(fibEntry->nexthops);
-#else
-  return fibEntry->fwdStrategy->countNexthops(fibEntry->fwdStrategy);
-#endif /* WITH_POLICY */
-}
-
-const NumberSet *fibEntry_GetNexthops(const FibEntry *fibEntry) {
-  parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null");
-#ifdef WITH_POLICY
-  return fibEntry->nexthops;
-#else
-  return fibEntry->fwdStrategy->returnNexthops(fibEntry->fwdStrategy);
-#endif /* WITH_POLICY */
-}
-
-const NumberSet *fibEntry_GetNexthopsFromForwardingStrategy(
-#ifdef WITH_POLICY
-    FibEntry *fibEntry, const Message *interestMessage, bool is_retransmission) {
-#else
-    const FibEntry *fibEntry, const Message *interestMessage) {
-#endif /* WITH_POLICY */
-  parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null");
-#ifdef WITH_POLICY
-  ConnectionTable * table = forwarder_GetConnectionTable(fibEntry->forwarder);
-  unsigned in_connection = message_GetIngressConnectionId(interestMessage);
-
-  hicn_policy_t policy = fibEntry_GetPolicy(fibEntry);
-
-  NumberSet * out;
-
-  /* Filtering */
-  NumberSet * available_nexthops = fibEntry_GetAvailableNextHops(fibEntry, in_connection);
-  if (numberSet_Length(available_nexthops) == 0) {
-    numberSet_Release(&available_nexthops);
-    out = numberSet_Create();
-    return out;
-  }
-
-  /*
-   * Update statistics about loss rates. We only detect losses upon
-   * retransmissions, and assume for the computation that the candidate set of
-   * output faces is the same as previously (i.e. does not take into account
-   * event such as face up/down, policy update, etc. Otherwise we would need to
-   * know what was the previous choice !
-   */
-  if (is_retransmission) {
-    for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) {
-      unsigned conn_id = numberSet_GetItem(available_nexthops, k);
-      const Connection * conn = connectionTable_FindById(table, conn_id);
-
-      if (connection_HasTag(conn, POLICY_TAG_WIRED))
-        fibEntry->policy_counters.wired.num_losses++;
-      if (connection_HasTag(conn, POLICY_TAG_WIFI))
-        fibEntry->policy_counters.wifi.num_losses++;
-      if (connection_HasTag(conn, POLICY_TAG_CELLULAR))
-        fibEntry->policy_counters.cellular.num_losses++;
-      fibEntry->policy_counters.all.num_losses++;
-    }
-  }
-
-  /*
-   * NOTE: We might want to call a forwarding strategy even with no nexthop to
-   * take a fallback decision.
-   */
-  if (numberSet_Length(available_nexthops) == 0) {
-    out = numberSet_Create();
-  } else {
-    /* Multipath */
-    if ((policy.tags[POLICY_TAG_MULTIPATH].state != POLICY_STATE_PROHIBIT) &&
-        (policy.tags[POLICY_TAG_MULTIPATH].state != POLICY_STATE_AVOID)) {
-      out = fibEntry->fwdStrategy->lookupNexthop(fibEntry->fwdStrategy, available_nexthops,
-          interestMessage);
-    } else {
-      unsigned nexthop = numberSet_GetItem(available_nexthops, 0);
-      out = numberSet_Create();
-      numberSet_Add(out, nexthop);
-    }
-  }
-
-  numberSet_Release(&available_nexthops);
-
-  return out;
-#else
-  return fibEntry->fwdStrategy->lookupNexthop(fibEntry->fwdStrategy,
-          interestMessage);
-#endif /* WITH_POLICY */
-}
-
-#ifdef WITH_POLICY
-void fibEntry_ReceiveObjectMessage(FibEntry *fibEntry,
-#else
-void fibEntry_ReceiveObjectMessage(const FibEntry *fibEntry,
-#endif /* WITH_POLICY */
-                                   const NumberSet *egressId,
-                                   const Message *objectMessage,
-                                   Ticks pitEntryCreation,
-                                   Ticks objReception) {
-  parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null");
-
-#ifdef WITH_POLICY
-  ConnectionTable * table = forwarder_GetConnectionTable(fibEntry->forwarder);
-
-  /* Update statistic counters : */
-
-  size_t msg_size = message_Length(objectMessage);
-  Ticks rtt = objReception - pitEntryCreation;
-
-  for (unsigned i = 0; i < numberSet_Length(egressId); i++) {
-    unsigned conn_id = numberSet_GetItem(egressId, i);
-    const Connection * conn = connectionTable_FindById(table, conn_id);
-    if (!conn)
-      continue;
-    if (connection_HasTag(conn, POLICY_TAG_WIRED)) {
-      fibEntry->policy_counters.wired.num_packets++;
-      fibEntry->policy_counters.wired.num_bytes += (uint32_t)msg_size;
-      fibEntry->policy.stats.wired.latency = (float) (\
-                      ALPHA       * fibEntry->policy.stats.wired.latency + \
-                      (1 - ALPHA) * (double)rtt);
-      fibEntry->policy_counters.wired.latency_idle = 0;
-    }
-    if (connection_HasTag(conn, POLICY_TAG_WIFI)) {
-      fibEntry->policy_counters.wifi.num_packets++;
-      fibEntry->policy_counters.wifi.num_bytes += (uint32_t)msg_size;
-      fibEntry->policy.stats.wifi.latency = (float)(\
-                      ALPHA       * fibEntry->policy.stats.wifi.latency + \
-                      (1 - ALPHA) * (double)rtt);
-      fibEntry->policy_counters.wifi.latency_idle = 0;
-
-    }
-    if (connection_HasTag(conn, POLICY_TAG_CELLULAR)) {
-      fibEntry->policy_counters.cellular.num_packets++;
-      fibEntry->policy_counters.cellular.num_bytes += (uint32_t)msg_size;
-      fibEntry->policy.stats.cellular.latency = (float)(\
-                      ALPHA       * fibEntry->policy.stats.cellular.latency + \
-                      (1 - ALPHA) * (double)rtt);
-      fibEntry->policy_counters.cellular.latency_idle = 0;
-    }
-  }
-
-  fibEntry->policy.stats.all.latency = (float)(\
-                    ALPHA       * fibEntry->policy.stats.all.latency + \
-                    (1 - ALPHA) * (double)rtt);
-  fibEntry->policy_counters.all.latency_idle = 0;
-
-  fibEntry->policy_counters.all.num_packets++;
-  fibEntry->policy_counters.all.num_bytes += (uint32_t)msg_size;
-
-#endif /* WITH_POLICY */
-
-  fibEntry->fwdStrategy->receiveObject(fibEntry->fwdStrategy, egressId,
-                                       objectMessage, pitEntryCreation, objReception);
-}
-
-#ifdef WITH_POLICY
-void fibEntry_OnTimeout(FibEntry *fibEntry, const NumberSet *egressId) {
-#else
-void fibEntry_OnTimeout(const FibEntry *fibEntry, const NumberSet *egressId) {
-#endif /* WITH_POLICY */
-  parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null");
-
-#ifdef WITH_POLICY
-
-  ConnectionTable * table = forwarder_GetConnectionTable(fibEntry->forwarder);
-
-  for (unsigned i = 0; i < numberSet_Length(egressId); i++) {
-    unsigned conn_id = numberSet_GetItem(egressId, i);
-    const Connection * conn = connectionTable_FindById(table, conn_id);
-    if (!conn)
-      continue;
-    if (connection_HasTag(conn, POLICY_TAG_WIRED)) {
-      fibEntry->policy_counters.wired.num_losses++;
-    }
-    if (connection_HasTag(conn, POLICY_TAG_WIFI)) {
-      fibEntry->policy_counters.wifi.num_losses++;
-    }
-    if (connection_HasTag(conn, POLICY_TAG_CELLULAR)) {
-      fibEntry->policy_counters.cellular.num_losses++;
-    }
-  }
-
-  fibEntry->policy_counters.all.num_losses++;
-
-#endif /* WITH_POLICY */
-
-  fibEntry->fwdStrategy->onTimeout(fibEntry->fwdStrategy, egressId);
-}
-
-#ifdef WITH_POLICY
-void fibEntry_UpdateStats(FibEntry *fibEntry, uint64_t now) {
-  double throughput;
-  double loss_rate;
-
-  if (now == fibEntry->policy_counters.last_update)
-      return ;
-
-  /* WIRED */
-
-  /*  a) throughput */
-  if (fibEntry->policy_counters.wired.num_bytes > 0) {
-    throughput = (float)(fibEntry->policy_counters.wired.num_bytes / \
-          (now - fibEntry->policy_counters.last_update)) ;
-    throughput = throughput * 8 / 1024;
-    if (throughput < 0)
-        throughput = 0;
-  } else {
-    throughput = 0;
-  }
-  fibEntry->policy.stats.wired.throughput = (float)(\
-        ALPHA     * fibEntry->policy.stats.wired.throughput + \
-        (1-ALPHA) * throughput);
-
-  /* b) loss rate */
-  if ((fibEntry->policy_counters.wired.num_losses > 0) && \
-          (fibEntry->policy_counters.wired.num_packets > 0)){
-      loss_rate = fibEntry->policy_counters.wired.num_losses / \
-            fibEntry->policy_counters.wired.num_packets;
-      loss_rate *= 100;
-  } else {
-      loss_rate = 0;
-  }
-  fibEntry->policy.stats.wired.loss_rate = (float)(\
-        ALPHA     * fibEntry->policy.stats.wired.loss_rate + \
-        (1-ALPHA) * loss_rate);
-
-  /* Latency */
-  fibEntry->policy_counters.wired.latency_idle++;
-  if (fibEntry->policy_counters.wired.latency_idle > 1)
-      fibEntry->policy.stats.wired.latency = 0;
-  fibEntry->policy_counters.wifi.latency_idle++;
-  if (fibEntry->policy_counters.wifi.latency_idle > 1)
-      fibEntry->policy.stats.wifi.latency = 0;
-  fibEntry->policy_counters.cellular.latency_idle++;
-  if (fibEntry->policy_counters.cellular.latency_idle > 1)
-      fibEntry->policy.stats.cellular.latency = 0;
-  fibEntry->policy_counters.all.latency_idle++;
-  if (fibEntry->policy_counters.all.latency_idle > 1)
-      fibEntry->policy.stats.all.latency = 0;
-
-  fibEntry->policy_counters.wired.num_bytes = 0;
-  fibEntry->policy_counters.wired.num_losses = 0;
-  fibEntry->policy_counters.wired.num_packets = 0;
-
-  /* WIFI */
-
-  /*  a) throughput */
-  if (fibEntry->policy_counters.wifi.num_bytes > 0) {
-    throughput = (float)(fibEntry->policy_counters.wifi.num_bytes / \
-          (now - fibEntry->policy_counters.last_update));
-    throughput = throughput * 8 / 1024;
-    if (throughput < 0)
-        throughput = 0;
-  } else {
-    throughput = 0;
-  }
-  fibEntry->policy.stats.wifi.throughput = (float)( \
-        ALPHA     * fibEntry->policy.stats.wifi.throughput + \
-        (1-ALPHA) * throughput);
-
-  /* b) loss rate */
-  if ((fibEntry->policy_counters.wifi.num_losses > 0) && \
-          (fibEntry->policy_counters.wifi.num_packets > 0)) {
-    loss_rate = fibEntry->policy_counters.wifi.num_losses / \
-          fibEntry->policy_counters.wifi.num_packets;
-      loss_rate *= 100;
-  } else {
-      loss_rate = 0;
-  }
-  fibEntry->policy.stats.wifi.loss_rate = (float)(\
-        ALPHA     * fibEntry->policy.stats.wifi.loss_rate + \
-        (1-ALPHA) * loss_rate);
-
-  fibEntry->policy_counters.wifi.num_bytes = 0;
-  fibEntry->policy_counters.wifi.num_losses = 0;
-  fibEntry->policy_counters.wifi.num_packets = 0;
-
-  /* CELLULAR */
-
-  /*  a) throughput */
-  if (fibEntry->policy_counters.cellular.num_bytes > 0) {
-    throughput = (float)(fibEntry->policy_counters.cellular.num_bytes / \
-          (now - fibEntry->policy_counters.last_update)) ;
-    throughput = throughput * 8 / 1024;
-    if (throughput < 0)
-        throughput = 0;
-  } else {
-    throughput = 0;
-  }
-  fibEntry->policy.stats.cellular.throughput = (float)( \
-        ALPHA     * fibEntry->policy.stats.cellular.throughput + \
-        (1-ALPHA) * throughput);
-
-  /* b) loss rate */
-  if ((fibEntry->policy_counters.cellular.num_losses > 0) && \
-          (fibEntry->policy_counters.cellular.num_packets > 0)) {
-    loss_rate = fibEntry->policy_counters.cellular.num_losses / \
-          fibEntry->policy_counters.cellular.num_packets;
-      loss_rate *= 100;
-  } else {
-      loss_rate = 0;
-  }
-  fibEntry->policy.stats.cellular.loss_rate = (float)( \
-        ALPHA     * fibEntry->policy.stats.cellular.loss_rate + \
-        (1-ALPHA) * loss_rate);
-
-  fibEntry->policy_counters.cellular.num_bytes = 0;
-  fibEntry->policy_counters.cellular.num_losses = 0;
-  fibEntry->policy_counters.cellular.num_packets = 0;
-
-  /* ALL */
-
-  /*  a) throughput */
-  if (fibEntry->policy_counters.all.num_bytes > 0) {
-    throughput = (float)( fibEntry->policy_counters.all.num_bytes / \
-          (now - fibEntry->policy_counters.last_update));
-    throughput = throughput * 8 / 1024;
-    if (throughput < 0)
-        throughput = 0;
-  } else {
-    throughput = 0;
-  }
-  fibEntry->policy.stats.all.throughput = (float)(\
-        ALPHA     * fibEntry->policy.stats.all.throughput + \
-        (1-ALPHA) * throughput);
-
-  /* b) loss rate */
-  if ((fibEntry->policy_counters.all.num_losses > 0) && \
-          (fibEntry->policy_counters.all.num_packets > 0)) {
-    loss_rate = fibEntry->policy_counters.all.num_losses / \
-          fibEntry->policy_counters.all.num_packets;
-      loss_rate *= 100;
-  } else {
-      loss_rate = 0;
-  }
-  fibEntry->policy.stats.all.loss_rate = (float)(\
-        ALPHA     * fibEntry->policy.stats.all.loss_rate + \
-        (1-ALPHA) * loss_rate);
-
-  fibEntry->policy_counters.all.num_bytes = 0;
-  fibEntry->policy_counters.all.num_losses = 0;
-  fibEntry->policy_counters.all.num_packets = 0;
-
-  fibEntry->policy_counters.last_update = now;
-}
-#endif /* WITH_POLICY */
-
-Name *fibEntry_GetPrefix(const FibEntry *fibEntry) {
-  parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null");
-  return fibEntry->name;
-  // return metisName_Acquire(fibEntry->name);
-}
-
-strategy_type fibEntry_GetFwdStrategyType(const FibEntry *fibEntry) {
-  return fibEntry->fwdStrategy->getStrategy(fibEntry->fwdStrategy);
-}
-
-StrategyImpl *fibEntry_GetFwdStrategy(const FibEntry *fibEntry) {
-  return fibEntry->fwdStrategy;
-}
-
-#ifdef WITH_MAPME
-
-void *fibEntry_getUserData(const FibEntry *fibEntry) {
-  parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null");
-  return fibEntry->userData;
-}
-
-void fibEntry_setUserData(FibEntry *fibEntry, const void *userDataOwner, const
-        void *userData, void (*userDataRelease)(const void *, void **)) {
-  parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null");
-  fibEntry->userDataOwner = userDataOwner;
-  fibEntry->userData = (void *)userData;
-  fibEntry->userDataRelease = userDataRelease;
-}
-
-#endif /* WITH_MAPME */
diff --git a/hicn-light/src/hicn/processor/fibEntry.h b/hicn-light/src/hicn/processor/fibEntry.h
deleted file mode 100644
index cf267d6a6..000000000
--- a/hicn-light/src/hicn/processor/fibEntry.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * 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 fibEntry.h
- * @brief A forwarding entry in the FIB table
- *
- * A Forwarding Information Base (FIB) entry (FibEntry) is a
- * set of nexthops for a name.  It also indicates the forwarding strategy.
- *
- * Each nexthop contains the ConnectionId assocaited with it.  This could be
- * something specific like a MAC address or point-to-point tunnel.  Or, it
- * could be something general like a MAC group address or ip multicast overlay.
- *
- * See strategy.h for a description of forwarding strategies.
- * In short, a strategy is the algorithm used to select one or more nexthops
- * from the set of available nexthops.
- *
- * Each nexthop also contains a void* to a forwarding strategy data container.
- * This allows a strategy to keep proprietary information about each nexthop.
- *
- *
- */
-
-#ifndef fibEntry_h
-#define fibEntry_h
-
-#include <hicn/core/name.h>
-#include <hicn/strategies/strategyImpl.h>
-
-#ifdef WITH_POLICY
-#include <hicn/core/connectionTable.h>
-#endif /* WITH_POLICY */
-
-#ifdef WITH_MAPME
-#include <parc/algol/parc_EventTimer.h>
-#include <parc/algol/parc_Iterator.h>
-#endif /* WITH_MAPME */
-
-struct fib_entry;
-typedef struct fib_entry FibEntry;
-
-#ifdef WITH_POLICY
-struct forwarder;
-FibEntry *fibEntry_Create(Name *name, strategy_type fwdStrategy, const struct forwarder * table);
-#else
-FibEntry *fibEntry_Create(Name *name, strategy_type fwdStrategy);
-#endif
-
-/**
- * Decrements the reference count by one, and destroys the memory after last
- * release
- *
- */
-void fibEntry_Release(FibEntry **fibEntryPtr);
-
-/**
- * Returns a reference counted copy of the fib entry
- *
- * The reference count is increased by one.  The returned value must be
- * released via fibEnty_Release().
- *
- * @param [in] fibEntry An allocated FibEntry
- *
- * @return non-null A reference counted copy of the fibEntry
- *
- */
-FibEntry *fibEntry_Acquire(const FibEntry *fibEntry);
-
-void fibEntry_SetStrategy(FibEntry *fibEntry, strategy_type strategy,
-                           unsigned related_prefixes_len,
-                           Name **related_prefixes);
-
-void fibEntry_AddNexthop(FibEntry *fibEntry, unsigned connectionId);
-
-void fibEntry_RemoveNexthopByConnectionId(FibEntry *fibEntry,
-                                          unsigned connectionId);
-
-size_t fibEntry_NexthopCount(const FibEntry *fibEntry);
-
-/**
- * @function fibEntry_GetNexthops
- * @abstract Returns the nexthop set of the FIB entry.  You must Acquire if it
- * will be saved.
- * @discussion
- *   Returns the next hop set for the FIB entry.
- */
-const NumberSet *fibEntry_GetNexthops(const FibEntry *fibEntry);
-
-#ifdef WITH_POLICY
-void fibEntry_ReceiveObjectMessage(FibEntry *fibEntry,
-#else
-void fibEntry_ReceiveObjectMessage(const FibEntry *fibEntry,
-#endif /* WITH_POLICY */
-                                   const NumberSet *egressId,
-                                   const Message *objectMessage,
-                                   Ticks pitEntryCreation,
-                                   Ticks objReception);
-
-#ifdef WITH_POLICY
-hicn_policy_t fibEntry_GetPolicy(const FibEntry *fibEntry);
-void fibEntry_ReconsiderPolicy(FibEntry *fibEntry);
-void fibEntry_SetPolicy(FibEntry *fibEntry, hicn_policy_t policy);
-void fibEntry_UpdateStats(FibEntry *fibEntry, uint64_t now);
-NumberSet * fibEntry_GetAvailableNextHops(const FibEntry *fibEntry, unsigned in_connection);
-NumberSet * fibEntry_GetPreviousNextHops(const FibEntry *fibEntry);
-void fibEntry_SetPreviousNextHops(FibEntry *fibEntry, const NumberSet * nexthops);
-
-void fibEntry_OnTimeout(FibEntry *fibEntry, const NumberSet *egressId);
-const NumberSet *fibEntry_GetNexthopsFromForwardingStrategy(
-    FibEntry *fibEntry, const Message *interestMessage, bool is_retransmission);
-
-#else
-void fibEntry_OnTimeout(const FibEntry *fibEntry, const NumberSet *egressId);
-const NumberSet *fibEntry_GetNexthopsFromForwardingStrategy(
-    const FibEntry *fibEntry, const Message *interestMessage);
-#endif /* WITH_POLICY */
-
-
-strategy_type fibEntry_GetFwdStrategyType(const FibEntry *fibEntry);
-
-StrategyImpl *fibEntry_GetFwdStrategy(const FibEntry *fibEntry);
-
-/**
- * @function fibEntry_GetPrefix
- * @abstract Returns a copy of the prefix.
- * @return A reference counted copy that you must destroy
- */
-Name *fibEntry_GetPrefix(const FibEntry *fibEntry);
-
-#ifdef WITH_MAPME
-
-/**
- * @function fibEntry_getUserData
- * @abstract Returns user data associated to the FIB entry.
- * @param [in] fibEntry - Pointer to the FIB entry.
- * @return User data as a void pointer
- */
-void *fibEntry_getUserData(const FibEntry *fibEntry);
-
-/**
- * @function fibEntry_getUserData
- * @abstract Associates user data and release callback to a FIB entry.
- * @param [in] fibEntry - Pointer to the FIB entry.
- * @param [in] userData - Generic pointer to user data
- * @param [in@ userDataRelease - Callback used to release user data upon change
- *       of FIB entry removal.
- */
-void fibEntry_setUserData(FibEntry *fibEntry, const void *userDataOwner,
-        const void *userData, void (*userDataRelease)(const void *, void **));
-
-#endif /* WITH_MAPME */
-
-#endif  // fibEntry_h
diff --git a/hicn-light/src/hicn/processor/fibEntryList.c b/hicn-light/src/hicn/processor/fibEntryList.c
deleted file mode 100644
index 56d7b8bea..000000000
--- a/hicn-light/src/hicn/processor/fibEntryList.c
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/algol/parc_ArrayList.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/assert/parc_Assert.h>
-#include <hicn/processor/fibEntryList.h>
-
-struct fib_entry_list {
-  PARCArrayList *listOfFibEntries;
-};
-
-static void fibEntryList_ListDestroyer(void **voidPtr) {
-  FibEntry **entryPtr = (FibEntry **)voidPtr;
-  fibEntry_Release(entryPtr);
-}
-
-FibEntryList *fibEntryList_Create() {
-  FibEntryList *fibEntryList =
-      parcMemory_AllocateAndClear(sizeof(FibEntryList));
-  parcAssertNotNull(fibEntryList,
-                    "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(FibEntryList));
-  fibEntryList->listOfFibEntries =
-      parcArrayList_Create(fibEntryList_ListDestroyer);
-  return fibEntryList;
-}
-
-void fibEntryList_Destroy(FibEntryList **listPtr) {
-  parcAssertNotNull(listPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*listPtr, "Parameter must dereference to non-null pointer");
-
-  FibEntryList *list = *listPtr;
-  parcArrayList_Destroy(&list->listOfFibEntries);
-  parcMemory_Deallocate((void **)&list);
-  listPtr = NULL;
-}
-
-void fibEntryList_Append(FibEntryList *list, FibEntry *fibEntry) {
-  parcAssertNotNull(list, "Parameter list must be non-null pointer");
-  parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null pointer");
-
-  FibEntry *copy = fibEntry_Acquire(fibEntry);
-  parcArrayList_Add(list->listOfFibEntries, copy);
-}
-
-size_t fibEntryList_Length(const FibEntryList *list) {
-  parcAssertNotNull(list, "Parameter list must be non-null pointer");
-  return parcArrayList_Size(list->listOfFibEntries);
-}
-
-const FibEntry *fibEntryList_Get(const FibEntryList *list, size_t index) {
-  parcAssertNotNull(list, "Parameter list must be non-null pointer");
-  FibEntry *entry = parcArrayList_Get(list->listOfFibEntries, index);
-  return entry;
-}
diff --git a/hicn-light/src/hicn/processor/fibEntryList.h b/hicn-light/src/hicn/processor/fibEntryList.h
deleted file mode 100644
index 072a1b369..000000000
--- a/hicn-light/src/hicn/processor/fibEntryList.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * 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 fibEntryList.h
- * @brief A typesafe list of FibEntry
- *
- * <#Detailed Description#>
- *
- */
-
-#ifndef fibEntryList_h
-#define fibEntryList_h
-
-#include <hicn/processor/fibEntry.h>
-
-struct fib_entry_list;
-typedef struct fib_entry_list FibEntryList;
-
-/**
- * Creates an emtpy FIB entry list
- *
- * Must be destroyed with fibEntryList_Destroy.
- *
- * @retval non-null An allocated FibEntryList
- * @retval null An error
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-FibEntryList *fibEntryList_Create(void);
-
-/**
- * @function FibEntryList_Detroy
- * @abstract Destroys the list and all entries.
- * @discussion
- *   <#Discussion#>
- *
- * @param <#param1#>
- */
-void fibEntryList_Destroy(FibEntryList **listPtr);
-
-/**
- * @function fibEntryList_Append
- * @abstract Will store a reference counted copy of the entry.
- * @discussion
- *   Will create and store a reference counted copy.  You keep ownership
- *   of the parameter <code>fibEntry</code>.
- *
- * @param <#param1#>
- * @return <#return#>
- */
-void fibEntryList_Append(FibEntryList *list, FibEntry *fibEntry);
-
-/**
- * Returns the number of entries in the list
- *
- * <#Paragraphs Of Explanation#>
- *
- * @param [in] list An allocated FibEntryList
- *
- * @retval number The number of entries in the list
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-size_t fibEntryList_Length(const FibEntryList *list);
-
-/**
- * @function fibEntryList_Get
- * @abstract Gets an element.  This is the internal reference, do not destroy.
- * @discussion
- *   Returns an internal reference from the list.  You must not destroy it.
- *   Will assert if you go off the end of the list.
- *
- * @param <#param1#>
- * @return <#return#>
- */
-const FibEntry *fibEntryList_Get(const FibEntryList *list, size_t index);
-#endif  // fibEntryList_h
diff --git a/hicn-light/src/hicn/processor/hashTableFunction.c b/hicn-light/src/hicn/processor/hashTableFunction.c
deleted file mode 100644
index 98afa1294..000000000
--- a/hicn-light/src/hicn/processor/hashTableFunction.c
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_Hash.h>
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/core/message.h>
-#include <hicn/processor/hashTableFunction.h>
-
-#include <parc/assert/parc_Assert.h>
-
-// ======================================================================
-// Hash table key functions
-// We use a Message as the key data type
-
-bool hashTableFunction_MessageNameEquals(const void *messageA,
-                                         const void *messageB) {
-  const Message *a = (const Message *)messageA;
-  const Message *b = (const Message *)messageB;
-
-  return name_Equals(message_GetName(a), message_GetName(b));
-}
-
-HashCodeType hashTableFunction_MessageNameHashCode(const void *messageA) {
-  const Message *message = (const Message *)messageA;
-  Name *name = message_GetName(message);
-
-  // we want the cumulative hash for the whole name
-  uint32_t hash = name_HashCode(name);
-
-  return hash;
-}
\ No newline at end of file
diff --git a/hicn-light/src/hicn/processor/hashTableFunction.h b/hicn-light/src/hicn/processor/hashTableFunction.h
deleted file mode 100644
index eb9989086..000000000
--- a/hicn-light/src/hicn/processor/hashTableFunction.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * 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 hashTableFunction.h
- * @brief These functions are used in PARCHashCodeTables by the
- * MatchingRulesTable and ContentStore and PIT. They perform the equality
- * and has generation needed by the PARCHashCodeTable.
- *
- */
-#ifndef hashTableFunction_h
-#define hashTableFunction_h
-
-#include <parc/algol/parc_HashCodeTable.h>
-
-// ==========================================================
-// These functions operate on a message as the key in the HashTable.
-// The functions use void * rather than message instances in the function
-// signature because it is using generic has code tables from PARC Library
-
-/**
- * Determine if the Names of two `message` instances are equal.
- *
- * The following equivalence relations on non-null `message` instances are
- * maintained:
- *
- *  * It is reflexive: for any non-null reference value x,
- * `hashTableFunction_MessageNameEquals(x, x)` must return true.
- *
- *  * It is symmetric: for any non-null reference values x and y,
- *    `message_Equals(x, y)` must return true if and only if
- *        `hashTableFunction_MessageNameEquals(y, x)` returns true.
- *
- *  * It is transitive: for any non-null reference values x, y, and z, if
- *        `hashTableFunction_MessageNameEquals(x, y)` returns true and
- *        `hashTableFunction_MessageNameEquals(y, z)` returns true,
- *        then  `hashTableFunction_MessageNameEquals(x, z)` must return true.
- *
- *  * It is consistent: for any non-null reference values x and y, multiple
- *      invocations of `hashTableFunction_MessageNameEquals(x, y)` consistently
- * return true or consistently return false.
- *
- *  * For any non-null reference value x,
- * `hashTableFunction_MessageNameEquals(x, NULL)` must return false.
- *
- * @param a A pointer to a `message` instance.
- * @param b A pointer to a `message` instance.
- * @return true if the names of the two `message` instances are equal.
- */
-bool hashTableFunction_MessageNameEquals(const void *messageA,
-                                         const void *messageB);
-
-/**
- * @function hashTableFunction_NameHashCode
- * @abstract Computes the hash of the entire name in a message
- *
- * @param messageA is a message
- * @return A non-cryptographic hash of Name
- */
-HashCodeType hashTableFunction_MessageNameHashCode(const void *messageA);
-#endif  // hashTableFunction_h
\ No newline at end of file
diff --git a/hicn-light/src/hicn/processor/matchingRulesTable.c b/hicn-light/src/hicn/processor/matchingRulesTable.c
deleted file mode 100644
index e57239321..000000000
--- a/hicn-light/src/hicn/processor/matchingRulesTable.c
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_Hash.h>
-#include <parc/algol/parc_Memory.h>
-
-#include <parc/assert/parc_Assert.h>
-#include <hicn/processor/hashTableFunction.h>
-#include <hicn/processor/matchingRulesTable.h>
-
-struct matching_rules_table {
-  // using this wrapper we can manatain multiple hash tables indexed in
-  // different ways
-  // for now we use only a table indexed by name
-
-  PARCHashCodeTable *tableByName;
-  PARCHashCodeTable_Destroyer dataDestroyer;
-};
-
-static PARCHashCodeTable *matchingRulesTable_GetTableForMessage(
-    const MatchingRulesTable *pit, const Message *interestMessage);
-
-// ======================================================================
-
-MatchingRulesTable *matchingRulesTable_Create(
-    PARCHashCodeTable_Destroyer dataDestroyer) {
-  size_t initialSize = 65535;
-
-  MatchingRulesTable *table =
-      parcMemory_AllocateAndClear(sizeof(MatchingRulesTable));
-  parcAssertNotNull(table, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(MatchingRulesTable));
-  table->dataDestroyer = dataDestroyer;
-
-  table->tableByName = parcHashCodeTable_Create_Size(
-      hashTableFunction_MessageNameEquals,
-      hashTableFunction_MessageNameHashCode, NULL, dataDestroyer, initialSize);
-
-  return table;
-}
-
-void matchingRulesTable_Destroy(MatchingRulesTable **tablePtr) {
-  parcAssertNotNull(tablePtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*tablePtr,
-                    "Parameter must dereference to non-null pointer");
-
-  MatchingRulesTable *table = *tablePtr;
-
-  parcHashCodeTable_Destroy(&table->tableByName);
-
-  parcMemory_Deallocate((void **)&table);
-  *tablePtr = NULL;
-}
-
-void *matchingRulesTable_Get(const MatchingRulesTable *rulesTable,
-                             const Message *message) {
-  parcAssertNotNull(rulesTable, "Parameter rulesTable must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
-
-  PARCHashCodeTable *hashTable =
-      matchingRulesTable_GetTableForMessage(rulesTable, message);
-  return parcHashCodeTable_Get(hashTable, message);
-}
-
-PARCArrayList *matchingRulesTable_GetUnion(const MatchingRulesTable *table,
-                                           const Message *message) {
-  PARCArrayList *list = parcArrayList_Create_Capacity(NULL, NULL, 3);
-
-  void *dataByName = parcHashCodeTable_Get(table->tableByName, message);
-  if (dataByName) {
-    parcArrayList_Add(list, dataByName);
-  }
-
-  return list;
-}
-
-void matchingRulesTable_RemoveFromBest(MatchingRulesTable *rulesTable,
-                                       const Message *message) {
-  parcAssertNotNull(rulesTable, "Parameter rulesTable must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
-
-  PARCHashCodeTable *hashTable =
-      matchingRulesTable_GetTableForMessage(rulesTable, message);
-  parcHashCodeTable_Del(hashTable, message);
-}
-
-void matchingRulesTable_RemoveFromAll(MatchingRulesTable *rulesTable,
-                                      const Message *message) {
-  parcAssertNotNull(rulesTable, "Parameter rulesTable must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
-
-  parcHashCodeTable_Del(rulesTable->tableByName, message);
-}
-
-bool matchingRulesTable_AddToBestTable(MatchingRulesTable *rulesTable,
-                                       Message *key, void *data) {
-  parcAssertNotNull(rulesTable, "Parameter rulesTable must be non-null");
-  parcAssertNotNull(key, "Parameter key must be non-null");
-  parcAssertNotNull(data, "Parameter data must be non-null");
-
-  PARCHashCodeTable *hashTable =
-      matchingRulesTable_GetTableForMessage(rulesTable, key);
-
-  bool success = parcHashCodeTable_Add(hashTable, key, data);
-
-  return success;
-}
-
-// ========================================================================================
-
-static PARCHashCodeTable *matchingRulesTable_GetTableForMessage(
-    const MatchingRulesTable *pit, const Message *interestMessage) {
-  PARCHashCodeTable *table;
-  table = pit->tableByName;
-
-  return table;
-}
diff --git a/hicn-light/src/hicn/processor/matchingRulesTable.h b/hicn-light/src/hicn/processor/matchingRulesTable.h
deleted file mode 100644
index 64a57d854..000000000
--- a/hicn-light/src/hicn/processor/matchingRulesTable.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * @header matchingRulesTable
- * @abstract A generic table (void *) that matches a Message
- * @discussion
- *     Matching is done based on Name
- *
- *     When used in the PIT, one calls
- * <code>matchingRulesTable_AddToBestTable()</code> to add an interest to the
- * "best" (i.e. most restrictive match) table, then calls
- *     <code>matchingRulesTable_GetUnion()</code> on a content object to match
- * against all of them.
- *
- *     When used in a ContentStore, one calls
- * <code>matchingRulesTable_AddToAllTables()</code> to index a Content Object in
- * all the tables.  one then calls <code>matchingRulesTable_Get()</code> with an
- * Interest to do the "best" matching (i.e by hash first, then keyid, then just
- * by name).
- *
- */
-
-#ifndef matchingRulesTable_h
-#define matchingRulesTable_h
-
-#include <parc/algol/parc_ArrayList.h>
-#include <parc/algol/parc_HashCodeTable.h>
-#include <hicn/core/message.h>
-
-struct matching_rules_table;
-typedef struct matching_rules_table MatchingRulesTable;
-
-/**
- * Creates a MatchigRulesTable and specifies the function to call to de-allocate
- * an entry
- *
- * The datadestroyer will be called when an entry is removed from a table. It
- * may be NULL.
- */
-MatchingRulesTable *matchingRulesTable_Create(
-    PARCHashCodeTable_Destroyer dataDestroyer);
-
-/**
- * Destroys the table and removes all stored elements.
- *
- */
-void matchingRulesTable_Destroy(MatchingRulesTable **tablePtr);
-
-/**
- * @function matchingRulesTable_Get
- * @abstract Returns the data item that best matches the message.
- * @discussion
- *   Indexed by NameAndContentObjectHash, NameAndKeyId, and Name, in that order.
- *
- * @return NULL if nothing matches, otherwise the stored value
- */
-void *matchingRulesTable_Get(const MatchingRulesTable *table,
-                             const Message *message);
-
-/**
- * @function matchingRulesTable_GetUnion
- * @abstract Returns matching data items from all index tables.
- * @discussion
- *   The PARCArrayList does not have an item destructor, so destroying it will
- * not affect the underlying data.
- *
- * @return Will not be NULL, but may be empty
- */
-PARCArrayList *matchingRulesTable_GetUnion(const MatchingRulesTable *table,
-                                           const Message *message);
-
-/**
- * @function matchingRulesTable_Add
- * @abstract Adds the data to the best table
- * @discussion
- *   The key must be derived from the data and destroyed when the data is
- * destroyed.  Only the data destroyer is called.
- *
- *   No duplicates are allowed, will return false if not added.
- *
- * @return true if unique key and added, false if duplicate and no action taken.
- */
-bool matchingRulesTable_AddToBestTable(MatchingRulesTable *rulesTable,
-                                       Message *key, void *data);
-
-/**
- * @function matchingRulesTable_Remove
- * @abstract Removes the matching entry from the best match table, calling the
- * destroyer on the data.
- */
-void matchingRulesTable_RemoveFromBest(MatchingRulesTable *rulesTable,
-                                       const Message *message);
-
-/**
- * @function matchingRulesTable_RemoveFromAll
- * @abstract Removes the message from all tables
- */
-void matchingRulesTable_RemoveFromAll(MatchingRulesTable *rulesTable,
-                                      const Message *message);
-#endif  // matchingRulesTable_h
diff --git a/hicn-light/src/hicn/processor/messageProcessor.c b/hicn-light/src/hicn/processor/messageProcessor.c
deleted file mode 100644
index d3f07cbda..000000000
--- a/hicn-light/src/hicn/processor/messageProcessor.c
+++ /dev/null
@@ -1,909 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <parc/algol/parc_ArrayList.h>
-#include <parc/algol/parc_Memory.h>
-#ifdef WITH_POLICY
-#include <parc/algol/parc_EventTimer.h>
-#ifdef WITH_MAPME
-#include <hicn/core/connection.h>
-#endif /* WITH_MAPME */
-#endif /* WITH_POLICY */
-#include <hicn/processor/messageProcessor.h>
-
-#include <hicn/processor/fib.h>
-#include <hicn/processor/pitStandard.h>
-
-#include <hicn/content_store/contentStoreInterface.h>
-#include <hicn/content_store/contentStoreLRU.h>
-
-#include <hicn/strategies/loadBalancer.h>
-#include <hicn/strategies/lowLatency.h>
-#include <hicn/strategies/rnd.h>
-#include <hicn/strategies/strategyImpl.h>
-
-#include <hicn/io/streamConnection.h>
-#include <hicn/io/udpListener.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <hicn/utils/commands.h>
-#include <hicn/utils/utils.h>
-
-#include <hicn/utils/address.h>
-#include <hicn/core/messageHandler.h>
-
-#ifdef WITH_POLICY
-#define STATS_INTERVAL 1000 /* ms */
-#endif /* WITH_POLICY */
-
-/*
- * 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.
- */
-typedef struct processor_stats {
-  uint32_t countReceived;
-  uint32_t countInterestsReceived;
-  uint32_t countObjectsReceived;
-
-  uint32_t countInterestsAggregated;
-
-  uint32_t countDropped;
-  uint32_t countInterestsDropped;
-  uint32_t countDroppedNoRoute;
-  uint32_t countDroppedNoReversePath;
-
-  uint32_t countDroppedConnectionNotFound;
-  uint32_t countObjectsDropped;
-
-  uint32_t countSendFailures;
-  uint32_t countInterestForwarded;
-  uint32_t countObjectsForwarded;
-  uint32_t countInterestsSatisfiedFromStore;
-
-  uint32_t countDroppedNoHopLimit;
-  uint32_t countDroppedZeroHopLimitFromRemote;
-  uint32_t countDroppedZeroHopLimitToRemote;
-} _ProcessorStats;
-
-struct message_processor {
-  Forwarder *forwarder;
-  Logger *logger;
-
-  PIT *pit;
-  ContentStoreInterface *contentStore;
-  FIB *fib;
-
-  bool store_in_cache;
-  bool serve_from_cache;
-
-  _ProcessorStats stats;
-
-#ifdef WITH_POLICY
-  void * timer;
-#endif /* WITH_POLICY */
-};
-
-static void messageProcessor_Drop(MessageProcessor *processor,
-                                  Message *message);
-static void messageProcessor_ReceiveInterest(MessageProcessor *processor,
-                                             Message *interestMessage);
-static void messageProcessor_ReceiveContentObject(MessageProcessor *processor,
-                                                  Message *objectMessage);
-static unsigned messageProcessor_ForwardToNexthops(MessageProcessor *processor,
-                                                   Message *message,
-                                                   const NumberSet *nexthops);
-
-static void messageProcessor_ForwardToInterfaceId(MessageProcessor *processor,
-                                                  Message *message,
-                                                  unsigned interfaceId);
-
-// ============================================================
-// Public API
-
-#ifdef WITH_POLICY
-static void
-messageProcessor_Tick(int fd, PARCEventType type, void *user_data)
-{
-  MessageProcessor *processor = (MessageProcessor*)user_data;
-  uint64_t now = (uint64_t)forwarder_GetTicks(processor->forwarder);
-
-  /* Loop over FIB entries to compute statistics from counters */
-  FibEntryList *fibList = forwarder_GetFibEntries(processor->forwarder);
-
-  for (size_t i = 0; i < fibEntryList_Length(fibList); i++) {
-    FibEntry *entry = (FibEntry *)fibEntryList_Get(fibList, i);
-    fibEntry_UpdateStats(entry, now);
-  }
-
-  fibEntryList_Destroy(&fibList);
-}
-#endif /* WITH_POLICY */
-
-MessageProcessor *messageProcessor_Create(Forwarder *forwarder) {
-  size_t objectStoreSize =
-      configuration_GetObjectStoreSize(forwarder_GetConfiguration(forwarder));
-
-  MessageProcessor *processor =
-      parcMemory_AllocateAndClear(sizeof(MessageProcessor));
-  parcAssertNotNull(processor, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(MessageProcessor));
-  memset(processor, 0, sizeof(MessageProcessor));
-
-  processor->forwarder = forwarder;
-  processor->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-  processor->pit = pitStandard_Create(forwarder);
-
-  processor->fib = fib_Create(forwarder);
-
-  if (logger_IsLoggable(processor->logger, LoggerFacility_Processor,
-                        PARCLogLevel_Debug)) {
-    logger_Log(processor->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-               __func__, "MessageProcessor %p created", (void *)processor);
-  }
-
-  ContentStoreConfig contentStoreConfig = {
-      .objectCapacity = objectStoreSize,
-  };
-
-  processor->contentStore =
-      contentStoreLRU_Create(&contentStoreConfig, processor->logger);
-
-  // the two flags for the cache are set to true by default. If the cache
-  // is active it always work as expected unless the use modifies this
-  // values using controller
-  processor->store_in_cache = true;
-  processor->serve_from_cache = true;
-
-#ifdef WITH_POLICY
-  /* Create statistics timer */
-  Dispatcher *dispatcher = forwarder_GetDispatcher(forwarder);
-  if (!dispatcher)
-    goto ERR;
-  processor->timer = dispatcher_CreateTimer(dispatcher, /* repeat */ true,
-          messageProcessor_Tick, processor);
-  if (!processor->timer)
-      goto ERR;
-  struct timeval timeout = {STATS_INTERVAL / 1000, (STATS_INTERVAL % 1000) * 1000};
-  dispatcher_StartTimer(dispatcher, processor->timer, &timeout);
-ERR:
-#endif /* WITH_POLICY */
-
-  return processor;
-}
-
-void messageProcessor_SetContentObjectStoreSize(
-    MessageProcessor *processor, size_t maximumContentStoreSize) {
-  parcAssertNotNull(processor, "Parameter processor must be non-null");
-  contentStoreInterface_Release(&processor->contentStore);
-
-  ContentStoreConfig contentStoreConfig = {.objectCapacity =
-                                               maximumContentStoreSize};
-
-  processor->contentStore =
-      contentStoreLRU_Create(&contentStoreConfig, processor->logger);
-}
-
-void messageProcessor_ClearCache(MessageProcessor *processor) {
-  parcAssertNotNull(processor, "Parameter processor must be non-null");
-  size_t objectStoreSize = configuration_GetObjectStoreSize(
-      forwarder_GetConfiguration(processor->forwarder));
-
-  contentStoreInterface_Release(&processor->contentStore);
-
-  ContentStoreConfig contentStoreConfig = {
-      .objectCapacity = objectStoreSize,
-  };
-
-  processor->contentStore =
-      contentStoreLRU_Create(&contentStoreConfig, processor->logger);
-}
-
-ContentStoreInterface *messageProcessor_GetContentObjectStore(
-    const MessageProcessor *processor) {
-  parcAssertNotNull(processor, "Parameter processor must be non-null");
-  return processor->contentStore;
-}
-
-void messageProcessor_Destroy(MessageProcessor **processorPtr) {
-  parcAssertNotNull(processorPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*processorPtr, "Parameter dereference to non-null pointer");
-
-  MessageProcessor *processor = *processorPtr;
-
-  if (logger_IsLoggable(processor->logger, LoggerFacility_Processor,
-                        PARCLogLevel_Debug)) {
-    logger_Log(processor->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-               __func__, "MessageProcessor %p destroyed", (void *)processor);
-  }
-
-  logger_Release(&processor->logger);
-  fib_Destroy(&processor->fib);
-  contentStoreInterface_Release(&processor->contentStore);
-  pit_Release(&processor->pit);
-
-#ifdef WITH_POLICY
-  Dispatcher *dispatcher = forwarder_GetDispatcher(processor->forwarder);
-  if (!dispatcher)
-    goto ERR;
-  dispatcher_StopTimer(dispatcher, processor->timer);
-  dispatcher_DestroyTimerEvent(dispatcher, (PARCEventTimer**)&processor->timer);
-ERR:
-#endif /* WITH_POLICY */
-
-  parcMemory_Deallocate((void **)&processor);
-  *processorPtr = NULL;
-}
-
-void messageProcessor_Receive(MessageProcessor *processor, Message *message) {
-  parcAssertNotNull(processor, "Parameter processor must be non-null");
-  parcAssertNotNull(message, "Parameter message must be non-null");
-
-  processor->stats.countReceived++;
-
-  if (logger_IsLoggable(processor->logger, LoggerFacility_Processor,
-                        PARCLogLevel_Debug)) {
-    char *nameString = name_ToString(message_GetName(message));
-    logger_Log(processor->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-               __func__, "Message %p ingress %3u length %5u received name %s",
-               (void *)message, message_GetIngressConnectionId(message),
-               message_Length(message), nameString);
-    parcMemory_Deallocate((void **)&nameString);
-  }
-
-  switch (message_GetType(message)) {
-    case MessagePacketType_Interest:
-      messageProcessor_ReceiveInterest(processor, message);
-      break;
-
-    case MessagePacketType_ContentObject:
-      messageProcessor_ReceiveContentObject(processor, message);
-      break;
-
-    default:
-      messageProcessor_Drop(processor, message);
-      break;
-  }
-
-  // if someone wanted to save it, they made a copy
-  message_Release(&message);
-}
-
-bool messageProcessor_AddOrUpdateRoute(MessageProcessor *processor,
-                                       add_route_command *control,
-                                       unsigned ifidx) {
-  Configuration *config = forwarder_GetConfiguration(processor->forwarder);
-
-  char *prefixStr = (char *) utils_PrefixLenToString(
-      control->addressType, &control->address, &control->len);
-  strategy_type fwdStrategy =
-      configuration_GetForwardingStrategy(config, prefixStr);
-
-  Name *prefix = name_CreateFromAddress(control->addressType, control->address,
-                                        control->len);
-  FibEntry *entry = fib_Contains(processor->fib, prefix);
-  if (entry != NULL) {
-    fibEntry_AddNexthop(entry, ifidx);
-  } else {
-#ifdef WITH_POLICY
-    entry = fibEntry_Create(prefix, fwdStrategy, processor->forwarder);
-#else
-    entry = fibEntry_Create(prefix, fwdStrategy);
-#endif /* WITH_POLICY */
-    fibEntry_AddNexthop(entry, ifidx);
-    fib_Add(processor->fib, entry);
-  }
-
-  free(prefixStr);
-  name_Release(&prefix);
-
-  return true;
-}
-
-bool messageProcessor_RemoveRoute(MessageProcessor *processor,
-                                  remove_route_command *control,
-                                  unsigned ifidx) {
-  Name *name = name_CreateFromAddress(control->addressType, control->address,
-                                      control->len);
-  fib_Remove(processor->fib, name, ifidx);
-  name_Release(&name);
-
-  return true;
-}
-
-#ifdef WITH_POLICY
-
-bool messageProcessor_AddOrUpdatePolicy(MessageProcessor *processor,
-                                       add_policy_command *control) {
-  Configuration *config = forwarder_GetConfiguration(processor->forwarder);
-
-  const char *prefixStr = utils_PrefixLenToString(
-      control->addressType, &control->address, &control->len);
-
-  Name *prefix = name_CreateFromAddress(control->addressType, control->address,
-                                        control->len);
-  FibEntry *entry = fib_Contains(processor->fib, prefix);
-  if (!entry) {
-    strategy_type fwdStrategy =
-        configuration_GetForwardingStrategy(config, prefixStr);
-    entry = fibEntry_Create(prefix, fwdStrategy, processor->forwarder);
-    fib_Add(processor->fib, entry);
-  }
-  fibEntry_SetPolicy(entry, control->policy);
-
-  name_Release(&prefix);
-
-  return true;
-}
-
-bool messageProcessor_RemovePolicy(MessageProcessor *processor,
-                                  remove_policy_command *control) {
-  Name *prefix = name_CreateFromAddress(control->addressType, control->address,
-                                      control->len);
-  FibEntry *entry = fib_Contains(processor->fib, prefix);
-  name_Release(&prefix);
-
-  if (!entry)
-      return false;
-
-  fibEntry_SetPolicy(entry, POLICY_NONE);
-
-  return true;
-}
-
-#endif /* WITH_POLICY */
-
-void messageProcessor_RemoveConnectionIdFromRoutes(MessageProcessor *processor,
-                                                   unsigned connectionId) {
-  fib_RemoveConnectionId(processor->fib, connectionId);
-}
-
-void processor_SetStrategy(MessageProcessor *processor, Name *prefix,
-                           strategy_type strategy,
-                           unsigned related_prefixes_len,
-                           Name **related_prefixes){
-  FibEntry *entry = fib_Contains(processor->fib, prefix);
-  if (entry != NULL) {
-    fibEntry_SetStrategy(entry, strategy, related_prefixes_len,
-                        related_prefixes);
-  }
-}
-
-FibEntryList *messageProcessor_GetFibEntries(MessageProcessor *processor) {
-  parcAssertNotNull(processor, "Parameter processor must be non-null");
-  return fib_GetEntries(processor->fib);
-}
-
-// ============================================================
-// Internal API
-
-/**
- * @function messageProcessor_Drop
- * @abstract Whenever we "drop" a message, increment countes
- * @discussion
- *   This is a bookkeeping function.  It increments the appropriate counters.
- *
- *   The default action for a message is to destroy it in
- * <code>messageProcessor_Receive()</code>, so this function does not need to do
- * that.
- *
- */
-static void messageProcessor_Drop(MessageProcessor *processor,
-                                  Message *message) {
-  processor->stats.countDropped++;
-
-  switch (message_GetType(message)) {
-    case MessagePacketType_Interest:
-      processor->stats.countInterestsDropped++;
-      break;
-
-    case MessagePacketType_ContentObject:
-      processor->stats.countObjectsDropped++;
-      break;
-
-    default:
-      break;
-  }
-
-  // dont destroy message here, its done at end of receive
-}
-
-/**
- * @function messageProcessor_AggregateInterestInPit
- * @abstract Try to aggregate the interest in the PIT
- * @discussion
- *   Tries to aggregate the interest with another interest.
- *
- * @return true if interest aggregagted (no more forwarding needed), false if
- * need to keep processing it.
- */
-#ifdef WITH_POLICY
-static PITVerdict messageProcessor_AggregateInterestInPit(MessageProcessor *processor,
-                                                    Message *interestMessage) {
-#else
-static bool messageProcessor_AggregateInterestInPit(MessageProcessor *processor,
-                                                    Message *interestMessage) {
-#endif /* WITH_POLICY */
-  PITVerdict verdict = pit_ReceiveInterest(processor->pit, interestMessage);
-
-  if (verdict == PITVerdict_Aggregate) {
-    // PIT has it, we're done
-    processor->stats.countInterestsAggregated++;
-
-    if (logger_IsLoggable(processor->logger, LoggerFacility_Processor,
-                          PARCLogLevel_Debug)) {
-      logger_Log(
-          processor->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-          __func__, "Message %p aggregated in PIT (aggregated count %u)",
-          (void *)interestMessage, processor->stats.countInterestsAggregated);
-    }
-
-    return true;
-  }
-
-  if (logger_IsLoggable(processor->logger, LoggerFacility_Processor,
-                        PARCLogLevel_Debug)) {
-    logger_Log(
-        processor->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-        __func__, "Message %p not aggregated in PIT (aggregated count %u)",
-        (void *)interestMessage, processor->stats.countInterestsAggregated);
-  }
-
-  return false;
-}
-
-static bool _satisfyFromContentStore(MessageProcessor *processor,
-                                     Message *interestMessage) {
-  bool result = false;
-
-  if (message_GetInterestLifetimeTicks(interestMessage) == 0) {
-    return false;
-  }
-
-  if (!processor->serve_from_cache) {
-    return result;
-  }
-
-  // See if there's a match in the store.
-  Message *objectMessage = contentStoreInterface_MatchInterest(
-      processor->contentStore, interestMessage,
-      forwarder_GetTicks(processor->forwarder));
-
-  if (objectMessage != NULL) {
-    // Remove it from the PIT.  nexthops is allocated, so need to destroy
-    NumberSet *nexthops = pit_SatisfyInterest(processor->pit, objectMessage);
-    parcAssertNotNull(
-        nexthops,
-        "Illegal state: got a null nexthops for an interest we just inserted.");
-
-    // send message in reply, then done
-    processor->stats.countInterestsSatisfiedFromStore++;
-
-    if (logger_IsLoggable(processor->logger, LoggerFacility_Processor,
-                          PARCLogLevel_Debug)) {
-      logger_Log(processor->logger, LoggerFacility_Processor,
-                 PARCLogLevel_Debug, __func__,
-                 "Message %p satisfied from content store (satisfied count %u)",
-                 (void *)interestMessage,
-                 processor->stats.countInterestsSatisfiedFromStore);
-    }
-
-    message_ResetPathLabel(objectMessage);
-
-    messageProcessor_ForwardToNexthops(processor, objectMessage, nexthops);
-    numberSet_Release(&nexthops);
-
-    result = true;
-  }
-
-  return result;
-}
-
-/**
- * @function messageProcessor_ForwardViaFib
- * @abstract Try to forward the interest via the FIB
- * @discussion
- *   This calls <code>messageProcessor_ForwardToNexthops()</code>, so if we find
- * any nexthops, the interest will be sent on its way.  Depending on the
- * IoOperations of each nexthop, it may be a deferred write and bump up the
- * <code>interestMessage</code> refernce count, or it may copy the data out.
- *
- *   A TRUE return means we did our best to forward it via the routes.  If those
- * routes are actually down or have errors, we still return TRUE.  A FALSE
- * return means there were no routes to try.
- *
- * @return true if we found a route and tried to forward it, false if no route
- */
-#ifdef WITH_POLICY
-static bool messageProcessor_ForwardViaFib(MessageProcessor *processor,
-    Message *interestMessage, PITVerdict verdict) {
-#else
-static bool messageProcessor_ForwardViaFib(MessageProcessor *processor,
-                                           Message *interestMessage) {
-#endif /* WITH_POLICY */
-  FibEntry *fibEntry = fib_MatchMessage(processor->fib, interestMessage);
-  if (fibEntry == NULL) {
-    return false;
-  }
-
-  if(messageHandler_IsAProbe(message_FixedHeader(interestMessage))){
-    bool reply_to_probe = false;
-    ConnectionTable * ct = forwarder_GetConnectionTable(processor->forwarder);
-    const NumberSet * nexthops = fibEntry_GetNexthops(fibEntry);
-    unsigned size = (unsigned) numberSet_Length(nexthops);
-
-    for (unsigned i = 0; i < size; i++) {
-      unsigned nhop = numberSet_GetItem(nexthops, i);
-      Connection *conn =
-          (Connection *)connectionTable_FindById(ct, nhop);
-      if (!conn)
-        continue;
-      bool isLocal = connection_IsLocal(conn);
-      if(isLocal){
-        Connection * replyConn =
-                  (Connection *)connectionTable_FindById(ct,
-                    message_GetIngressConnectionId(interestMessage));
-        connection_HandleProbe(replyConn,
-                  (uint8_t *) message_FixedHeader(interestMessage));
-        reply_to_probe = true;
-        break;
-      }
-    }
-    if(reply_to_probe)
-      return false;
-  }
-
-
-  PitEntry *pitEntry = pit_GetPitEntry(processor->pit, interestMessage);
-  if (pitEntry == NULL) {
-    return false;
-  }
-
-  pitEntry_AddFibEntry(pitEntry, fibEntry);
-
-  NumberSet *nexthops = (NumberSet *)fibEntry_GetNexthopsFromForwardingStrategy(
-#ifdef WITH_POLICY
-      fibEntry, interestMessage, verdict);
-#else
-      fibEntry, interestMessage);
-#endif /* WITH_POLICY */
-
-  // this requires some additional checks. It may happen that some of the output
-  // faces selected by the forwarding strategy are not usable. So far all the
-  // forwarding strategy return only valid faces (or an empty list)
-  for (unsigned i = 0; i < numberSet_Length(nexthops); i++) {
-    pitEntry_AddEgressId(pitEntry, numberSet_GetItem(nexthops, i));
-  }
-
-  // The function GetPitEntry encreases the ref counter in the pit entry
-  // we need to decrease it
-  pitEntry_Release(&pitEntry);
-
-  if (messageProcessor_ForwardToNexthops(processor, interestMessage, nexthops) >
-      0) {
-    numberSet_Release(&nexthops);
-    return true;
-  } else {
-    if (logger_IsLoggable(processor->logger, LoggerFacility_Processor,
-                          PARCLogLevel_Debug)) {
-      logger_Log(processor->logger, LoggerFacility_Processor,
-                 PARCLogLevel_Debug, __func__,
-                 "Message %p returned an emtpy next hop set",
-                 (void *)interestMessage);
-    }
-  }
-
-  numberSet_Release(&nexthops);
-  return false;
-}
-
-/**
- * @function messageProcessor_ReceiveInterest
- * @abstract Receive an interest from the network
- * @discussion
- *   (1) if interest in the PIT, aggregate in PIT
- *   (2) if interest in the ContentStore, reply
- *   (3) if in the FIB, forward
- *   (4) drop
- *
- */
-static void messageProcessor_ReceiveInterest(MessageProcessor *processor,
-                                             Message *interestMessage) {
-  processor->stats.countInterestsReceived++;
-
-  // (1) Try to aggregate in PIT
-#ifdef WITH_POLICY
-  PITVerdict verdict = messageProcessor_AggregateInterestInPit(processor, interestMessage);
-  switch(verdict) {
-    case PITVerdict_Aggregate:
-      //done
-      return;
-
-    case PITVerdict_Forward:
-    case PITVerdict_Retransmit:
-      break;
-  }
-#else
-  if (messageProcessor_AggregateInterestInPit(processor, interestMessage)) {
-    // done
-    return;
-  }
-#endif /* WITH_POLICY */
-
-  // At this point, we just created a PIT entry.  If we don't forward the
-  // interest, we need to remove the PIT entry.
-
-  // (2) Try to satisfy from content store
-  if (_satisfyFromContentStore(processor, interestMessage)) {
-    // done
-    // If we found a content object in the CS,
-    // messageProcess_SatisfyFromContentStore already cleared the PIT state
-    return;
-  }
-
-  // (3) Try to forward it
-#ifdef WITH_POLICY
-  if (messageProcessor_ForwardViaFib(processor, interestMessage, verdict)) {
-#else
-  if (messageProcessor_ForwardViaFib(processor, interestMessage)) {
-#endif /* WITH_POLICY */
-    // done
-    return;
-  }
-
-  // Remove the PIT entry?
-  processor->stats.countDroppedNoRoute++;
-
-  if (logger_IsLoggable(processor->logger, LoggerFacility_Processor,
-                        PARCLogLevel_Debug)) {
-    logger_Log(processor->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-               __func__, "Message %p did not match FIB, no route (count %u)",
-               (void *)interestMessage, processor->stats.countDroppedNoRoute);
-  }
-
-  messageProcessor_Drop(processor, interestMessage);
-}
-
-/**
- * @function messageProcessor_ReceiveContentObject
- * @abstract Process an in-bound content object
- * @discussion
- *   (1) If it does not match anything in the PIT, drop it
- *   (2) Add to Content Store
- *   (3) Reverse path forward via PIT entries
- *
- * @param <#param1#>
- */
-static void messageProcessor_ReceiveContentObject(MessageProcessor *processor,
-                                                  Message *message) {
-  processor->stats.countObjectsReceived++;
-
-  NumberSet *ingressSetUnion = pit_SatisfyInterest(processor->pit, message);
-
-  if (numberSet_Length(ingressSetUnion) == 0) {
-    // (1) If it does not match anything in the PIT, drop it
-    processor->stats.countDroppedNoReversePath++;
-
-    if (logger_IsLoggable(processor->logger, LoggerFacility_Processor,
-                          PARCLogLevel_Debug)) {
-      logger_Log(processor->logger, LoggerFacility_Processor,
-                 PARCLogLevel_Debug, __func__,
-                 "Message %p did not match PIT, no reverse path (count %u)",
-                 (void *)message, processor->stats.countDroppedNoReversePath);
-    }
-
-    //if the packet is a probe we need to analyze it
-    if(messageHandler_IsAProbe(message_FixedHeader(message))){
-      FibEntry *fibEntry = fib_MatchMessage(processor->fib, message);
-      if(fibEntry &&
-          fibEntry_GetFwdStrategyType(fibEntry) == SET_STRATEGY_LOW_LATENCY){
-        unsigned connid = message_GetIngressConnectionId(message);
-        NumberSet *outFace = numberSet_Create();
-        numberSet_Add(outFace, connid);
-        fibEntry_ReceiveObjectMessage(fibEntry, outFace, message, 0,
-                                      forwarder_GetTicks(processor->forwarder));
-        numberSet_Release(&(outFace));
-      }
-    }
-
-    // we store the packets in the content store enven in the case where there
-    // is no match in the PIT table in this way the applications can push the
-    // content in the CS of the forwarder. We allow this only for local faces
-    bool isLocal = connection_IsLocal(connectionTable_FindById(
-        forwarder_GetConnectionTable(processor->forwarder),
-        message_GetIngressConnectionId((const Message *)message)));
-    if (processor->store_in_cache && isLocal) {
-      uint64_t currentTimeTicks = forwarder_GetTicks(processor->forwarder);
-      contentStoreInterface_PutContent(processor->contentStore, message,
-                                       currentTimeTicks);
-      if (logger_IsLoggable(processor->logger, LoggerFacility_Processor,
-                            PARCLogLevel_Debug)) {
-        logger_Log(processor->logger, LoggerFacility_Processor,
-                   PARCLogLevel_Debug, __func__,
-                   "Message %p sotred in the CS anyway", (void *)message);
-      }
-    }
-
-    messageProcessor_Drop(processor, message);
-  } else {
-    // (2) Add to Content Store. Store may remove expired content, if necessary,
-    // depending on store policy.
-    if (processor->store_in_cache) {
-      uint64_t currentTimeTicks = forwarder_GetTicks(processor->forwarder);
-      contentStoreInterface_PutContent(processor->contentStore, message,
-                                       currentTimeTicks);
-    }
-    // (3) Reverse path forward via PIT entries
-    messageProcessor_ForwardToNexthops(processor, message, ingressSetUnion);
-
-  }
-
-  numberSet_Release(&ingressSetUnion);
-}
-
-/**
- * @function messageProcessor_ForwardToNexthops
- * @abstract Try to forward to each nexthop listed in the NumberSet
- * @discussion
- *   Will not forward to the ingress connection.
- *
- * @return The number of nexthops tried
- */
-static unsigned messageProcessor_ForwardToNexthops(MessageProcessor *processor,
-                                                   Message *message,
-                                                   const NumberSet *nexthops) {
-  unsigned forwardedCopies = 0;
-
-  size_t length = numberSet_Length(nexthops);
-
-  unsigned ingressId = message_GetIngressConnectionId(message);
-  uint32_t old_path_label = 0;
-
-  if (message_GetType(message) == MessagePacketType_ContentObject) {
-    old_path_label = message_GetPathLabel(message);
-  }
-
-  for (size_t i = 0; i < length; i++) {
-    unsigned egressId = numberSet_GetItem(nexthops, i);
-    if (egressId != ingressId) {
-      forwardedCopies++;
-      messageProcessor_ForwardToInterfaceId(processor, message, egressId);
-
-      if (message_GetType(message) == MessagePacketType_ContentObject) {
-        // everytime we send out a message we need to restore the original path
-        // label of the message this is important because we keep a single copy
-        // of the message (single pointer) and we modify the path label at each
-        // send.
-        message_SetPathLabel(message, old_path_label);
-      }
-    }
-  }
-  return forwardedCopies;
-}
-
-/**
- * caller has checked that the hop limit is ok.  Try to send out the connection.
- */
-static void messageProcessor_SendWithGoodHopLimit(MessageProcessor *processor,
-                                                  Message *message,
-                                                  unsigned interfaceId,
-                                                  const Connection *conn) {
-  bool success = connection_Send(conn, message);
-  if (success) {
-    switch (message_GetType(message)) {
-      case MessagePacketType_Interest:
-        processor->stats.countInterestForwarded++;
-        break;
-
-      case MessagePacketType_ContentObject:
-        processor->stats.countObjectsForwarded++;
-        break;
-
-      default:
-        break;
-    }
-
-    if (logger_IsLoggable(processor->logger, LoggerFacility_Processor,
-                          PARCLogLevel_Debug)) {
-      logger_Log(
-          processor->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-          __func__, "forward message %p to interface %u (int %u, obj %u)",
-          (void *)message, interfaceId, processor->stats.countInterestForwarded,
-          processor->stats.countObjectsForwarded);
-    }
-  } else {
-    processor->stats.countSendFailures++;
-
-    if (logger_IsLoggable(processor->logger, LoggerFacility_Processor,
-                          PARCLogLevel_Debug)) {
-      logger_Log(processor->logger, LoggerFacility_Processor,
-                 PARCLogLevel_Debug, __func__,
-                 "forward message %p to interface %u send failure (count %u)",
-                 (void *)message, interfaceId,
-                 processor->stats.countSendFailures);
-    }
-    messageProcessor_Drop(processor, message);
-  }
-}
-
-/*
- *   If the hoplimit is equal to 0, then we may only forward it to local
- * applications.  Otherwise, we may forward it off the system.
- *
- */
-static void messageProcessor_ForwardToInterfaceId(MessageProcessor *processor,
-                                                  Message *message,
-                                                  unsigned interfaceId) {
-  ConnectionTable *connectionTable =
-      forwarder_GetConnectionTable(processor->forwarder);
-  const Connection *conn =
-      connectionTable_FindById(connectionTable, interfaceId);
-
-  if (conn != NULL) {
-    messageProcessor_SendWithGoodHopLimit(processor, message, interfaceId,
-                                          conn);
-  } else {
-    processor->stats.countDroppedConnectionNotFound++;
-
-    if (logger_IsLoggable(processor->logger, LoggerFacility_Processor,
-                          PARCLogLevel_Debug)) {
-      logger_Log(processor->logger, LoggerFacility_Processor,
-                 PARCLogLevel_Debug, __func__,
-                 "forward message %p to interface %u not found (count %u)",
-                 (void *)message, interfaceId,
-                 processor->stats.countDroppedConnectionNotFound);
-    }
-
-    messageProcessor_Drop(processor, message);
-  }
-}
-
-void messageProcessor_SetCacheStoreFlag(MessageProcessor *processor, bool val) {
-  processor->store_in_cache = val;
-}
-
-bool messageProcessor_GetCacheStoreFlag(MessageProcessor *processor) {
-  return processor->store_in_cache;
-}
-
-void messageProcessor_SetCacheServeFlag(MessageProcessor *processor, bool val) {
-  processor->serve_from_cache = val;
-}
-
-bool messageProcessor_GetCacheServeFlag(MessageProcessor *processor) {
-  return processor->serve_from_cache;
-}
-
-#ifdef WITH_MAPME
-
-FIB *messageProcessor_getFib(MessageProcessor *processor) {
-  return processor->fib;
-}
-
-#endif /* WITH_MAPME */
diff --git a/hicn-light/src/hicn/processor/messageProcessor.h b/hicn-light/src/hicn/processor/messageProcessor.h
deleted file mode 100644
index 6a863aa38..000000000
--- a/hicn-light/src/hicn/processor/messageProcessor.h
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * 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 messageProcessor.h
- * @brief Executes the set of rules dictated by the PacketType
- *
- * This is a "run-to-completion" handling of a message based on the PacketType.
- *
- * The MessageProcessor also owns the PIT and FIB tables.
- *
- */
-
-#ifndef messageProcessor_h
-#define messageProcessor_h
-
-#include <hicn/content_store/contentStoreInterface.h>
-#include <hicn/core/forwarder.h>
-#include <hicn/core/message.h>
-
-#include <hicn/utils/commands.h>
-
-#ifdef WITH_POLICY
-#ifdef WITH_MAPME
-#include <hicn/core/connection.h>
-#endif /* WITH_MAPME */
-#endif /* WITH_POLICY */
-
-struct message_processor;
-typedef struct message_processor MessageProcessor;
-
-/**
- * Allocates a MessageProcessor along with PIT, FIB and ContentStore tables
- *
- * The hicn-light pointer is primarily used for logging (forwarder_Log), getting
- * the configuration, and accessing the connection table.
- *
- * @param [in] Pointer to owning hicn-light process
- *
- * @retval non-null An allocated message processor
- * @retval null An error
- *
- */
-MessageProcessor *messageProcessor_Create(Forwarder *forwarder);
-
-/**
- * Deallocates a message processor an all internal tables
- *
- * @param [in,out] processorPtr Pointer to message processor to de-allocate,
- * will be NULL'd.
- */
-void messageProcessor_Destroy(MessageProcessor **processorPtr);
-
-/**
- * @function messageProcessor_Receive
- * @abstract Process the message, takes ownership of the memory.
- * @discussion
- *   Will call destroy on the memory when done with it, so if the caller wants
- * to keep it, make a reference counted copy.
- *
- *   Receive may modify some fields in the message, such as the HopLimit field.
- */
-void messageProcessor_Receive(MessageProcessor *procesor, Message *message);
-
-/**
- * Adds or updates a route in the FIB
- *
- * If the route already exists, it is replaced
- *
- * @param [in] procesor An allocated message processor
- * @param [in] route The route to update
- *
- * @retval true added or updated
- * @retval false An error
- */
-bool messageProcessor_AddOrUpdateRoute(MessageProcessor *processor,
-                                       add_route_command *control,
-                                       unsigned ifidx);
-
-/**
- * Removes a route from the FIB
- *
- * Removes a specific nexthop for a route.  If there are no nexthops left after
- * the removal, the entire route is deleted from the FIB.
- *
- * @param [in] procesor An allocated message processor
- * @param [in] route The route to remove
- *
- * @retval true Route completely removed
- * @retval false There is still a nexthop for the route
- */
-
-bool messageProcessor_RemoveRoute(MessageProcessor *processor,
-                                  remove_route_command *control,
-                                  unsigned ifidx);
-
-#ifdef WITH_POLICY
-
-/**
- * Adds or updates a policy in the FIB
- *
- * If the policy is already set, it is replaced
- *
- * @param [in] procesor An allocated message processor
- * @param [in] control Control message
- *
- * @retval true added or updated
- * @retval false An error
- */
-bool messageProcessor_AddOrUpdatePolicy(MessageProcessor *processor,
-        add_policy_command *control);
-
-/**
- * Removes a policy from the FIB
- *
- * Reset the policy in the FIB to the default (empty) policy.
- *
- * @param [in] procesor An allocated message processor
- * @param [in] control Control message
- *
- * @retval true Policy completely removed
- * @retval false There is still a nexthop for the policy
- */
-bool messageProcessor_RemovePolicy(MessageProcessor *processor,
-        remove_policy_command *control);
-
-#endif /* WITH_POLICY */
-
-/**
- * Removes a given connection id from all FIB entries
- *
- * Iterates the FIB and removes the given connection ID from every route.
- */
-void messageProcessor_RemoveConnectionIdFromRoutes(MessageProcessor *processor,
-                                                   unsigned connectionId);
-
-/**
- * Returns a list of all FIB entries
- *
- * You must destroy the list.
- *
- * @retval non-null The list of FIB entries
- * @retval null An error
- */
-FibEntryList *messageProcessor_GetFibEntries(MessageProcessor *processor);
-
-/**
- * Adjusts the ContentStore to the given size.
- *
- * This will destroy and re-create the content store, so any cached objects will
- * be lost.
- *
- */
-void messageProcessor_SetContentObjectStoreSize(MessageProcessor *processor,
-                                                size_t maximumContentStoreSize);
-
-/**
- * Return the interface to the currently instantiated ContentStore, if any.
- *
- * @param [in] processor the `MessageProcessor` from which to return the
- * ContentStoreInterface.
- *
- */
-ContentStoreInterface *messageProcessor_GetContentObjectStore(
-    const MessageProcessor *processor);
-
-void messageProcessor_SetCacheStoreFlag(MessageProcessor *processor, bool val);
-
-bool messageProcessor_GetCacheStoreFlag(MessageProcessor *processor);
-
-void messageProcessor_SetCacheServeFlag(MessageProcessor *processor, bool val);
-
-bool messageProcessor_GetCacheServeFlag(MessageProcessor *processor);
-
-void messageProcessor_ClearCache(MessageProcessor *processor);
-
-void processor_SetStrategy(MessageProcessor *processor, Name *prefix,
-                           strategy_type strategy,
-                           unsigned related_prefixes_len,
-                           Name **related_prefixes);
-
-#ifdef WITH_MAPME
-
-/**
- * @function messageProcessor_getFib
- * @abstract Returns the hICN processor's FIB.
- * @param [in] forwarder - Pointer to the hICN processor.
- * @returns Pointer to the hICN FIB.
- */
-FIB *messageProcessor_getFib(MessageProcessor *processor);
-
-#endif /* WITH_MAPME */
-
-#endif  // messageProcessor_h
diff --git a/hicn-light/src/hicn/processor/pit.c b/hicn-light/src/hicn/processor/pit.c
deleted file mode 100644
index 66ad85410..000000000
--- a/hicn-light/src/hicn/processor/pit.c
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * Generic interface to PIT table
- *
- */
-
-#include <parc/assert/parc_Assert.h>
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <hicn/processor/pit.h>
-
-void *pit_Closure(const PIT *pit) { return pit->closure; }
-
-void pit_Release(PIT **pitPtr) { (*pitPtr)->release(pitPtr); }
-
-PITVerdict pit_ReceiveInterest(PIT *pit, Message *interestMessage) {
-  return pit->receiveInterest(pit, interestMessage);
-}
-
-NumberSet *pit_SatisfyInterest(PIT *pit, const Message *objectMessage) {
-  return pit->satisfyInterest(pit, objectMessage);
-}
-
-void pit_RemoveInterest(PIT *pit, const Message *interestMessage) {
-  pit->removeInterest(pit, interestMessage);
-}
-
-PitEntry *pit_GetPitEntry(const PIT *pit, const Message *interestMessage) {
-  return pit->getPitEntry(pit, interestMessage);
-}
diff --git a/hicn-light/src/hicn/processor/pit.h b/hicn-light/src/hicn/processor/pit.h
deleted file mode 100644
index 63a9b20e4..000000000
--- a/hicn-light/src/hicn/processor/pit.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * 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 pit.h
- * @brief The Pending Interest Table interface
- *
- * Interface for implementing a PIT table
- *
- */
-
-#ifndef pit_h
-#define pit_h
-
-#include <hicn/core/forwarder.h>
-#include <hicn/core/message.h>
-#include <hicn/core/numberSet.h>
-#include <hicn/processor/pitEntry.h>
-#include <hicn/processor/pitVerdict.h>
-
-struct pit;
-typedef struct pit PIT;
-
-struct pit {
-  void (*release)(PIT **pitPtr);
-  PITVerdict (*receiveInterest)(PIT *pit, Message *interestMessage);
-  NumberSet *(*satisfyInterest)(PIT *pit, const Message *objectMessage);
-  void (*removeInterest)(PIT *pit, const Message *interestMessage);
-  PitEntry *(*getPitEntry)(const PIT *pit, const Message *interestMessage);
-  void *closure;
-};
-
-void *pit_Closure(const PIT *pit);
-
-/**
- * Destroys the PIT table and all entries contained in it.
- *
- * PIT entries are reference counted, so if the user has stored one outside the
- * PIT table it will still be valid.
- *
- * @param [in,out] pitPtr Double pointer to PIT table, will be NULLed
- */
-void pit_Release(PIT **pitPtr);
-
-/**
- * @function pit_ReceiveInterest
- * @abstract Receives an interest and adds to PIT table
- * @discussion
- *   If not present, adds entry to the PIT table and returns
- * PIT_VERDICT_NEW_ENTRY. If present and aggregated, returns
- * PIT_VERDICT_EXISTING_ENTRY.
- *
- *   Some aggregated interests may return PIT_VERDICT_NEW_ENTRY if the interest
- * needs to be forwarded again (e.g. the lifetime is extended).
- *
- *   If the PIT stores the message in its table, it will store a reference
- * counted copy.
- *
- * @return Verdict of receiving the interest
- */
-PITVerdict pit_ReceiveInterest(PIT *pit, Message *interestMessage);
-
-/**
- * @function pit_SatisfyInterest
- * @abstract Tries to satisfy PIT entries based on the message, returning where
- * to send message
- * @discussion
- *     If matching interests are in the PIT, will return the set of reverse
- * paths to use to forward the content object.
- *
- *     The return value is allocated and must be destroyed.
- *
- * @return Set of ConnectionTable id's to forward the message, may be empty or
- * NULL.  Must be destroyed.
- */
-NumberSet *pit_SatisfyInterest(PIT *pit, const Message *objectMessage);
-
-/**
- * @function pit_RemoveInterest
- * @abstract Unconditionally remove the interest from the PIT
- * @discussion
- *   The PIT may store a specific name in several tables.  This function will
- *   remove the interest from the specific table it lives it.  It will not
- *   remove PIT entries in different tables with the same name.
- *
- *   The different tables index interests based on their matching criteria,
- *   such as by name, by name and keyid, etc.
- *
- */
-void pit_RemoveInterest(PIT *pit, const Message *interestMessage);
-
-/**
- * @function pit_GetPitEntry
- * @abstract Retrieve the best matching PIT entry for the message.
- * @discussion
- *   Returns a reference counted copy of the entry, must call
- * <code>pitEntry_Destory()</code> on it.
- *
- * @return NULL if not in table, otherwise a reference counted copy of the entry
- */
-PitEntry *pit_GetPitEntry(const PIT *pit, const Message *interestMessage);
-#endif  // pit_h
diff --git a/hicn-light/src/hicn/processor/pitEntry.c b/hicn-light/src/hicn/processor/pitEntry.c
deleted file mode 100644
index 99b3f1f2b..000000000
--- a/hicn-light/src/hicn/processor/pitEntry.c
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <hicn/core/numberSet.h>
-#include <hicn/processor/pitEntry.h>
-
-#include <parc/assert/parc_Assert.h>
-
-struct pit_entry {
-  Message *message;
-  NumberSet *ingressIdSet;
-  NumberSet *egressIdSet;
-
-  FibEntry *fibEntry;
-
-  Ticks creationTime;
-  Ticks expiryTime;
-
-  unsigned refcount;
-};
-
-PitEntry *pitEntry_Create(Message *message, Ticks expiryTime,
-                          Ticks creationTime) {
-  PitEntry *pitEntry = parcMemory_AllocateAndClear(sizeof(PitEntry));
-  parcAssertNotNull(pitEntry, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(PitEntry));
-  pitEntry->message = message;
-  pitEntry->ingressIdSet = numberSet_Create();
-  pitEntry->egressIdSet = numberSet_Create();
-  pitEntry->refcount = 1;
-
-  // add the message to the reverse path set
-  numberSet_Add(pitEntry->ingressIdSet,
-                message_GetIngressConnectionId(message));
-
-  // hack in a 4-second timeout
-  pitEntry->expiryTime = expiryTime;
-  pitEntry->fibEntry = NULL;
-
-  pitEntry->creationTime = creationTime;
-  return pitEntry;
-}
-
-void pitEntry_Release(PitEntry **pitEntryPtr) {
-  parcAssertNotNull(pitEntryPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*pitEntryPtr,
-                    "Parameter must dereference to non-null pointer");
-
-  PitEntry *pitEntry = *pitEntryPtr;
-  parcTrapIllegalValueIf(pitEntry->refcount == 0,
-                         "Illegal state: has refcount of 0");
-
-  pitEntry->refcount--;
-  if (pitEntry->refcount == 0) {
-    if (pitEntry->fibEntry != NULL) {
-      fibEntry_Release(&pitEntry->fibEntry);
-    }
-    numberSet_Release(&pitEntry->ingressIdSet);
-    numberSet_Release(&pitEntry->egressIdSet);
-    message_Release(&pitEntry->message);
-    parcMemory_Deallocate((void **)&pitEntry);
-  }
-  *pitEntryPtr = NULL;
-}
-
-PitEntry *pitEntry_Acquire(PitEntry *original) {
-  parcAssertNotNull(original, "Parameter original must be non-null");
-  original->refcount++;
-  return original;
-}
-
-void pitEntry_AddIngressId(PitEntry *pitEntry, unsigned ingressId) {
-  parcAssertNotNull(pitEntry, "Parameter pitEntry must be non-null");
-  numberSet_Add(pitEntry->ingressIdSet, ingressId);
-}
-
-void pitEntry_AddEgressId(PitEntry *pitEntry, unsigned egressId) {
-  parcAssertNotNull(pitEntry, "Parameter pitEntry must be non-null");
-  numberSet_Add(pitEntry->egressIdSet, egressId);
-}
-
-void pitEntry_AddFibEntry(PitEntry *pitEntry, FibEntry *fibEntry) {
-  parcAssertNotNull(pitEntry, "Parameter pitEntry must be non-null");
-  parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null");
-  // the fibEntry should be always the same for all the interests in the same
-  // pitEntry
-  if (pitEntry->fibEntry == NULL) {
-    fibEntry_Acquire(fibEntry);
-    pitEntry->fibEntry = fibEntry;
-  }
-}
-
-FibEntry *pitEntry_GetFibEntry(PitEntry *pitEntry) {
-  parcAssertNotNull(pitEntry, "Parameter pitEntry must be non-null");
-  return pitEntry->fibEntry;
-}
-
-Ticks pitEntry_GetExpiryTime(const PitEntry *pitEntry) {
-  parcAssertNotNull(pitEntry, "Parameter pitEntry must be non-null");
-  return pitEntry->expiryTime;
-}
-
-Ticks pitEntry_GetCreationTime(const PitEntry *pitEntry) {
-  parcAssertNotNull(pitEntry, "Parameter pitEntry must be non-null");
-  return pitEntry->creationTime;
-}
-
-void pitEntry_SetExpiryTime(PitEntry *pitEntry, Ticks expiryTime) {
-  parcAssertNotNull(pitEntry, "Parameter pitEntry must be non-null");
-  pitEntry->expiryTime = expiryTime;
-}
-
-const NumberSet *pitEntry_GetIngressSet(const PitEntry *pitEntry) {
-  parcAssertNotNull(pitEntry, "Parameter pitEntry must be non-null");
-  return pitEntry->ingressIdSet;
-}
-
-const NumberSet *pitEntry_GetEgressSet(const PitEntry *pitEntry) {
-  parcAssertNotNull(pitEntry, "Parameter pitEntry must be non-null");
-  return pitEntry->egressIdSet;
-}
-
-Message *pitEntry_GetMessage(const PitEntry *pitEntry) {
-  parcAssertNotNull(pitEntry, "Parameter pitEntry must be non-null");
-  return message_Acquire(pitEntry->message);
-}
diff --git a/hicn-light/src/hicn/processor/pitEntry.h b/hicn-light/src/hicn/processor/pitEntry.h
deleted file mode 100644
index 3cd5821bc..000000000
--- a/hicn-light/src/hicn/processor/pitEntry.h
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- * 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 pitEntry.h
- * @brief The embodiment of a PIT entry
- *
- * Embodies a PIT entry
- *
- */
-
-#ifndef pitEntry_h
-#define pitEntry_h
-
-#include <hicn/core/message.h>
-#include <hicn/core/numberSet.h>
-#include <hicn/core/ticks.h>
-#include <hicn/processor/fibEntry.h>
-
-struct pit_entry;
-typedef struct pit_entry PitEntry;
-
-/**
- * @function pitEntry_Create
- * @abstract Takes ownership of the message inside the PitEntry
- * @discussion
- *   When the PIT entry is destroyed, will call <code>message_Release()</code>
- * on the message.
- *
- */
-PitEntry *pitEntry_Create(Message *message, Ticks expiryTime,
-                          Ticks CreationTime);
-
-/**
- * Release a previously acquired reference to the specified instance,
- * decrementing the reference count for the instance.
- *
- * The pointer to the instance is set to NULL as a side-effect of this function.
- *
- * If the invocation causes the last reference to the instance to be released,
- * the instance is deallocated and the instance's implementation will perform
- * additional cleanup and release other privately held references.
- *
- * @param [in,out] pitEntryPtr A pointer to a PitEntry instance pointer, which
- * will be set to zero on return.
- *
- */
-void pitEntry_Release(PitEntry **pitEntryPtr);
-
-/**
- * @function pitEntry_Acquire
- * @abstract Returns a reference counted copy
- * @discussion
- *   A reference counted copy that shares the same state as the original.
- *   Caller must use <code>pitEntry_Release()</code> on it when done.
- *
- * @return A reference counted copy, use Destroy on it.
- */
-PitEntry *pitEntry_Acquire(PitEntry *original);
-
-/**
- * @function pitEntry_AddIngressId
- * @abstract Add an ingress connection id to the list of reverse paths
- * @discussion
- *   A PitEntry has two NumberSets.  The first is the set of ingress ports,
- * which make up the reverse path.  The second is the set of egress ports, which
- * make up its forward path.
- *
- *   This function tracks which reverse paths have sent us the interest.
- *
- * @param ingressId the reverse path
- */
-void pitEntry_AddIngressId(PitEntry *pitEntry, unsigned ingressId);
-
-/**
- * @function pitEntry_AddEgressId
- * @abstract Add an egress connection id to the list of attempted paths
- * @discussion
- *   A PitEntry has two NumberSets.  The first is the set of ingress ports,
- * which make up the reverse path.  The second is the set of egress ports, which
- * make up its forward path.
- *
- *   This function tracks which forward paths we've tried for the interest.
- *
- * @param egressId the forwarded path
- */
-void pitEntry_AddEgressId(PitEntry *pitEntry, unsigned egressId);
-
-void pitEntry_AddFibEntry(PitEntry *pitEntry, FibEntry *fibEntry);
-
-FibEntry *pitEntry_GetFibEntry(PitEntry *pitEntry);
-
-/**
- * @function pitEntry_GetIngressSet
- * @abstract The Ingress connection id set
- * @discussion
- *   You must acquire a copy of the number set if you will store the result.
- * This is the internal reference.
- *
- * @return May be empty, will not be null.  Must be destroyed.
- */
-const NumberSet *pitEntry_GetIngressSet(const PitEntry *pitEntry);
-
-/**
- * @function pitEntry_GetEgressSet
- * @abstract The Egress connection id set
- * @discussion
- *   You must acquire a copy of the number set if you will store the result.
- * This is the internal reference.
- *
- * @param <#param1#>
- * @return May be empty, will not be null.  Must be destroyed.
- */
-const NumberSet *pitEntry_GetEgressSet(const PitEntry *pitEntry);
-
-/**
- * @function pitEntry_GetMessage
- * @abstract Gets the interest underpinning the PIT entry
- * @discussion
- *   A reference counted copy, call <code>Message_Release()</code> on it.
- *
- * @return A reference counted copy, call <code>Message_Release()</code> on it.
- */
-Message *pitEntry_GetMessage(const PitEntry *pitEntry);
-
-/**
- * Returns the time (in ticks) at which the PIT entry is no longer valid
- *
- * The ExpiryTime is computed when the PIT entry is added (or via
- * pitEntry_SetExpiryTime). It is the aboslute time (in Ticks) at which the Pit
- * entry is no longer valid.
- *
- * @param [in] PitEntry An allocated PIT entry
- *
- * @retval number The abosolute time (in Ticks) of the Expiry
- */
-Ticks pitEntry_GetExpiryTime(const PitEntry *pitEntry);
-
-Ticks pitEntry_GetCreationTime(const PitEntry *pitEntry);
-/**
- * Sets the ExpriyTime of the PIT entry to the given value
- *
- * It is probalby an error to set the expiryTime to a smaller value than
- * currently set to, but this is not enforced.  PIT entries use lazy delete.
- *
- * @param [in] pitEntry The allocated PIT entry to modify
- * @param [in] expiryTime The new expiryTime (UTC in forwarder Ticks)
- *
- */
-void pitEntry_SetExpiryTime(PitEntry *pitEntry, Ticks expiryTime);
-
-#endif  // pitEntry_h
diff --git a/hicn-light/src/hicn/processor/pitStandard.c b/hicn-light/src/hicn/processor/pitStandard.c
deleted file mode 100644
index 04d886261..000000000
--- a/hicn-light/src/hicn/processor/pitStandard.c
+++ /dev/null
@@ -1,305 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * The pending interest table.
- *
- * Interest aggregation strategy:
- * - The first Interest for a name is forwarded
- * - A second Interest for a name from a different reverse path may be
- * aggregated
- * - A second Interest for a name from an existing Interest is forwarded
- * - The Interest Lifetime is like a subscription time.  A reverse path entry is
- * removed once the lifetime is exceeded.
- * - Whan an Interest arrives or is aggregated, the Lifetime for that reverse
- * hop is extended.  As a simplification, we only keep a single lifetime not per
- * reverse hop.
- *
- */
-
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#define __STDC_FORMAT_MACROS
-#include <inttypes.h>
-
-#include <hicn/processor/hashTableFunction.h>
-#include <hicn/processor/pit.h>
-
-#include <hicn/core/ticks.h>
-
-#include <parc/algol/parc_Hash.h>
-#include <parc/algol/parc_HashCodeTable.h>
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/core/forwarder.h>
-
-#include <parc/assert/parc_Assert.h>
-
-struct standard_pit;
-typedef struct standard_pit StandardPIT;
-
-struct standard_pit {
-  Forwarder *forwarder;
-  Logger *logger;
-  PARCHashCodeTable *table;  // PIT indexed by name
-};
-
-static void _pit_StoreInTable(StandardPIT *pit, Message *interestMessage);
-
-static void _pit_PitEntryDestroyer(void **dataPtr) {
-  pitEntry_Release((PitEntry **)dataPtr);
-}
-
-static bool _pit_IngressSetContains(PitEntry *pitEntry, unsigned connectionId) {
-  const NumberSet *set = pitEntry_GetIngressSet(pitEntry);
-  bool numberInSet = numberSet_Contains(set, connectionId);
-  return numberInSet;
-}
-
-static Ticks _pit_CalculateLifetime(StandardPIT *pit,
-                                    Message *interestMessage) {
-  uint64_t interestLifetimeTicks =
-      message_GetInterestLifetimeTicks(interestMessage);
-  if (interestLifetimeTicks == 0) {
-    interestLifetimeTicks = forwarder_NanosToTicks(4000000000ULL);
-  }
-
-  Ticks expiryTime = forwarder_GetTicks(pit->forwarder) + interestLifetimeTicks;
-  return expiryTime;
-}
-
-static void _pit_StoreInTable(StandardPIT *pit, Message *interestMessage) {
-  Message *key = message_Acquire(interestMessage);
-
-  Ticks expiryTime = _pit_CalculateLifetime(pit, interestMessage);
-
-  PitEntry *pitEntry =
-      pitEntry_Create(key, expiryTime, forwarder_GetTicks(pit->forwarder));
-
-  parcHashCodeTable_Add(pit->table, key, pitEntry);
-
-  if (logger_IsLoggable(pit->logger, LoggerFacility_Processor,
-                        PARCLogLevel_Debug)) {
-    logger_Log(pit->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-               __func__,
-               "Message %p added to PIT (expiry %" PRIu64 ") ingress %u",
-               (void *)interestMessage, pitEntry_GetExpiryTime(pitEntry),
-               message_GetIngressConnectionId(interestMessage));
-  }
-}
-
-static void _pit_ExtendLifetime(StandardPIT *pit, PitEntry *pitEntry,
-                                Message *interestMessage) {
-  Ticks expiryTime = _pit_CalculateLifetime(pit, interestMessage);
-
-  if (expiryTime > pitEntry_GetExpiryTime(pitEntry))
-    pitEntry_SetExpiryTime(pitEntry, expiryTime);
-}
-
-// ======================================================================
-// Interface API
-
-static void _pitStandard_Destroy(PIT **pitPtr) {
-  parcAssertNotNull(pitPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*pitPtr, "Parameter must dereference to non-null pointer");
-
-  StandardPIT *pit = pit_Closure(*pitPtr);
-
-  if (logger_IsLoggable(pit->logger, LoggerFacility_Processor,
-                        PARCLogLevel_Debug)) {
-    logger_Log(pit->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-               __func__, "PIT %p destroyed", (void *)pit);
-  }
-
-  parcHashCodeTable_Destroy(&pit->table);
-  logger_Release(&pit->logger);
-  parcMemory_Deallocate(pitPtr);
-}
-
-static PITVerdict _pitStandard_ReceiveInterest(PIT *generic,
-                                               Message *interestMessage) {
-  parcAssertNotNull(generic, "Parameter pit must be non-null");
-  parcAssertNotNull(interestMessage,
-                    "Parameter interestMessage must be non-null");
-
-  StandardPIT *pit = pit_Closure(generic);
-
-  PitEntry *pitEntry = parcHashCodeTable_Get(pit->table, interestMessage);
-
-  if (pitEntry) {
-    // has it expired?
-    Ticks now = forwarder_GetTicks(pit->forwarder);
-    if (now < pitEntry_GetExpiryTime(pitEntry)) {
-      _pit_ExtendLifetime(pit, pitEntry, interestMessage);
-
-      // Is the reverse path already in the PIT entry?
-      if (_pit_IngressSetContains(
-              pitEntry, message_GetIngressConnectionId(interestMessage))) {
-        // It is already in the PIT entry, so this is a retransmission, so
-        // forward it.
-
-        if (logger_IsLoggable(pit->logger, LoggerFacility_Processor,
-                              PARCLogLevel_Debug)) {
-          logger_Log(pit->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-                     __func__,
-                     "Message %p existing entry (expiry %" PRIu64
-                     ") and reverse path, forwarding",
-                     (void *)interestMessage, pitEntry_GetExpiryTime(pitEntry));
-        }
-#ifdef WITH_POLICY
-        return PITVerdict_Retransmit;
-#else
-        return PITVerdict_Forward;
-#endif /* WITH_POLICY */
-      }
-
-      // It is in the PIT but this is the first interest for the reverse path
-      pitEntry_AddIngressId(pitEntry,
-                            message_GetIngressConnectionId(interestMessage));
-
-      if (logger_IsLoggable(pit->logger, LoggerFacility_Processor,
-                            PARCLogLevel_Debug)) {
-        logger_Log(pit->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-                   __func__,
-                   "Message %p existing entry (expiry %" PRIu64
-                   ") and reverse path is new, aggregate",
-                   (void *)interestMessage, pitEntry_GetExpiryTime(pitEntry));
-      }
-
-      return PITVerdict_Aggregate;
-    }
-    // this is a timeout....
-    FibEntry *fibEntry = pitEntry_GetFibEntry(pitEntry);
-    if (fibEntry != NULL) {
-      fibEntry_OnTimeout(fibEntry, pitEntry_GetEgressSet(pitEntry));
-    }
-
-    // it's an old entry, remove it
-    parcHashCodeTable_Del(pit->table, interestMessage);
-  }
-
-  _pit_StoreInTable(pit, interestMessage);
-
-  return PITVerdict_Forward;
-}
-
-static NumberSet *_pitStandard_SatisfyInterest(PIT *generic,
-                                               const Message *objectMessage) {
-  parcAssertNotNull(generic, "Parameter pit must be non-null");
-  parcAssertNotNull(objectMessage, "Parameter objectMessage must be non-null");
-
-  StandardPIT *pit = pit_Closure(generic);
-
-  NumberSet *ingressSet = numberSet_Create();
-
-  PitEntry *pitEntry = parcHashCodeTable_Get(pit->table, objectMessage);
-  if (pitEntry) {
-    // here we need to check if the PIT entry is expired
-    // if so, remove the PIT entry.
-    Ticks now = forwarder_GetTicks(pit->forwarder);
-    if (now < pitEntry_GetExpiryTime(pitEntry)) {
-      // PIT entry is not expired, use it
-      FibEntry *fibEntry = pitEntry_GetFibEntry(pitEntry);
-      if (fibEntry != NULL) {
-        fibEntry_ReceiveObjectMessage(fibEntry, pitEntry_GetEgressSet(pitEntry),
-                                      objectMessage,
-                                      pitEntry_GetCreationTime(pitEntry),
-                                      forwarder_GetTicks(pit->forwarder));
-      }
-      const NumberSet *is = pitEntry_GetIngressSet(pitEntry);
-      numberSet_AddSet(ingressSet, is);  // with this we do a copy so we can
-                                         // remove the entry from the PIT
-    }
-    // remove the entry from the PIT.  Key is a reference counted copy of the
-    // pit entry message
-    Message *key = pitEntry_GetMessage(pitEntry);
-    parcHashCodeTable_Del(pit->table, key);
-    message_Release(&key);
-  }
-
-  return ingressSet;
-}
-
-static void _pitStandard_RemoveInterest(PIT *generic,
-                                        const Message *interestMessage) {
-  parcAssertNotNull(generic, "Parameter pit must be non-null");
-  parcAssertNotNull(interestMessage,
-                    "Parameter interestMessage must be non-null");
-
-  StandardPIT *pit = pit_Closure(generic);
-
-  if (logger_IsLoggable(pit->logger, LoggerFacility_Processor,
-                        PARCLogLevel_Debug)) {
-    logger_Log(pit->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-               __func__, "Message %p removed from PIT",
-               (void *)interestMessage);
-  }
-
-  parcHashCodeTable_Del(pit->table, interestMessage);
-}
-
-static PitEntry *_pitStandard_GetPitEntry(const PIT *generic,
-                                          const Message *interestMessage) {
-  parcAssertNotNull(generic, "Parameter pit must be non-null");
-  parcAssertNotNull(interestMessage,
-                    "Parameter interestMessage must be non-null");
-
-  StandardPIT *pit = pit_Closure(generic);
-
-  PitEntry *entry = parcHashCodeTable_Get(pit->table, interestMessage);
-  if (entry) {
-    return pitEntry_Acquire(entry);
-  }
-  return NULL;
-}
-
-// ======================================================================
-// Public API
-
-PIT *pitStandard_Create(Forwarder *forwarder) {
-  parcAssertNotNull(forwarder, "Parameter must be non-null");
-
-  size_t allocation = sizeof(PIT) + sizeof(StandardPIT);
-
-  PIT *generic = parcMemory_AllocateAndClear(allocation);
-  parcAssertNotNull(generic, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    allocation);
-  generic->closure = (uint8_t *)generic + sizeof(PIT);
-
-  StandardPIT *pit = pit_Closure(generic);
-  pit->forwarder = forwarder;
-  pit->logger = logger_Acquire(forwarder_GetLogger(forwarder));
-
-  size_t initialSize = 65535;
-  pit->table =
-      parcHashCodeTable_Create_Size(hashTableFunction_MessageNameEquals,
-                                    hashTableFunction_MessageNameHashCode, NULL,
-                                    _pit_PitEntryDestroyer, initialSize);
-
-  if (logger_IsLoggable(pit->logger, LoggerFacility_Processor,
-                        PARCLogLevel_Debug)) {
-    logger_Log(pit->logger, LoggerFacility_Processor, PARCLogLevel_Debug,
-               __func__, "PIT %p created", (void *)pit);
-  }
-
-  generic->getPitEntry = _pitStandard_GetPitEntry;
-  generic->receiveInterest = _pitStandard_ReceiveInterest;
-  generic->release = _pitStandard_Destroy;
-  generic->removeInterest = _pitStandard_RemoveInterest;
-  generic->satisfyInterest = _pitStandard_SatisfyInterest;
-
-  return generic;
-}
diff --git a/hicn-light/src/hicn/processor/pitStandard.h b/hicn-light/src/hicn/processor/pitStandard.h
deleted file mode 100644
index 9d7ce6a23..000000000
--- a/hicn-light/src/hicn/processor/pitStandard.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * 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 pitStandard.h
- * @brief The Pending Interest Table
- *
- * Implements the standard Pending Interest Table.
- *
- */
-
-#ifndef pitStandard_h
-#define pitStandard_h
-
-#include <hicn/processor/pit.h>
-
-/**
- * Creates a PIT table
- *
- * Creates and allocates an emtpy PIT table.  The Forwarder reference is
- * used for logging and for time functions.
- *
- * @param [in] hicn-light The releated Forwarder
- *
- * @return non-null a PIT table
- * @return null An error
- */
-PIT *pitStandard_Create(Forwarder *forwarder);
-#endif  // pit_h
diff --git a/hicn-light/src/hicn/processor/pitVerdict.h b/hicn-light/src/hicn/processor/pitVerdict.h
deleted file mode 100644
index f37242027..000000000
--- a/hicn-light/src/hicn/processor/pitVerdict.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * 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 pitVerdict.h
- * @brief Adding an entry to the PIT will return NEW or EXISTING
- *
- * Adding an entry to the PIT will return NEW or EXISTING
- *
- */
-
-#ifndef pitVerdict_h
-#define pitVerdict_h
-
-/**
- * @typedef PitVerdict
- * @abstract The verdit of the PIT for receiving a message
- * @constant PITVerdict_Forward The message made a new PIT entry, the interest
- * should be forwarded
- * @constant PITVerdict_Aggregate The Interest was aggregated in the PIT, does
- * not need to be forwarded
- */
-#ifdef WITH_POLICY
-typedef enum { PITVerdict_Forward, PITVerdict_Aggregate, PITVerdict_Retransmit } PITVerdict;
-#else
-typedef enum { PITVerdict_Forward, PITVerdict_Aggregate } PITVerdict;
-#endif /* WITH_POLICY */
-#endif  // pitVerdict_h
diff --git a/hicn-light/src/hicn/socket/CMakeLists.txt b/hicn-light/src/hicn/socket/CMakeLists.txt
index 8c8a757fb..41dbd2342 100644
--- a/hicn-light/src/hicn/socket/CMakeLists.txt
+++ b/hicn-light/src/hicn/socket/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -25,11 +25,5 @@ if (UNIX AND NOT APPLE)
   )
 endif()
 
-set(TO_INSTALL_HEADER_FILES
-  ${TO_INSTALL_HEADER_FILES}
-  ${HEADER_FILES}
-  PARENT_SCOPE
-)
-
 set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
 set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
diff --git a/hicn-light/src/hicn/socket/api.c b/hicn-light/src/hicn/socket/api.c
index 34c0aae54..e39ebf4b5 100644
--- a/hicn-light/src/hicn/socket/api.c
+++ b/hicn-light/src/hicn/socket/api.c
@@ -10,8 +10,12 @@
 #include <unistd.h>      // close
 
 #include "api.h"
-#include "error.h"
 #include "ops.h"
+#include <hicn/util/sstrncpy.h>
+
+#if __linux__
+#include "error.h"
+#endif
 
 #define INET_MAX_ADDRSTRLEN INET6_ADDRSTRLEN
 
@@ -72,8 +76,7 @@ hicn_socket_helper_t *hicn_create() {
   }
 
   hicn->conf = malloc(sizeof(hicn_conf_t));
-  if (hicn->conf < 0)
-    goto ERR_CONF;
+  if (hicn->conf < 0) goto ERR_CONF;
   memcpy(hicn->conf, &hicn_default_conf, sizeof(hicn_conf_t));
 
   /* Initialize socket tree to empty */
@@ -133,20 +136,16 @@ void hicn_destroy() {
   /* Restore default rules */
   printf("Restoring default configuration.\n");
   rc = ops.del_lo_prio_rule(NULL, AF_INET6, LOCAL_PRIORITY);
-  if (rc < 0)
-    ret = -1;
+  if (rc < 0) ret = -1;
 
   rc = ops.del_lo_prio_rule(NULL, AF_INET, LOCAL_PRIORITY);
-  if (rc < 0)
-    ret = -1;
+  if (rc < 0) ret = -1;
 
   rc = ops.add_lo_prio_rule(NULL, AF_INET6, 0);
-  if (rc < 0)
-    ret = -1;
+  if (rc < 0) ret = -1;
 
   rc = ops.add_lo_prio_rule(NULL, AF_INET, 0);
-  if (rc < 0)
-    ret = -1;
+  if (rc < 0) ret = -1;
 
   for (i = 0; i < rules_counter; i++) {
     if (strcmp(rules_to_remove[i].tun_name, "NONE") != 0) {
@@ -158,20 +157,17 @@ void hicn_destroy() {
           &rules_to_remove[i].prefix, rules_to_remove[i].address_family,
           rules_to_remove[i].priority, rules_to_remove[i].table_id);
     }
-    if (rc < 0)
-      ret = -1;
+    if (rc < 0) ret = -1;
   }
 
   for (i = 0; i < routes_counter; i++) {
     rc = ops.del_out_route(routes_to_remove[i].remote_ip_address,
                            routes_to_remove[i].address_family,
                            routes_to_remove[i].table_id);
-    if (rc < 0)
-      ret = -1;
+    if (rc < 0) ret = -1;
   }
 
-  if (ret < 0)
-      printf("Unexpected exit. Some state may not be deleted.\n");
+  if (ret < 0) printf("Unexpected exit. Some state may not be deleted.\n");
 }
 
 void hicn_free(hicn_socket_helper_t *hicn) {
@@ -259,10 +255,10 @@ int hicn_get_local_address(const ip_prefix_t *remote_address,
                            ip_prefix_t *local_address) {
   int rc = 0;
   uint32_t interface_id;
-  char remote_address_str[INET_MAX_ADDRSTRLEN + 4 ];
+  char remote_address_str[INET_MAX_ADDRSTRLEN + 4];
 
   rc = ip_prefix_ntop_short(remote_address, remote_address_str,
-                    sizeof(remote_address_str));
+                            sizeof(remote_address_str));
   if (rc < 0) {
     rc = HICN_SOCKET_ERROR_BIND_REMOTE_REPR;
     goto ERR;
@@ -331,7 +327,8 @@ int hicn_set_remote_endpoint(hicn_socket_t *socket,
     /////
 
     /* Convert to representation format */
-    rc = ip_prefix_ntop_short(&addr, local_ip_address, sizeof(local_ip_address));
+    rc =
+        ip_prefix_ntop_short(&addr, local_ip_address, sizeof(local_ip_address));
     if (rc < 0) {
       rc = HICN_SOCKET_ERROR_BIND_REMOTE_REPR;
       goto ERR;
@@ -466,7 +463,9 @@ int hicn_listen(hicn_socket_helper_t *hicn, int fd, const char *prefix) {
     return rc;
   }
 
-  strcpy(rules_to_remove[rules_counter].tun_name, "NONE");
+  rc = strcpy_s(rules_to_remove[rules_counter].tun_name,
+                sizeof(rules_to_remove[rules_counter].tun_name), "NONE");
+  if (rc != EOK) return -1;
 
   rules_to_remove[rules_counter].prefix = ip_prefix;
   rules_to_remove[rules_counter].address_family = ip_prefix.family;
@@ -533,7 +532,10 @@ int hicn_bind(hicn_socket_helper_t *hicn, int fd,
     goto ERR;
   }
 
-  strcpy(rules_to_remove[rules_counter].tun_name, socket->tun_name);
+  rc = strcpy_s(rules_to_remove[rules_counter].tun_name,
+                sizeof(rules_to_remove[rules_counter].tun_name),
+                socket->tun_name);
+  if (rc != EOK) return -1;
   rules_to_remove[rules_counter].address_family = addr_family;
   rules_to_remove[rules_counter].table_id = socket->connection.table_id;
   ++rules_counter;
@@ -563,7 +565,13 @@ int hicn_bind(hicn_socket_helper_t *hicn, int fd,
     goto ERR;
   }
 
-  strcpy(routes_to_remove[routes_counter].remote_ip_address, remote_ip_address);
+  rc = strcpy_s(routes_to_remove[routes_counter].remote_ip_address,
+                sizeof(rules_to_remove[rules_counter].tun_name),
+                remote_ip_address);
+  if (rc != EOK) {
+    rc = HICN_SOCKET_ERROR_UNSPEC;
+    goto ERR;
+  }
   routes_to_remove[routes_counter].table_id = socket->connection.table_id;
   routes_to_remove[routes_counter].address_family = (uint8_t)addr_family;
   ++routes_counter;
diff --git a/hicn-light/src/hicn/socket/api.h b/hicn-light/src/hicn/socket/api.h
index 1a7f5c700..a0356e035 100644
--- a/hicn-light/src/hicn/socket/api.h
+++ b/hicn-light/src/hicn/socket/api.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,7 +29,6 @@
 #include <stdlib.h>
 
 #include <hicn/hicn.h>
-#include "error.h"
 
 #define BUFSIZE 4096
 #define MAX_CONNECTIONS \
diff --git a/hicn-light/src/hicn/socket/ops_linux.c b/hicn-light/src/hicn/socket/ops_linux.c
index 8bfc438f3..d741fd2e6 100644
--- a/hicn-light/src/hicn/socket/ops_linux.c
+++ b/hicn-light/src/hicn/socket/ops_linux.c
@@ -24,6 +24,8 @@
 
 #include <stdint.h>
 #include <stdlib.h>
+#include <hicn/ctrl/api.h>
+#include <hicn/util/sstrncpy.h>
 
 /* Public interface */
 
@@ -338,7 +340,8 @@ uint32_t _nl_get_ifid(const char *interface_name) {
   struct nlmsghdr *hdr = (struct nlmsghdr *)buffer;
   size_t n;
   int fd;
-  size_t len = interface_name ? strlen(interface_name) + 1 : 0;
+  size_t len =
+      interface_name ? strnlen_s(interface_name, INTERFACE_LEN) + 1 : 0;
   uint8_t padding[RTA_ALIGNTO] = {0, 0, 0, 0};
 
   if (len == 0) {
@@ -353,8 +356,8 @@ uint32_t _nl_get_ifid(const char *interface_name) {
            .hdr.nlmsg_flags = FLAGS_GET,
            .payload.ifi_family = AF_UNSPEC,
            .payload.ifi_index = 0};
-  struct rtattr a_ifname = {RTA_LENGTH(strlen(interface_name) + 1),
-                            IFLA_IFNAME};
+  struct rtattr a_ifname = {
+      RTA_LENGTH(strnlen_s(interface_name, INTERFACE_LEN) + 1), IFLA_IFNAME};
 
   struct iovec iov[] = {{&msg, sizeof(msg)},
                         {&a_ifname, sizeof(a_ifname)},
@@ -621,13 +624,12 @@ int _nl_set_ip_addr(uint32_t interface_id, ip_prefix_t *prefix) {
   /* Set attributes = length/type/value */
   struct rtattr ifa_address = {RTA_LENGTH(ip_address_len(prefix->family)),
                                IFA_ADDRESS};
-  const void * address = ip_address_get_buffer(&prefix->address, prefix->family);
-  if (!address)
-      goto ERR_ADDRESS;
+  const void *address = ip_address_get_buffer(&prefix->address, prefix->family);
+  if (!address) goto ERR_ADDRESS;
   const struct iovec iov[] = {
       {&msg, sizeof(msg)},
       {&ifa_address, sizeof(ifa_address)},
-      {(void*)address, ip_address_len(prefix->family)},
+      {(void *)address, ip_address_len(prefix->family)},
   };
   msg.hdr.nlmsg_len = iov_length(iov, ARRAY_SIZE(iov));
 
@@ -993,17 +995,15 @@ int _nl_del_lo_route(const ip_prefix_t *prefix) {
   uint32_t one = 1;
   struct rtattr a_dst = {RTA_LENGTH(ip_address_len(prefix->family)), RTA_DST};
   struct rtattr a_ifid_lo = {RTA_LENGTH(sizeof(uint32_t)), RTA_OIF};
-  const void * address = ip_address_get_buffer(&prefix->address, prefix->family);
-  if (!address)
-      goto ERR;
-  const struct iovec iov[] = {
-      {&msg, sizeof(msg)},
-      /* Ip address */
-      {&a_dst, sizeof(a_dst)},
-      {(void*)address, ip_address_len(prefix->family)},
-      /* Interface id */
-      {&a_ifid_lo, sizeof(a_ifid_lo)},
-      {&one, sizeof(one)}};
+  const void *address = ip_address_get_buffer(&prefix->address, prefix->family);
+  if (!address) goto ERR;
+  const struct iovec iov[] = {{&msg, sizeof(msg)},
+                              /* Ip address */
+                              {&a_dst, sizeof(a_dst)},
+                              {(void *)address, ip_address_len(prefix->family)},
+                              /* Interface id */
+                              {&a_ifid_lo, sizeof(a_ifid_lo)},
+                              {&one, sizeof(one)}};
   msg.hdr.nlmsg_len = iov_length(iov, ARRAY_SIZE(iov));
 
   fd = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
@@ -1048,7 +1048,7 @@ int _nl_add_rule(const char *interface_name, uint8_t address_family,
   _nl_payload_rule(table_id, address_family, (uint8_t *)buffer, BUFSIZE);
 
   addAttr(hdr, BUFSIZE, FRA_IIFNAME, (void *)interface_name,
-          strlen(interface_name));
+          strnlen_s(interface_name, INTERFACE_LEN));
 
   fd = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
   if (fd < 0) {
@@ -1094,7 +1094,7 @@ int _nl_del_rule(const char *interface_name, uint8_t address_family,
   _nl_payload_rule(table_id, address_family, (uint8_t *)buffer, BUFSIZE);
 
   addAttr(hdr, BUFSIZE, FRA_IIFNAME, (void *)interface_name,
-          strlen(interface_name));
+          strnlen_s(interface_name, INTERFACE_LEN));
 
   fd = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
   if (fd < 0) {
@@ -1158,16 +1158,15 @@ int _nl_add_neigh_proxy(const ip_prefix_t *prefix,
   /* Message attributes = length/type/value */
   struct rtattr a_dst = {RTA_LENGTH(ip_address_len(prefix->family)), NDA_DST};
 
-  const void * address = ip_address_get_buffer(&prefix->address, prefix->family);
-  if (!address)
-      goto ERR;
+  const void *address = ip_address_get_buffer(&prefix->address, prefix->family);
+  if (!address) goto ERR;
 
   /* Iovec describing the packets */
   const struct iovec iov[] = {
       {&msg, sizeof(msg)},
       /* Ip address */
       {&a_dst, sizeof(a_dst)},
-      {(void*)address, ip_address_len(prefix->family)},
+      {(void *)address, ip_address_len(prefix->family)},
   };
   msg.hdr.nlmsg_len = iov_length(iov, ARRAY_SIZE(iov));
 
@@ -1240,16 +1239,15 @@ int _nl_add_in_route_table(const ip_prefix_t *prefix,
   struct rtattr a_dst = {RTA_LENGTH(ip_address_len(prefix->family)), RTA_DST};
   struct rtattr a_oif = {RTA_LENGTH(sizeof(uint32_t)), RTA_OIF};
 
-  const void * address = ip_address_get_buffer(&prefix->address, prefix->family);
-  if (!address)
-      goto ERR;
+  const void *address = ip_address_get_buffer(&prefix->address, prefix->family);
+  if (!address) goto ERR;
 
   /* Iovec describing the packets */
   const struct iovec iov[] = {
       {&msg, sizeof(msg)},
       /* Destination prefix / ip address */
       {&a_dst, sizeof(a_dst)},
-      {(void*)address, ip_address_len(prefix->family)},
+      {(void *)address, ip_address_len(prefix->family)},
       /* Output interface */
       {&a_oif, sizeof(a_oif)},
       {(void *)&interface_id, sizeof(uint32_t)},
@@ -1346,15 +1344,15 @@ int _nl_add_prio_rule(const ip_prefix_t *prefix, uint8_t address_family,
     struct rtattr a_src = {RTA_LENGTH(ip_address_len(prefix->family)), FRA_SRC};
     struct rtattr a_prio = {RTA_LENGTH(sizeof(uint32_t)), FRA_PRIORITY};
 
-    const void * address = ip_address_get_buffer(&prefix->address, prefix->family);
-    if (!address)
-        goto ERR;
+    const void *address =
+        ip_address_get_buffer(&prefix->address, prefix->family);
+    if (!address) goto ERR;
     /* Iovec describing the packets */
     const struct iovec iov[] = {
         {&msg, sizeof(msg)},
         /* Source prefix / prefix */
         {&a_src, sizeof(a_src)},
-        {(void*)address, ip_address_len(prefix->family)},
+        {(void *)address, ip_address_len(prefix->family)},
         /* Priority */
         {&a_prio, sizeof(a_prio)},
         {(void *)&priority, sizeof(uint32_t)},
@@ -1407,8 +1405,7 @@ ERR:
 
 int _nl_add_lo_prio_rule(const ip_prefix_t *prefix, uint8_t address_family,
                          const uint32_t priority) {
-  return _nl_add_prio_rule(prefix, address_family, priority,
-                           RT_TABLE_LOCAL);
+  return _nl_add_prio_rule(prefix, address_family, priority, RT_TABLE_LOCAL);
 }
 
 /* ip -6 rule del from all prio 0 table local */
@@ -1450,16 +1447,16 @@ int _nl_del_prio_rule(const ip_prefix_t *prefix, uint8_t address_family,
     struct rtattr a_src = {RTA_LENGTH(ip_address_len(prefix->family)), FRA_SRC};
     struct rtattr a_prio = {RTA_LENGTH(sizeof(uint32_t)), FRA_PRIORITY};
 
-    const void * address = ip_address_get_buffer(&prefix->address, prefix->family);
-    if (!address)
-        goto ERR;
+    const void *address =
+        ip_address_get_buffer(&prefix->address, prefix->family);
+    if (!address) goto ERR;
 
     /* Iovec describing the packets */
     const struct iovec iov[] = {
         {&msg, sizeof(msg)},
         /* Source prefix / prefix */
         {&a_src, sizeof(a_src)},
-        {(void*)address, ip_address_len(prefix->family)},
+        {(void *)address, ip_address_len(prefix->family)},
         /* Priority */
         {&a_prio, sizeof(a_prio)},
         {(void *)&priority, sizeof(uint32_t)},
@@ -1539,7 +1536,7 @@ int _nl_del_lo_prio_rule(const ip_prefix_t *ip_address, uint8_t address_family,
 
 int tun_alloc(char *dev, int flags) {
   struct ifreq ifr;
-  int fd, err;
+  int fd, err, rc;
   char *clonedev = "/dev/net/tun";
 
   /* Arguments taken by the function:
@@ -1563,7 +1560,8 @@ int tun_alloc(char *dev, int flags) {
     /* if a device name was specified, put it in the structure; otherwise,
      * the kernel will try to allocate the "next" device of the
      * specified type */
-    strncpy(ifr.ifr_name, dev, IF_NAMESIZE - 1);
+    rc = strcpy_s(ifr.ifr_name, IF_NAMESIZE - 1, dev);
+    if (rc != EOK) return -1;
   }
 
   /* try to create the device */
@@ -1576,7 +1574,8 @@ int tun_alloc(char *dev, int flags) {
    * interface to the variable "dev", so the caller can know
    * it. Note that the caller MUST reserve space in *dev (see calling
    * code below) */
-  strcpy(dev, ifr.ifr_name);
+  rc = strcpy_s(dev, IF_NAMESIZE, ifr.ifr_name);
+  if (rc != EOK) return -1;
 
   /* this is the special file descriptor that the caller will use to talk
    * with the virtual interface */
diff --git a/hicn-light/src/hicn/strategies/CMakeLists.txt b/hicn-light/src/hicn/strategies/CMakeLists.txt
index 886aa137c..15ae93fea 100644
--- a/hicn-light/src/hicn/strategies/CMakeLists.txt
+++ b/hicn-light/src/hicn/strategies/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -12,20 +12,23 @@
 # limitations under the License.
 
 list(APPEND HEADER_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/strategyImpl.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/loadBalancer.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/lowLatency.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/nexthopState.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/nexthopStateLowLatency.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/rnd.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/load_balancer.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/low_latency.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/random.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/replication.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/best_path.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/local_prefixes.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/probe_generator.h
 )
 
 list(APPEND SOURCE_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/loadBalancer.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/lowLatency.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/nexthopState.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/nexthopStateLowLatency.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/rnd.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/load_balancer.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/low_latency.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/random.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/replication.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/best_path.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/local_prefixes.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/probe_generator.c
 )
 
 set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
diff --git a/hicn-light/src/hicn/strategies/best_path.c b/hicn-light/src/hicn/strategies/best_path.c
new file mode 100644
index 000000000..35a07c43f
--- /dev/null
+++ b/hicn-light/src/hicn/strategies/best_path.c
@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <hicn/hicn-light/config.h>
+
+#include <hicn/core/forwarder.h>
+#include <hicn/core/nexthops.h>
+#include <hicn/core/strategy.h>
+#include <hicn/core/strategy_vft.h>
+
+#include "best_path.h"
+
+#define MAX_NEXTHOP_COST 100
+#define MAX_RTT_ALLOWED 300.0   // ms
+#define MAX_LOSSES_ALLOWED 0.4  // 40%
+
+#define MAX_PROBING_DURATION 5000  // ticks (= ms)
+#define PROBES_WAINTING_TIME 500   // ticks (= ms)
+#define MAX_PROBES 50
+
+/* Shorthand */
+#define nexthop_state_t strategy_bestpath_nexthop_state_t
+#define strategy_state_t strategy_bestpath_state_t
+#define nexthop_state(nexthops, i) (&nexthops->state[i].bestpath)
+
+// nexthop state functions
+
+static const nexthop_state_t NEXTHOP_STATE_INIT = {
+    .sent_probes = 0,
+    .recv_probes = 0,
+    .rtt_sum = 0,
+};
+
+static inline unsigned int get_sent_probes(nexthop_state_t *state) {
+  return state->sent_probes;
+}
+
+static inline unsigned int inc_sent_probes(nexthop_state_t *state) {
+  state->sent_probes++;
+  return state->sent_probes;
+}
+
+static inline void add_rtt_sample(nexthop_state_t *state, Ticks rtt) {
+  state->recv_probes++;
+  state->rtt_sum += rtt;
+}
+
+static inline unsigned int get_nexthop_cost(nexthop_state_t *state) {
+  if (state->recv_probes == 0)
+    return 100;  // we have no info for this nexthop, return max cost
+
+  assert(state->recv_probes <= state->sent_probes);
+
+  double rtt = (double)state->rtt_sum / (double)state->recv_probes;
+  double delay_cost = rtt / MAX_RTT_ALLOWED;
+  if (delay_cost > 1) delay_cost = 1;
+
+  double loss_rate = (double)(state->sent_probes - state->recv_probes) /
+                     (double)state->sent_probes;
+  double loss_cost = loss_rate / MAX_LOSSES_ALLOWED;
+  if (loss_cost > 1) loss_cost = 1;
+
+  double total_cost = delay_cost * 0.5 + loss_cost * 0.5;
+  return round(total_cost * 100);
+}
+
+// options functions
+static void bestpath_update_remote_node(strategy_entry_t *entry,
+                                        nexthops_t *nexthops) {
+  strategy_state_t *state = &entry->state.bestpath;
+  strategy_bestpath_options_t *options = &entry->options.bestpath;
+  off_t offset = nexthops_find(nexthops, state->best_nexthop);
+  nexthops_select(nexthops, offset);
+  update_remote_node_paths(nexthops, entry->forwarder, options->local_prefixes);
+}
+
+// probing functions
+
+static void start_probing(strategy_entry_t *entry) {
+  strategy_state_t *state = &entry->state.bestpath;
+  if (state->probing_state == PROBING_OFF) {
+    state->probing_state = PROBING_ON;
+    state->probing_time = ticks_now();
+  }
+}
+
+static void stop_probing(strategy_entry_t *entry, nexthops_t *nexthops) {
+  strategy_state_t *state = &entry->state.bestpath;
+  nexthop_t best_nexthop, nexthop;
+  best_nexthop = state->best_nexthop;
+  unsigned i;
+  unsigned int min_cost = ~0;
+  unsigned current_nexthop_cost = ~0;
+
+  nexthops_enumerate(nexthops, i, nexthop, {
+    unsigned int cost = get_nexthop_cost(nexthop_state(nexthops, i));
+    if (cost < min_cost) {
+      min_cost = cost;
+      best_nexthop = nexthop;
+    }
+    if (nexthop == state->best_nexthop) current_nexthop_cost = cost;
+
+    nexthops->state[i].bestpath = NEXTHOP_STATE_INIT;
+  });
+
+  if (best_nexthop != state->best_nexthop) {
+    if (current_nexthop_cost > min_cost) {
+      // update best face
+      state->best_nexthop = best_nexthop;
+    }
+  }
+
+  // always update remote node
+  bestpath_update_remote_node(entry, nexthops);
+
+  state->probing_state = PROBING_OFF;
+  delete_all_probes(state->pg);
+}
+
+static void check_stop_probing(strategy_entry_t *entry, nexthops_t *nexthops) {
+  strategy_state_t *state = &entry->state.bestpath;
+  if (state->probing_state == PROBING_OFF) return;
+
+  if (state->probing_state == PROBING_ON) {
+    Ticks probing_duration = ticks_now() - state->probing_time;
+    if (probing_duration >= MAX_PROBING_DURATION) {
+      state->probing_state = PROBING_ENDING;
+      state->probing_time = ticks_now();
+    }
+    return;
+  }
+
+  if (state->probing_state == SENT_MAX_PROBES) {
+    state->probing_state = PROBING_ENDING;
+    state->probing_time = ticks_now();
+    return;
+  }
+
+  if (state->probing_state == PROBING_ENDING) {
+    Ticks ending_duration = ticks_now() - state->probing_time;
+    if (ending_duration >= PROBES_WAINTING_TIME) stop_probing(entry, nexthops);
+  }
+}
+
+static void send_probes(strategy_entry_t *entry, nexthops_t *nexthops,
+                        const msgbuf_t *msgbuf) {
+  strategy_state_t *state = &entry->state.bestpath;
+
+  unsigned i;
+  nexthop_t nexthop;
+  bool sent_max_probes = false;
+  nexthops_enumerate(nexthops, i, nexthop, {
+    if (get_sent_probes(nexthop_state(nexthops, i)) < MAX_PROBES) {
+      int res = generate_probe(state->pg, msgbuf, entry->forwarder, nexthop);
+      if (res >= 0) inc_sent_probes(nexthop_state(nexthops, i));
+    } else {
+      sent_max_probes = true;
+    }
+  });
+
+  if (sent_max_probes) {
+    state->probing_state = SENT_MAX_PROBES;
+    check_stop_probing(entry, nexthops);
+  }
+}
+
+static void init_strategy_state(strategy_state_t *state) {
+  state->best_nexthop = ~0;
+  state->probing_state = PROBING_OFF;
+  state->pg = create_probe_generator();
+}
+
+// strategy functions
+static int strategy_bestpath_initialize(strategy_entry_t *entry,
+                                        const void *forwarder) {
+  if (entry->forwarder == NULL) {
+    srand((unsigned int)time(NULL));
+    entry->forwarder = forwarder;
+    init_strategy_state(&entry->state.bestpath);
+  } else {
+    strategy_state_t *state = &entry->state.bestpath;
+    if (!state->pg) {
+      // the previous strategy was a different one
+      init_strategy_state(state);
+    } else {
+      // all set, start probing
+      start_probing(entry);
+    }
+  }
+  return 0;
+}
+
+static int strategy_bestpath_finalize(strategy_entry_t *entry) {
+  strategy_state_t *state = &entry->state.bestpath;
+  free_local_prefixes(entry->options.bestpath.local_prefixes);
+  destroy_probe_generator(state->pg);
+  return 0;
+}
+
+static int strategy_bestpath_add_nexthop(strategy_entry_t *entry,
+                                         nexthops_t *nexthops, off_t offset) {
+  // reset the strategy state
+  nexthops->state[offset].bestpath = NEXTHOP_STATE_INIT;
+  return 0;
+}
+
+static int strategy_bestpath_remove_nexthop(strategy_entry_t *entry,
+                                            nexthops_t *nexthops,
+                                            off_t offset) {
+  /* Nothing to do */
+  return 0;
+}
+
+static nexthops_t *strategy_bestpath_lookup_nexthops(strategy_entry_t *entry,
+                                                     nexthops_t *nexthops,
+                                                     const msgbuf_t *msgbuf) {
+  size_t nexthops_len = nexthops_get_curlen(nexthops);
+  if (nexthops_len == 0) {
+    // nexthops is empty, return
+    return nexthops;
+  }
+
+  strategy_state_t *state = &entry->state.bestpath;
+  off_t best_nexthop_offset = nexthops_find(nexthops, state->best_nexthop);
+
+  if (nexthops_len == 1) {
+    nexthop_t nh = nexthops_get_one(nexthops);
+    if (state->best_nexthop != nh) {
+      state->best_nexthop = nh;
+      bestpath_update_remote_node(entry, nexthops);
+    }
+    return nexthops;
+  }
+
+  if (state->best_nexthop == ~0 || best_nexthop_offset == INVALID_NEXTHOP) {
+    state->best_nexthop = nexthops_get_one(nexthops);
+    best_nexthop_offset = nexthops_find(nexthops, state->best_nexthop);
+    bestpath_update_remote_node(entry, nexthops);
+    // we have probe only in case the number of face is > 1
+    start_probing(entry);
+    // bestpath_update_remote_node sets the nexthops. in case of probing we want
+    // to send the packets on all faces, so we reset the nexthops here
+    nexthops_reset(nexthops);
+  }
+
+  if (state->probing_state == PROBING_ON) {
+    // send a probe for each interest received
+    send_probes(entry, nexthops, msgbuf);
+
+    uint32_t suffix = name_GetSuffix(msgbuf_get_name(msgbuf));
+    if (suffix >= MIN_PROBE_SUFFIX && suffix <= MAX_PROBE_SUFFIX) {
+      // this packet is a probe from the transport, so register it
+      Ticks time = get_probe_send_time(state->pg, suffix);
+      if (time == 0) {
+        // a probe with the same seq number is not pending, send the packet
+        // the stats for this probe will be collected by the transport
+        register_probe(state->pg, suffix);
+      } else {
+        // this probe is already pending. avoid duplicates and drop it
+        nexthops->flags = ~0;
+        nexthops->cur_elts = 0;
+      }
+    }
+  } else {
+    // we are not probing anymore. if in probing ending state (wait for probes
+    // to come back) keep replicating traffic, otherwise and on best path
+    if (state->probing_state != PROBING_ENDING)
+      nexthops_select(nexthops, best_nexthop_offset);
+  }
+
+  // in case we are still probing send all interest on all paths
+  // so do not select any next hop.
+  // XXX in this transition phase should we replicate also at the
+  // server side?
+  return nexthops;
+}
+
+static int strategy_bestpath_on_data(strategy_entry_t *entry,
+                                     nexthops_t *nexthops,
+                                     const nexthops_t *data_nexthops,
+                                     const msgbuf_t *msgbuf,
+                                     Ticks pitEntryCreation,
+                                     Ticks objReception) {
+  strategy_state_t *state = &entry->state.bestpath;
+  if (state->probing_state == PROBING_OFF) return 0;
+
+  uint32_t seq = name_GetSuffix(msgbuf_get_name(msgbuf));
+  if (seq >= MIN_PROBE_SUFFIX && seq <= MAX_PROBE_SUFFIX) {
+    if (pitEntryCreation != 0) {
+      // this is not a probe sent by the forwader. do not use it in the probing
+      // statisitcs but remove it from the map if it exists
+      delete_probe(state->pg, seq);
+      return 0;
+    }
+
+    unsigned nexthop, i;
+    Ticks send_time = get_probe_send_time(state->pg, seq);
+    if (send_time != 0) {
+      Ticks rtt = ticks_now() - send_time;
+      delete_probe(state->pg, seq);
+      nexthops_enumerate(data_nexthops, i, nexthop, {
+        off_t pos = nexthops_find(nexthops, nexthop);
+        add_rtt_sample(nexthop_state(nexthops, pos), rtt);
+      });
+    }
+  }
+
+  check_stop_probing(entry, nexthops);
+
+  return 0;
+}
+
+static int strategy_bestpath_on_timeout(strategy_entry_t *entry,
+                                        nexthops_t *nexthops,
+                                        const nexthops_t *timeout_nexthops) {
+  /* Nothing to do */
+  return 0;
+}
+
+#undef nexthop_state_t
+#undef strategy_state_t
+
+DECLARE_STRATEGY(bestpath);
+
+#undef nexthop_state_t
+#undef strategy_state_t
diff --git a/hicn-light/src/hicn/strategies/best_path.h b/hicn-light/src/hicn/strategies/best_path.h
new file mode 100644
index 000000000..206214579
--- /dev/null
+++ b/hicn-light/src/hicn/strategies/best_path.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Forward on a single path. Every time the strategy is reset with a command the
+ * forwarder starts to probe the available paths matching the probes on the
+ * original flow. if after the probing phase a better path exists (lower
+ * latency, less losses) the forwarder switch path, otherwise does nothing
+ */
+
+#ifndef HICNLIGHT_STRATEGY_BESTPATH_H
+#define HICNLIGHT_STRATEGY_BESTPATH_H
+
+#include "probe_generator.h"
+#include "local_prefixes.h"
+
+typedef enum {
+  PROBING_OFF,
+  PROBING_ON,
+  SENT_MAX_PROBES,
+  PROBING_ENDING,  // waiting for probes to come back
+  UNKWNOWN,
+} probing_state_t;
+
+typedef struct {
+  // number or probes sent during a probing phase
+  unsigned int sent_probes;
+  // number or probes received during a probing phase
+  unsigned int recv_probes;
+  // sum of all rtt collected
+  Ticks rtt_sum;
+} strategy_bestpath_nexthop_state_t;
+
+typedef struct {
+  unsigned best_nexthop;
+  Ticks probing_time;
+  probing_state_t probing_state;
+  probe_generator_t *pg;
+} strategy_bestpath_state_t;
+
+typedef struct {
+  local_prefixes_t *local_prefixes;
+} strategy_bestpath_options_t;
+
+#endif /* HICNLIGHT_STRATEGY_BESTPATH_H */
diff --git a/hicn-light/src/hicn/strategies/loadBalancer.c b/hicn-light/src/hicn/strategies/loadBalancer.c
deleted file mode 100644
index 82b5a6103..000000000
--- a/hicn-light/src/hicn/strategies/loadBalancer.c
+++ /dev/null
@@ -1,369 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_HashMap.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_Unsigned.h>
-
-#include <hicn/strategies/loadBalancer.h>
-#include <hicn/strategies/nexthopState.h>
-
-static void _strategyLoadBalancer_ReceiveObject(StrategyImpl *strategy,
-                                                const NumberSet *egressId,
-                                                const Message *objectMessage,
-                                                Ticks pitEntryCreation,
-                                                Ticks objReception);
-static void _strategyLoadBalancer_OnTimeout(StrategyImpl *strategy,
-                                            const NumberSet *egressId);
-static NumberSet *_strategyLoadBalancer_LookupNexthop(
-    StrategyImpl *strategy,
-#ifdef WITH_POLICY
-    NumberSet * nexthops,
-#endif /* WITH_POLICY */
-    const Message *interestMessage);
-#ifndef WITH_POLICY
-static NumberSet *_strategyLoadBalancer_ReturnNexthops(StrategyImpl *strategy);
-static unsigned _strategyLoadBalancer_CountNexthops(StrategyImpl *strategy);
-#endif /* ! WITH_POLICY */
-static void _strategyLoadBalancer_AddNexthop(StrategyImpl *strategy,
-                                             unsigned connectionId);
-static void _strategyLoadBalancer_RemoveNexthop(StrategyImpl *strategy,
-                                                unsigned connectionId);
-static void _strategyLoadBalancer_ImplDestroy(StrategyImpl **strategyPtr);
-static strategy_type _strategyLoadBalancer_GetStrategy(StrategyImpl *strategy);
-
-static StrategyImpl _template = {
-    .context = NULL,
-    .receiveObject = &_strategyLoadBalancer_ReceiveObject,
-    .onTimeout = &_strategyLoadBalancer_OnTimeout,
-    .lookupNexthop = &_strategyLoadBalancer_LookupNexthop,
-#ifndef WITH_POLICY
-    .returnNexthops = &_strategyLoadBalancer_ReturnNexthops,
-    .countNexthops = &_strategyLoadBalancer_CountNexthops,
-#endif /* ! WITH_POLICY */
-    .addNexthop = &_strategyLoadBalancer_AddNexthop,
-    .removeNexthop = &_strategyLoadBalancer_RemoveNexthop,
-    .destroy = &_strategyLoadBalancer_ImplDestroy,
-    .getStrategy = &_strategyLoadBalancer_GetStrategy,
-};
-
-struct strategy_load_balancer;
-typedef struct strategy_load_balancer StrategyLoadBalancer;
-
-struct strategy_load_balancer {
-#ifndef WITH_POLICY
-  double weights_sum;
-#endif /* ! WITH_POLICY */
-  // hash map from connectionId to StrategyNexthopState
-  PARCHashMap *strategy_state;
-#ifndef WITH_POLICY
-  NumberSet *nexthops;
-#endif /* ! WITH_POLICY */
-};
-
-StrategyImpl *strategyLoadBalancer_Create() {
-  StrategyLoadBalancer *strategy =
-      parcMemory_AllocateAndClear(sizeof(StrategyLoadBalancer));
-  parcAssertNotNull(strategy, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(StrategyLoadBalancer));
-
-#ifndef WITH_POLICY
-  strategy->weights_sum = 0.0;
-#endif /* ! WITH_POLICY */
-  strategy->strategy_state = parcHashMap_Create();
-#ifndef WITH_POLICY
-  strategy->nexthops = numberSet_Create();
-#endif /* ! WITH_POLICY */
-  srand((unsigned int)time(NULL));
-
-  StrategyImpl *impl = parcMemory_AllocateAndClear(sizeof(StrategyImpl));
-  parcAssertNotNull(impl, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(StrategyImpl));
-  memcpy(impl, &_template, sizeof(StrategyImpl));
-  impl->context = strategy;
-
-  return impl;
-}
-
-// =======================================================
-// Dispatch API
-
-strategy_type _strategyLoadBalancer_GetStrategy(StrategyImpl *strategy) {
-  return SET_STRATEGY_LOADBALANCER;
-}
-
-static void _update_Stats(StrategyLoadBalancer *strategy,
-                          StrategyNexthopState *state, bool inc) {
-  const double ALPHA = 0.9;
-#ifdef WITH_POLICY
-  strategyNexthopState_UpdateState(state, inc, ALPHA);
-#else
-  double w = strategyNexthopState_GetWeight(state);
-  strategy->weights_sum -= w;
-  w = strategyNexthopState_UpdateState(state, inc, ALPHA);
-  strategy->weights_sum += w;
-#endif /* WITH_POLICY */
-}
-
-#ifndef WITH_POLICY
-static unsigned _select_Nexthop(StrategyLoadBalancer *strategy) {
-  double rnd = (double)rand() / (double)RAND_MAX;
-  double start_range = 0.0;
-
-  PARCIterator *it = parcHashMap_CreateKeyIterator(strategy->strategy_state);
-
-  unsigned nexthop = 100000;
-  while (parcIterator_HasNext(it)) {
-    PARCUnsigned *cid = parcIterator_Next(it);
-    const StrategyNexthopState *elem =
-        parcHashMap_Get(strategy->strategy_state, cid);
-
-    double w = strategyNexthopState_GetWeight(elem);
-
-    double prob = w / strategy->weights_sum;
-    if ((rnd >= start_range) && (rnd <= (start_range + prob))) {
-      nexthop = parcUnsigned_GetUnsigned(cid);
-      break;
-    } else {
-      start_range += prob;
-    }
-  }
-
-  parcIterator_Release(&it);
-
-  // if no face is selected by the algorithm (for example because of a wrong
-  // round in the weights) we may always select the last face here. Double check
-  // this!
-  return nexthop;
-}
-#endif /* ! WITH_POLICY */
-
-static void _strategyLoadBalancer_ReceiveObject(StrategyImpl *strategy,
-                                                const NumberSet *egressId,
-                                                const Message *objectMessage,
-                                                Ticks pitEntryCreation,
-                                                Ticks objReception) {
-  _strategyLoadBalancer_OnTimeout(strategy, egressId);
-}
-
-static void _strategyLoadBalancer_OnTimeout(StrategyImpl *strategy,
-                                            const NumberSet *egressId) {
-  StrategyLoadBalancer *lb = (StrategyLoadBalancer *)strategy->context;
-
-  for (unsigned i = 0; i < numberSet_Length(egressId); i++) {
-    unsigned outId = numberSet_GetItem(egressId, i);
-    PARCUnsigned *cid = parcUnsigned_Create(outId);
-
-    const StrategyNexthopState *state =
-        parcHashMap_Get(lb->strategy_state, cid);
-    if (state != NULL) {
-      _update_Stats(lb, (StrategyNexthopState *)state, false);
-    } else {
-      // this may happen if we remove a face/route while downloading a file
-      // we should ignore this timeout
-    }
-    parcUnsigned_Release(&cid);
-  }
-}
-
-static NumberSet *_strategyLoadBalancer_LookupNexthop(
-    StrategyImpl *strategy,
-#ifdef WITH_POLICY
-    NumberSet * nexthops,
-#endif /* WITH_POLICY */
-    const Message *interestMessage) {
-  StrategyLoadBalancer *lb = (StrategyLoadBalancer *)strategy->context;
-  NumberSet *outList = numberSet_Create();
-
-#ifdef WITH_POLICY
-  /* Compute the sum of weights of potential next hops */
-  double sum = 0;
-  for (unsigned i = 0; i < numberSet_Length(nexthops); i++) {
-    PARCUnsigned *cid = parcUnsigned_Create(numberSet_GetItem(nexthops, i));
-    const StrategyNexthopState *elem =
-        parcHashMap_Get(lb->strategy_state, cid);
-    parcUnsigned_Release(&cid);
-    if (!elem)
-      continue;
-    sum += strategyNexthopState_GetWeight(elem);
-  }
-
-  /* Perform weighted random selection */
-  double distance = (double)rand() * sum / ((double)RAND_MAX + 1);
-
-  for (unsigned i = 0; i < numberSet_Length(nexthops); i++) {
-    PARCUnsigned *cid = parcUnsigned_Create(numberSet_GetItem(nexthops, i));
-    const StrategyNexthopState *state =
-        parcHashMap_Get(lb->strategy_state, cid);
-    if (!state) {
-       parcUnsigned_Release(&cid);
-       continue;
-    }
-    distance -= strategyNexthopState_GetWeight(state);
-    if (distance < 0) {
-      numberSet_Add(outList, parcUnsigned_GetUnsigned(cid));
-      _update_Stats(lb, (StrategyNexthopState *)state, true);
-      parcUnsigned_Release(&cid);
-      break;
-    }
-    parcUnsigned_Release(&cid);
-  }
-#else
-  unsigned in_connection = message_GetIngressConnectionId(interestMessage);
-  PARCUnsigned *in = parcUnsigned_Create(in_connection);
-
-  unsigned mapSize = (unsigned)parcHashMap_Size(lb->strategy_state);
-
-  if ((mapSize == 0) ||
-      ((mapSize == 1) && parcHashMap_Contains(lb->strategy_state, in))) {
-    // there are no output faces or the input face is also the only output face.
-    // return null to avoid loops
-    parcUnsigned_Release(&in);
-    return outList;
-  }
-
-  unsigned out_connection;
-  do {
-    out_connection = _select_Nexthop(lb);
-  } while (out_connection == in_connection);
-
-  PARCUnsigned *out = parcUnsigned_Create(out_connection);
-
-  const StrategyNexthopState *state = parcHashMap_Get(lb->strategy_state, out);
-  if (state == NULL) {
-    // this is an error and should not happen!
-    parcTrapNotImplemented(
-        "Try to send an interest on a face that does not exists");
-  }
-
-  _update_Stats(lb, (StrategyNexthopState *)state, true);
-
-  parcUnsigned_Release(&in);
-  parcUnsigned_Release(&out);
-
-  numberSet_Add(outList, out_connection);
-#endif /* WITH_POLICY */
-
-  return outList;
-}
-
-#ifndef WITH_POLICY
-static NumberSet *_strategyLoadBalancer_ReturnNexthops(StrategyImpl *strategy) {
-  StrategyLoadBalancer *lb = (StrategyLoadBalancer *)strategy->context;
-  return lb->nexthops;
-}
-
-unsigned _strategyLoadBalancer_CountNexthops(StrategyImpl *strategy) {
-  StrategyLoadBalancer *lb = (StrategyLoadBalancer *)strategy->context;
-  return (unsigned)numberSet_Length(lb->nexthops);
-}
-#endif /* ! WITH_POLICY */
-
-static void _strategyLoadBalancer_resetState(StrategyImpl *strategy) {
-  StrategyLoadBalancer *lb = (StrategyLoadBalancer *)strategy->context;
-#ifndef WITH_POLICY
-  lb->weights_sum = 0.0;
-#endif/* ! WITH_POLICY */
-  PARCIterator *it = parcHashMap_CreateKeyIterator(lb->strategy_state);
-
-  while (parcIterator_HasNext(it)) {
-    PARCUnsigned *cid = parcIterator_Next(it);
-    StrategyNexthopState *elem =
-        (StrategyNexthopState *)parcHashMap_Get(lb->strategy_state, cid);
-
-    strategyNexthopState_Reset(elem);
-#ifndef WITH_POLICY
-    lb->weights_sum += strategyNexthopState_GetWeight(elem);
-#endif /* ! WITH_POLICY */
-  }
-
-  parcIterator_Release(&it);
-}
-
-static void _strategyLoadBalancer_AddNexthop(StrategyImpl *strategy,
-                                             unsigned connectionId) {
-
-  PARCUnsigned *cid = parcUnsigned_Create(connectionId);
-
-  StrategyLoadBalancer *lb = (StrategyLoadBalancer *)strategy->context;
-
-  if (!parcHashMap_Contains(lb->strategy_state, cid)) {
-    StrategyNexthopState *state = strategyNexthopState_Create();
-    parcHashMap_Put(lb->strategy_state, cid, state);
-#ifndef WITH_POLICY
-    numberSet_Add(lb->nexthops, connectionId);
-#endif /* WITH_POLICY */
-    _strategyLoadBalancer_resetState(strategy);
-  }
-  parcUnsigned_Release(&cid);
-}
-
-static void _strategyLoadBalancer_RemoveNexthop(StrategyImpl *strategy,
-                                                unsigned connectionId) {
-  StrategyLoadBalancer *lb = (StrategyLoadBalancer *)strategy->context;
-
-  PARCUnsigned *cid = parcUnsigned_Create(connectionId);
-
-  if (parcHashMap_Contains(lb->strategy_state, cid)) {
-    StrategyNexthopState *state =
-        (StrategyNexthopState *)parcHashMap_Get(lb->strategy_state, cid);
-    parcObject_Release((void**)&state);
-
-    parcHashMap_Remove(lb->strategy_state, cid);
-#ifndef WITH_POLICY
-    numberSet_Remove(lb->nexthops, connectionId);
-#endif /* WITH_POLICY */
-    _strategyLoadBalancer_resetState(strategy);
-  }
-
-  parcUnsigned_Release(&cid);
-}
-
-static void _strategyLoadBalancer_ImplDestroy(StrategyImpl **strategyPtr) {
-  parcAssertNotNull(strategyPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*strategyPtr,
-                    "Parameter must dereference to non-null pointer");
-
-  StrategyImpl *impl = *strategyPtr;
-  StrategyLoadBalancer *strategy = (StrategyLoadBalancer *)impl->context;
-  if (parcHashMap_Size(strategy->strategy_state) > 0) {
-    PARCIterator *it = parcHashMap_CreateKeyIterator(strategy->strategy_state);
-    while (parcIterator_HasNext(it)) {
-      PARCUnsigned *cid = parcIterator_Next(it);
-      StrategyNexthopState *state =
-              (StrategyNexthopState *) parcHashMap_Get(strategy->strategy_state, cid);
-      parcObject_Release((void **) &state);
-    }
-    parcIterator_Release(&it);
-  }
-
-  parcHashMap_Release(&(strategy->strategy_state));
-#ifndef WITH_POLICY
-  numberSet_Release(&(strategy->nexthops));
-#endif /* ! WITH_POLICY */
-
-  parcMemory_Deallocate((void **) &strategy);
-  parcMemory_Deallocate((void **) &impl);
-  *strategyPtr = NULL;
-}
diff --git a/hicn-light/src/hicn/strategies/load_balancer.c b/hicn-light/src/hicn/strategies/load_balancer.c
new file mode 100644
index 000000000..709efcf23
--- /dev/null
+++ b/hicn-light/src/hicn/strategies/load_balancer.c
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <hicn/hicn-light/config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <hicn/core/strategy.h>
+#include <hicn/core/strategy_vft.h>
+#include <hicn/core/nexthops.h>
+#include <hicn/core/fib_entry.h>
+
+#include "load_balancer.h"
+
+#define AVG_PI_THRESHOLD 1e-3
+#define AVG_PI_MIN 0.1
+
+#define ALPHA 0.9
+
+/* Shorthand */
+#define nexthop_state_t strategy_load_balancer_nexthop_state_t
+#define nexthop_state(nexthops, i) (&nexthops->state[i].load_balancer)
+
+static const nexthop_state_t NEXTHOP_STATE_INIT = {
+    .pi = 0,
+    .avg_pi = 0.0,
+    .weight = 1,
+};
+
+static inline void update_state(nexthop_state_t *state) {
+  state->avg_pi = (state->avg_pi * ALPHA) + (state->pi * 1 - ALPHA);
+  if (state->avg_pi < AVG_PI_THRESHOLD) state->avg_pi = AVG_PI_MIN;
+  state->weight = 1 / state->avg_pi;
+}
+
+static inline void update_state_inc(nexthop_state_t *state) {
+  state->pi++;
+  update_state(state);
+}
+
+static inline void update_state_dec(nexthop_state_t *state) {
+  if (state->pi > 0) state->pi--;
+  update_state(state);
+}
+
+static inline void reset_all(nexthops_t *nexthops) {
+  unsigned i;
+  nexthop_t nexthop;
+  nexthops_enumerate(nexthops, i, nexthop, {
+    (void)nexthop;
+    nexthops->state[i].load_balancer = NEXTHOP_STATE_INIT;
+  });
+}
+
+static int strategy_load_balancer_initialize(strategy_entry_t *entry,
+                                             const void *forwarder) {
+  /* No reset, this will be done when a nexthop is added */
+  entry->forwarder = forwarder;
+  return 0;
+}
+
+static int strategy_load_balancer_finalize(strategy_entry_t *entry) {
+  /* Nothing to do */
+  return 0;
+}
+
+static int strategy_load_balancer_add_nexthop(strategy_entry_t *entry,
+                                              nexthops_t *nexthops,
+                                              off_t offset) {
+  /* We reset the state of all nexthops */
+  reset_all(nexthops);
+  return 0;
+}
+
+static int strategy_load_balancer_remove_nexthop(strategy_entry_t *entry,
+                                                 nexthops_t *nexthops,
+                                                 off_t offset) {
+  reset_all(nexthops);
+  return 0;
+}
+
+static nexthops_t *strategy_load_balancer_lookup_nexthops(
+    strategy_entry_t *entry, nexthops_t *nexthops, const msgbuf_t *msgbuf) {
+  /* Compute the sum of weights of potential next hops */
+  double sum = 0;
+  unsigned i, nexthop;
+  nexthops_enumerate(nexthops, i, nexthop, {
+    (void)nexthop;
+    sum += nexthops_state(nexthops, i).load_balancer.weight;
+  });
+
+  /* Perform weighted random selection */
+  double distance = (double)rand() * sum / ((double)RAND_MAX + 1);
+
+  nexthops_enumerate(nexthops, i, nexthop, {
+    distance -= nexthop_state(nexthops, i)->weight;
+    if (distance < 0) {
+      nexthops_select(nexthops, i);
+      update_state_inc(nexthop_state(nexthops, i));
+      break;
+    }
+  });
+  return nexthops;
+}
+
+static int strategy_load_balancer_on_timeout(
+    strategy_entry_t *entry, nexthops_t *nexthops,
+    const nexthops_t *timeout_nexthops) {
+  /*
+   * As we have few nexthops in FIB entry, and even fewer selected ones in
+   * nexthops, we can allow for linear search that will be very efficient
+   * CPU-wise.
+   */
+  nexthop_t timeout_nexthop;
+  nexthops_foreach(timeout_nexthops, timeout_nexthop, {
+    nexthop_t nexthop;
+    unsigned i;
+    nexthops_enumerate(nexthops, i, nexthop, {
+      if (nexthop == timeout_nexthop)
+        update_state_dec(nexthop_state(nexthops, i));
+    });
+  });
+  return 0;
+}
+
+static int strategy_load_balancer_on_data(strategy_entry_t *entry,
+                                          nexthops_t *nexthops,
+                                          const nexthops_t *data_nexthops,
+                                          const msgbuf_t *msgbuf,
+                                          Ticks pitEntryCreation,
+                                          Ticks objReception) {
+  return strategy_load_balancer_on_timeout(entry, nexthops, data_nexthops);
+}
+
+#undef nexthop_state_t
+
+DECLARE_STRATEGY(load_balancer);
+
+#undef nexthop_state_t
diff --git a/hicn-light/src/hicn/config/controlUpdate.h b/hicn-light/src/hicn/strategies/load_balancer.h
index 0007ab653..f7447d928 100644
--- a/hicn-light/src/hicn/config/controlUpdate.h
+++ b/hicn-light/src/hicn/strategies/load_balancer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,22 +14,24 @@
  */
 
 /**
- * @file control_Update.h
- * @brief Root node for the "update" commands
- *
- * Implements the "update" node of the CLI tree.
- *
+ * Forward on the less loaded path
  */
 
-#ifndef controlUpdate_h
-#define controlUpdate_h
+#ifndef HICNLIGHT_STRATEGY_LOAD_BALANCER_H
+#define HICNLIGHT_STRATEGY_LOAD_BALANCER_H
 
-#ifdef WITH_POLICY
+typedef struct {
+  unsigned int pi;
+  double avg_pi;
+  double weight;
+} strategy_load_balancer_nexthop_state_t;
 
-#include <hicn/config/controlState.h>
-CommandOps *controlUpdate_Create(ControlState *state);
-CommandOps *controlUpdate_HelpCreate(ControlState *state);
+typedef struct {
+  void *_;
+} strategy_load_balancer_state_t;
 
-#endif /* WITH_POLICY */
+typedef struct {
+  void *_;
+} strategy_load_balancer_options_t;
 
-#endif  // controlUpdate_h
+#endif /* HICNLIGHT_STRATEGY_LOAD_BALANCER_H */
diff --git a/hicn-light/src/hicn/strategies/local_prefixes.c b/hicn-light/src/hicn/strategies/local_prefixes.c
new file mode 100644
index 000000000..23d72ae80
--- /dev/null
+++ b/hicn-light/src/hicn/strategies/local_prefixes.c
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "local_prefixes.h"
+#include <hicn/core/forwarder.h>
+#include <hicn/core/nexthops.h>
+#include <hicn/core/name.h>
+#include <hicn/core/mapme.h>
+
+#define MAX_PREFIXES 10
+
+struct local_prefixes_s {
+  Name local_prefixes[MAX_PREFIXES];
+  unsigned len;
+};
+
+local_prefixes_t *create_local_prefixes() {
+  local_prefixes_t *lp = calloc(1, sizeof(local_prefixes_t));
+  if (!lp) return NULL;
+  return lp;
+}
+
+void free_local_prefixes(local_prefixes_t *lp) { free(lp); }
+
+unsigned local_prefixes_get_len(local_prefixes_t *prefixes) {
+  return prefixes->len;
+}
+
+bool contain_prefix(local_prefixes_t *prefixes, Name *name) {
+  for (unsigned i = 0; i < prefixes->len; i++) {
+    if (name_Equals(&(prefixes->local_prefixes[i]), name)) return true;
+  }
+  return false;
+}
+
+void local_prefixes_add_prefixes(local_prefixes_t *prefixes,
+                                 local_prefixes_t *new_prefixes) {
+  // if there is not enough space for the new prefixes they are not added
+  unsigned i = 0;
+  while ((i < new_prefixes->len) && (prefixes->len < MAX_PREFIXES)) {
+    if (!contain_prefix(prefixes, &(new_prefixes->local_prefixes[i]))) {
+      name_Copy(&new_prefixes->local_prefixes[i],
+                &prefixes->local_prefixes[prefixes->len]);
+      prefixes->len++;
+    }
+    i++;
+  }
+}
+
+void local_prefixes_add_prefix(local_prefixes_t *prefixes, const void *prefix) {
+  if (prefixes->len >= MAX_PREFIXES) return;
+  Name *n = (Name *)prefix;
+  if (!contain_prefix(prefixes, n)) {
+    name_Copy(n, &(prefixes->local_prefixes[prefixes->len]));
+    prefixes->len++;
+  }
+}
+
+void update_remote_node_paths(const void *nexthops, const void *forwarder,
+                              local_prefixes_t *prefixes) {
+  if (!prefixes) return;
+  struct mapme_s *mapme = forwarder_get_mapme((forwarder_t *)forwarder);
+  fib_t *fib = forwarder_get_fib((forwarder_t *)forwarder);
+  for (unsigned i = 0; i < prefixes->len; i++) {
+    fib_entry_t *entry = fib_match_name(fib, &prefixes->local_prefixes[i]);
+    if (!entry) continue;
+    mapme_set_adjacencies(mapme, entry, (nexthops_t *)nexthops, false);
+  }
+}
diff --git a/hicn-light/src/hicn/strategies/local_prefixes.h b/hicn-light/src/hicn/strategies/local_prefixes.h
new file mode 100644
index 000000000..833a48057
--- /dev/null
+++ b/hicn-light/src/hicn/strategies/local_prefixes.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * struct used to store prefixes that are served locally.
+ * these prefixes are used in mapme messages to tell to the server which
+ * path to use to retrive the content produced locally.
+ * using this strategy the path selection done by the client can be
+ * replicated at the server
+ */
+
+#ifndef HICNLIGHT_LOCAL_PREFIXES_H
+#define HICNLIGHT_LOCAL_PREFIXES_H
+
+typedef struct local_prefixes_s local_prefixes_t;
+
+local_prefixes_t* create_local_prefixes();
+
+void free_local_prefixes(local_prefixes_t* lp);
+
+unsigned local_prefixes_get_len(local_prefixes_t* prefixes);
+
+void local_prefixes_add_prefixes(local_prefixes_t* prefixes,
+                                 local_prefixes_t* new_prefixes);
+
+void local_prefixes_add_prefix(local_prefixes_t* prefixes, const void* prefix);
+
+void update_remote_node_paths(const void* nexthops, const void* forwarder,
+                              local_prefixes_t* prefixes);
+
+#endif /* HICNLIGHT_LOCAL_PREFIXES */
diff --git a/hicn-light/src/hicn/strategies/lowLatency.c b/hicn-light/src/hicn/strategies/lowLatency.c
deleted file mode 100644
index 61bffe243..000000000
--- a/hicn-light/src/hicn/strategies/lowLatency.c
+++ /dev/null
@@ -1,851 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <math.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_HashMap.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Object.h>
-#include <parc/algol/parc_Unsigned.h>
-
-#include <hicn/core/messageHandler.h>
-
-#include <hicn/strategies/lowLatency.h>
-#include <hicn/strategies/nexthopStateLowLatency.h>
-
-const unsigned STABILITY_FACTOR = 15;
-const unsigned MAX_SWITCH_TRY = 10;
-const unsigned MAX_LATENCY_DIFF = 10;
-const unsigned MAX_TOLLERATED_LATENCY_DIFF = 15;
-const unsigned MAX_ROUNDS_MP_WITHOUT_CHECK = 2;
-const unsigned MAX_ROUNDS_AVOIDING_MULTIPATH = 40; //about 20 sec
-const unsigned MAX_ROUNDS_WITH_ERROR = 4;
-const unsigned PROBE_LIFETIME = 500; //ms
-
-static void _strategyLowLatency_ReceiveObject(StrategyImpl *strategy,
-                                                const NumberSet *egressId,
-                                                const Message *objectMessage,
-                                                Ticks pitEntryCreation,
-                                                Ticks objReception);
-static void _strategyLowLatency_OnTimeout(StrategyImpl *strategy,
-                                            const NumberSet *egressId);
-static NumberSet *_strategyLowLatency_LookupNexthop(
-    StrategyImpl *strategy,
-#ifdef WITH_POLICY
-    NumberSet * nexthops,
-#endif /* WITH_POLICY */
-    const Message *interestMessage);
-#ifndef WITH_POLICY
-static NumberSet *_strategyLowLatency_ReturnNexthops(StrategyImpl *strategy);
-static unsigned _strategyLowLatency_CountNexthops(StrategyImpl *strategy);
-#endif /* ! WITH_POLICY */
-static void _strategyLowLatency_AddNexthop(StrategyImpl *strategy,
-                                             unsigned connectionId);
-static void _strategyLowLatency_RemoveNexthop(StrategyImpl *strategy,
-                                                unsigned connectionId);
-static void _strategyLowLatency_ImplDestroy(StrategyImpl **strategyPtr);
-static strategy_type _strategyLowLatency_GetStrategy(StrategyImpl *strategy);
-
-static StrategyImpl _template = {
-    .context = NULL,
-    .receiveObject = &_strategyLowLatency_ReceiveObject,
-    .onTimeout = &_strategyLowLatency_OnTimeout,
-    .lookupNexthop = &_strategyLowLatency_LookupNexthop,
-#ifndef WITH_POLICY
-    .returnNexthops = &_strategyLowLatency_ReturnNexthops,
-    .countNexthops = &_strategyLowLatency_CountNexthops,
-#endif /* ! WITH_POLICY */
-    .addNexthop = &_strategyLowLatency_AddNexthop,
-    .removeNexthop = &_strategyLowLatency_RemoveNexthop,
-    .destroy = &_strategyLowLatency_ImplDestroy,
-    .getStrategy = &_strategyLowLatency_GetStrategy,
-};
-
-struct strategy_low_latency;
-typedef struct strategy_low_latency StrategyLowLatency;
-
-struct strategy_low_latency {
-  // hash map from connectionId to StrategyNexthopStateLL
-  PARCHashMap *strategy_state;
-  //hash map from sequence number to ticks (sent time)
-  PARCHashMap *pending_probes_ticks;
-  //hash map from sequence number to face id
-  PARCHashMap *pending_probes_faces;
-  const Forwarder * forwarder;
-  PARCEventTimer *sendProbes;
-  PARCEventTimer *computeBestFace;
-  uint8_t * probe;
-  hicn_name_t * name;
-  StrategyNexthopStateLL * bestFaces[2];
-  unsigned round;
-  unsigned rounds_in_multipath;
-  unsigned rounds_with_error;
-  unsigned rounds_avoiding_multipath;
-  bool use2paths;
-  bool avoid_multipath;
-  unsigned related_prefixes_len;
-  Name **related_prefixes;
-#ifndef WITH_POLICY
-  NumberSet *nexthops;
-#endif /* ! WITH_POLICY */
-};
-
-static void strategyLowLatency_SendProbesCB(int fd, PARCEventType which_event,
-                                            void *data){
-  parcAssertTrue(which_event & PARCEventType_Timeout,
-                 "Event incorrect, expecting %X set, got %X",
-                 PARCEventType_Timeout, which_event);
-
-  StrategyLowLatency *ll = (StrategyLowLatency *) data;
-
-  //delete old pending probes
-  if(parcHashMap_Size(ll->pending_probes_ticks) != 0){
-    Ticks now = forwarder_GetTicks(ll->forwarder);
-    PARCIterator *iterator = parcHashMap_CreateKeyIterator(ll->pending_probes_ticks);
-    NumberSet *to_remove = numberSet_Create();
-    while(parcIterator_HasNext(iterator)) {
-      PARCUnsigned *parc_seq = (PARCUnsigned *) parcIterator_Next(iterator);
-      PARCUnsigned *parc_time = (PARCUnsigned *) parcHashMap_Get(ll->pending_probes_ticks, parc_seq);
-      Ticks sent_time = parcUnsigned_GetUnsigned(parc_time);
-      if((now - sent_time) > PROBE_LIFETIME){
-        //probes to delete
-        numberSet_Add(to_remove, parcUnsigned_GetUnsigned(parc_seq));
-      }
-    }
-    parcIterator_Release(&iterator);
-
-    for(int i = 0; i < numberSet_Length(to_remove); i++){
-      PARCUnsigned *prob_seq = parcUnsigned_Create(numberSet_GetItem(to_remove,i));
-      PARCUnsigned *cid = (PARCUnsigned *) parcHashMap_Get(ll->pending_probes_faces, prob_seq);
-      StrategyNexthopStateLL *state =
-        (StrategyNexthopStateLL *) parcHashMap_Get(ll->strategy_state, cid);
-      strategyNexthopStateLL_LostProbe(state);
-      parcHashMap_Remove(ll->pending_probes_ticks, prob_seq);
-      parcHashMap_Remove(ll->pending_probes_faces, prob_seq);
-      parcUnsigned_Release(&prob_seq);
-    }
-    numberSet_Release(&to_remove);
-  }
-
-  ConnectionTable * ct = forwarder_GetConnectionTable(ll->forwarder);
-
-  PARCIterator *iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
-  while(parcIterator_HasNext(iterator)){
-    PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
-    Connection *conn =
-        (Connection *)connectionTable_FindById(ct,
-                        parcUnsigned_GetUnsigned(cid));
-    if(!conn)
-        continue;
-
-    StrategyNexthopStateLL *state =
-        (StrategyNexthopStateLL *) parcHashMap_Get(ll->strategy_state, cid);
-
-    //probe only usable paths
-    if(!strategyNexthopStateLL_IsAllowed(state))
-      continue;
-
-    uint32_t seq = rand();
-    messageHandler_SetProbeName(ll->probe, HF_INET6_TCP,
-                                ll->name, seq);
-    connection_Probe(conn, ll->probe);
-
-    PARCUnsigned *parc_seq = parcUnsigned_Create(seq);
-    Ticks now = forwarder_GetTicks(ll->forwarder);
-    PARCUnsigned *parc_time = parcUnsigned_Create((unsigned int)now);
-    parcHashMap_Put(ll->pending_probes_ticks, parc_seq, parc_time);
-    parcHashMap_Put(ll->pending_probes_faces, parc_seq, cid);
-    strategyNexthopStateLL_SentProbe(state);
-    parcUnsigned_Release(&parc_seq);
-    parcUnsigned_Release(&parc_time);
-  }
-  parcIterator_Release(&iterator);
-
-  struct timeval timeout = {0,50000};
-  parcEventTimer_Start(ll->sendProbes, &timeout);
-}
-
-static void strategyLowLatency_SendMapmeUpdate(StrategyLowLatency *ll,
-                                               const NumberSet * nexthops){
-  MapMe * mapme = forwarder_getMapmeInstance(ll->forwarder);
-  FIB * fib = forwarder_getFib((Forwarder*) ll->forwarder);
-  if(fib != NULL){
-    for(unsigned i = 0; i < ll->related_prefixes_len; i++){
-      FibEntry *fibEntry = fib_MatchName(fib, ll->related_prefixes[i]);
-      if(fibEntry != NULL){
-        mapme_maybe_send_updates(mapme, fibEntry, nexthops);
-      }
-    }
-  }
-}
-
-static void strategyLowLatency_SelectBestFaces(StrategyLowLatency *ll,
-                                                        bool new_round){
-
-  StrategyNexthopStateLL * old_faces[2];
-  old_faces[0] = ll->bestFaces[0];
-  old_faces[1] = ll->bestFaces[1];
-
-  if(new_round){
-    ll->round++;
-  }
-
-  if(parcHashMap_Size(ll->strategy_state) == 0){
-    ll->bestFaces[0] = NULL;
-    ll->bestFaces[1] = NULL;
-    ll->use2paths = false;
-    goto NEW_ROUND;
-  }
-
-  if(ll->use2paths && ll->bestFaces[0] != NULL && ll->bestFaces[1] != NULL){
-    //multipath  case
-
-    if(!strategyNexthopStateLL_IsLossy(ll->bestFaces[0])
-      && !strategyNexthopStateLL_IsLossy(ll->bestFaces[1])
-      && strategyNexthopStateLL_IsAllowed(ll->bestFaces[0])
-      && strategyNexthopStateLL_IsAllowed(ll->bestFaces[1])){
-
-      if(ll->rounds_in_multipath < MAX_ROUNDS_MP_WITHOUT_CHECK){
-        //we are at the first rounds of the multipath let's wait a bit
-        //(MAX_ROUNDS_MP_WITHOUT_CHECK) to make the queuing converge
-        ll->rounds_in_multipath++;
-        goto NEW_ROUND;
-      }
-
-      //we need to decide if we want ot keep using two paths or not
-      ll->rounds_in_multipath++;
-      double rtt0 = strategyNexthopStateLL_GetRTTLive(ll->bestFaces[0]);
-      double rtt1 = strategyNexthopStateLL_GetRTTLive(ll->bestFaces[1]);
-      double diff = fabs(rtt0 - rtt1);
-
-      if(diff < MAX_LATENCY_DIFF){
-        //everything is working, keep using the two paths
-        ll->rounds_with_error = 0;
-        goto NEW_ROUND;
-      }
-
-      //check for how many rounds we had problems
-      if(ll->rounds_with_error < MAX_ROUNDS_WITH_ERROR &&
-                            diff < MAX_TOLLERATED_LATENCY_DIFF){
-        //we can tollerate few round with errors
-        ll->rounds_with_error++;
-        goto NEW_ROUND;
-      }
-
-      //prevent the usage of multiple paths
-      ll->rounds_with_error = 0;
-      ll->avoid_multipath = true;
-      ll->rounds_avoiding_multipath = 0;
-    } //else
-      //at least one of the two path is lossy
-      //or it is not allowed by the policies.
-      //search for a better possibility
-  }
-
-  ll->bestFaces[0] = NULL;
-  ll->bestFaces[1] = NULL;
-
-  //check if there is at least one non lossy connection
-  PARCIterator *iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
-  bool check_losses = true;
-  bool found_good_face = false;
-  while(parcIterator_HasNext(iterator) && !found_good_face){
-    PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
-    const StrategyNexthopStateLL *state = parcHashMap_Get(ll->strategy_state, cid);
-    if(!strategyNexthopStateLL_IsLossy(state) &&
-      strategyNexthopStateLL_IsAllowed(state)){
-      found_good_face = true;
-    }
-  }
-  parcIterator_Release(&iterator);
-  if(!found_good_face){
-    // all the available faces are lossy, so we take into account only
-    // the latency computed with the probes
-    check_losses = false;
-  }
-
-  if(ll->bestFaces[0] == NULL){
-    //try to take a random face
-    PARCIterator *iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
-    bool face_found = false;
-    while(parcIterator_HasNext(iterator) && !face_found) {
-      PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
-      StrategyNexthopStateLL *state = (StrategyNexthopStateLL *)
-          parcHashMap_Get(ll->strategy_state, cid);
-
-      if((check_losses && strategyNexthopStateLL_IsLossy(state)) ||
-            !strategyNexthopStateLL_IsAllowed(state)){
-        //skip the face
-        continue;
-      }
-
-      ll->bestFaces[0] = state;
-      face_found = true;
-    }
-    parcIterator_Release(&iterator);
-  }
-
-  if(ll->bestFaces[0] == NULL){
-    //no usable face exists
-    ll->bestFaces[0] = NULL;
-    ll->bestFaces[1] = NULL;
-    ll->use2paths = false;
-    goto NEW_ROUND;
-  }
-
-  double bestRtt = strategyNexthopStateLL_GetRTTLive(ll->bestFaces[0]);
-
-  if(ll->avoid_multipath)
-    ll->rounds_avoiding_multipath++;
-
-  if(ll->rounds_avoiding_multipath > MAX_ROUNDS_AVOIDING_MULTIPATH){
-    ll->avoid_multipath = false;
-    ll->rounds_avoiding_multipath = 0;
-  }
-
-  iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
-  while (parcIterator_HasNext(iterator)) {
-
-    PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
-    StrategyNexthopStateLL *state = (StrategyNexthopStateLL *)
-                              parcHashMap_Get(ll->strategy_state, cid);
-    double rtt = strategyNexthopStateLL_GetRTTLive(state);
-
-    if((check_losses && strategyNexthopStateLL_IsLossy(state)) ||
-        !strategyNexthopStateLL_IsAllowed(state)){
-      //skip the face
-      continue;
-    }
-
-    if(rtt + STABILITY_FACTOR < bestRtt){
-      //maybe we found a better face
-      double rttInUse = strategyNexthopStateLL_GetRTTInUse(state);
-      unsigned try = strategyNexthopStateLL_GetTryToSwitch(state);
-
-      //we check the rtt in use to check if the new face that we found
-      //gets congested when we use it to send the traffic
-      if(rttInUse < bestRtt || try > MAX_SWITCH_TRY){
-        //we have a new best face!
-        strategyNexthopStateLL_ResetTryToSwitch((StrategyNexthopStateLL*) state);
-        bestRtt = rtt;
-        if(ll->bestFaces[0] != NULL)
-           strategyNexthopStateLL_SetUnusedFace(ll->bestFaces[0]);
-        ll->bestFaces[0] = (StrategyNexthopStateLL*) state;
-      }else{
-        //in this case we should switch but we wait MAX_SWITCH_TRY
-        //before switch to avoid ossillations between different paths
-        strategyNexthopStateLL_IncreaseTryToSwitch(
-                  (StrategyNexthopStateLL*) state, ll->round);
-      }
-    }
-  }
-
-  parcIterator_Release(&iterator);
-
-  if(ll->bestFaces[0] == NULL){
-    //we found no face so return
-    ll->bestFaces[0] = NULL;
-    ll->bestFaces[1] = NULL;
-    ll->use2paths = false;
-    goto NEW_ROUND;
-  }
-
-  if(parcHashMap_Size(ll->strategy_state) == 1 || ll->avoid_multipath){
-    //in this case (one face available or avoid multipath) we stop the
-    //search here. Just reset face 1 if needed
-    if(ll->bestFaces[1] != NULL){
-      strategyNexthopStateLL_SetUnusedFace(ll->bestFaces[1]);
-      ll->bestFaces[1] = NULL;
-    }
-    ll->use2paths = false;
-    goto NEW_ROUND;
-  }
-
-  //if we are here we have more than 1 interface, so we search for a second one
-  //to use in case of multipath
-  iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
-  while (parcIterator_HasNext(iterator)) {
-    PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
-    if(parcUnsigned_GetUnsigned(cid) !=
-          strategyNexthopStateLL_GetFaceId(ll->bestFaces[0])){
-
-      StrategyNexthopStateLL *state = (StrategyNexthopStateLL *)
-                 parcHashMap_Get(ll->strategy_state, cid);
-
-      if((check_losses && strategyNexthopStateLL_IsLossy(state)) ||
-        !strategyNexthopStateLL_IsAllowed(state)){
-        //skip the face
-        continue;
-      }
-
-      if(ll->bestFaces[1] == NULL){
-        //in case of 2 faces we should pass always here
-        ll->bestFaces[1] = state;
-      }else{
-        //TODO this must be tested with more then 2 faces
-        double rtt1 = strategyNexthopStateLL_GetRTTLive(ll->bestFaces[1]);
-        double rttNewFace = strategyNexthopStateLL_GetRTTLive(state);
-        if(rttNewFace + STABILITY_FACTOR < rtt1){
-          strategyNexthopStateLL_SetUnusedFace(ll->bestFaces[1]);
-          ll->bestFaces[1] = state;
-        }
-      }
-    }
-  }
-  parcIterator_Release(&iterator);
-
-  if(ll->bestFaces[1] != NULL){
-    //we are not using the second face yet so we use the normal rtt for comparison
-    double rtt0 = strategyNexthopStateLL_GetRTTProbe(ll->bestFaces[0]);
-    double rtt1 = strategyNexthopStateLL_GetRTTProbe(ll->bestFaces[1]);
-    double diff = fabs(rtt0 - rtt1);
-    if(diff < MAX_LATENCY_DIFF) {
-      //let's start to use 2 paths
-      ll->rounds_with_error = 0;
-      ll->use2paths = true;
-      ll->rounds_in_multipath = 0;
-    }else{
-      //we use only one path
-      strategyNexthopStateLL_SetUnusedFace(ll->bestFaces[1]);
-      ll->bestFaces[1] = NULL;
-      ll->use2paths = false;
-    }
-  }else{
-    ll->use2paths = false;
-  }
-
-  NEW_ROUND:
-    {
-      Logger * log = forwarder_GetLogger(ll->forwarder);
-      if(log != NULL &&
-        logger_IsLoggable(log, LoggerFacility_Strategy, PARCLogLevel_Info)){
-      if(ll->use2paths){
-          logger_Log(log, LoggerFacility_Strategy, PARCLogLevel_Info,
-            __func__, "use 2 paths. rtt face %d = %f queue = %f is_lossy = %d,"
-            "rtt face %d = %f queue = %f is_lossy = %d\n",
-            strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]),
-            strategyNexthopStateLL_GetRTTLive(ll->bestFaces[0]),
-            strategyNexthopStateLL_GetQueuing(ll->bestFaces[0]),
-            strategyNexthopStateLL_IsLossy(ll->bestFaces[0]),
-            strategyNexthopStateLL_GetFaceId(ll->bestFaces[1]),
-            strategyNexthopStateLL_GetRTTLive(ll->bestFaces[1]),
-            strategyNexthopStateLL_GetQueuing(ll->bestFaces[1]),
-            strategyNexthopStateLL_IsLossy(ll->bestFaces[1]));
-        }else{
-          if(ll->bestFaces[0] != NULL){
-            logger_Log(log, LoggerFacility_Strategy,
-              PARCLogLevel_Info, __func__,
-              "use 1 path. rtt face %d = %f is_lossy = %d, "
-              "(avoid multipath = %d)\n",
-              strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]),
-              strategyNexthopStateLL_GetRTTLive(ll->bestFaces[0]),
-              strategyNexthopStateLL_IsLossy(ll->bestFaces[0]),
-              ll->avoid_multipath);
-          }else{
-            logger_Log(log, LoggerFacility_Strategy, PARCLogLevel_Info,
-                     __func__, "no face to use!\n");
-          }
-        }
-      }
-    }
-
-  //update the round only at the end for all the faces
-  if(new_round){
-    PARCIterator * iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
-    while (parcIterator_HasNext(iterator)) {
-      PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
-      strategyNexthopStateLL_StartNewRound((StrategyNexthopStateLL *)
-          parcHashMap_Get(ll->strategy_state, cid));
-    }
-    parcIterator_Release(&iterator);
-  }
-
-  //mapme updates
-  //if ll->bestFaces[0] == NULL we don't have any output faces
-  //so don't need to send any updates since we are disconnected
-  if(ll->related_prefixes_len != 0){
-    if(ll->bestFaces[0] != NULL){
-      NumberSet *out = numberSet_Create();
-      if(old_faces[0] == NULL ||
-         (strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]) !=
-         strategyNexthopStateLL_GetFaceId(old_faces[0]))){
-          //there is a new face 0 so we need a map me update
-          //if ll->bestFaces[1] != NULL we need to send the update
-          //even if it is the same as before
-        numberSet_Add(out,
-          strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]));
-        if(ll->bestFaces[1] != NULL){
-          numberSet_Add(out,
-            strategyNexthopStateLL_GetFaceId(ll->bestFaces[1]));
-        }
-        strategyLowLatency_SendMapmeUpdate(ll,out);
-      }else{
-        if(ll->bestFaces[1] != NULL){
-          if(old_faces[1] == NULL ||
-              (strategyNexthopStateLL_GetFaceId(ll->bestFaces[1]) !=
-              strategyNexthopStateLL_GetFaceId(old_faces[1]))){
-            //send a mapme both with face 0 and face 1
-            numberSet_Add(out,
-              strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]));
-            numberSet_Add(out,
-              strategyNexthopStateLL_GetFaceId(ll->bestFaces[1]));
-            strategyLowLatency_SendMapmeUpdate(ll,out);
-          }
-        }else{
-          if(old_faces[1] != NULL){
-            //in the previuos round we were using two faces, now only one
-            //send update with only face 0
-            numberSet_Add(out,
-              strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]));
-            strategyLowLatency_SendMapmeUpdate(ll,out);
-          }
-        }
-      }
-      numberSet_Release(&out);
-    }
-  }
-}
-
-static void strategyLowLatency_BestFaceCB(int fd, PARCEventType which_event,
-                                            void *data){
-  parcAssertTrue(which_event & PARCEventType_Timeout,
-                 "Event incorrect, expecting %X set, got %X",
-                 PARCEventType_Timeout, which_event);
-
-  StrategyLowLatency * ll = (StrategyLowLatency *) data;
-  strategyLowLatency_SelectBestFaces(ll, true);
-
-  struct timeval timeout = {0, 500000};
-  parcEventTimer_Start(ll->computeBestFace, &timeout);
-}
-
-StrategyImpl *strategyLowLatency_Create() {
-  StrategyLowLatency *strategy =
-      parcMemory_AllocateAndClear(sizeof(StrategyLowLatency));
-  parcAssertNotNull(strategy, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(StrategyLowLatency));
-
-  strategy->strategy_state = parcHashMap_Create();
-  strategy->pending_probes_ticks = parcHashMap_Create();
-  strategy->pending_probes_faces = parcHashMap_Create();
-#ifndef WITH_POLICY
-  strategy->nexthops = numberSet_Create();
-#endif /* ! WITH_POLICY */
-  srand((unsigned int)time(NULL));
-
-  StrategyImpl *impl = parcMemory_AllocateAndClear(sizeof(StrategyImpl));
-  parcAssertNotNull(impl, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(StrategyImpl));
-  memcpy(impl, &_template, sizeof(StrategyImpl));
-  impl->context = strategy;
-
-  return impl;
-}
-
-void strategyLowLatency_SetStrategy(StrategyImpl *strategy,
-                                    const Forwarder * forwarder,
-                                    const FibEntry * fibEntry,
-                                    unsigned related_prefixes_len,
-                                    Name **related_prefixes) {
-  StrategyLowLatency *ll =
-      (StrategyLowLatency *)strategy->context;
-  ll->forwarder = forwarder;
-
-  //create probe packet
-  ll->probe = messageHandler_CreateProbePacket(HF_INET6_TCP, PROBE_LIFETIME);
-  ip_prefix_t address;
-  nameBitvector_ToIPAddress(name_GetContentName(
-                                  fibEntry_GetPrefix(fibEntry)), &address);
-  ll->name = messageHandler_CreateProbeName(&address);
-
-
-  Dispatcher *dispatcher = forwarder_GetDispatcher((Forwarder *)ll->forwarder);
-  ll->sendProbes = dispatcher_CreateTimer(dispatcher, false,
-                                     strategyLowLatency_SendProbesCB, ll);
-
-  ll->round = 0;
-  ll->rounds_in_multipath = 0;
-  ll->rounds_with_error = 0;
-  ll->rounds_avoiding_multipath = 0;
-  ll->use2paths = false;
-  ll->avoid_multipath = false;
-
-  ll->related_prefixes_len = related_prefixes_len;
-  ll->related_prefixes = malloc(sizeof(Name *) * ll->related_prefixes_len);
-  for(unsigned i = 0; i < ll->related_prefixes_len; i++){
-    ll->related_prefixes[i] = name_Copy(related_prefixes[i]);
-  }
-
-  ll->computeBestFace = dispatcher_CreateTimer(dispatcher, false,
-                                     strategyLowLatency_BestFaceCB, ll);
-}
-
-void _startTimers(StrategyImpl *strategy){
-  StrategyLowLatency *ll =
-      (StrategyLowLatency *)strategy->context;
-
-  struct timeval timeoutProbes = {0,10000};
-  parcEventTimer_Start(ll->sendProbes, &timeoutProbes);
-   struct timeval timeoutBF = {1,0};
-   parcEventTimer_Start(ll->computeBestFace, &timeoutBF);
-}
-
-void _stopTimers(StrategyImpl *strategy){
-  StrategyLowLatency *ll =
-      (StrategyLowLatency *)strategy->context;
-
-  parcEventTimer_Stop(ll->sendProbes);
-  parcEventTimer_Stop(ll->computeBestFace);
-}
-
-// =======================================================
-// Dispatch API
-
-strategy_type _strategyLowLatency_GetStrategy(StrategyImpl *strategy) {
-  return SET_STRATEGY_LOW_LATENCY;
-}
-
-static void _strategyLowLatency_ReceiveObject(StrategyImpl *strategy,
-                                                const NumberSet *egressId,
-                                                const Message *objectMessage,
-                                                Ticks pitEntryCreation,
-                                                Ticks objReception) {
-  StrategyLowLatency *ll = (StrategyLowLatency *)strategy->context;
-
-  if(!messageHandler_IsAProbe(message_FixedHeader(objectMessage)))
-    return;
-
-  uint32_t seq = messageHandler_GetSegment(message_FixedHeader(objectMessage));
-  PARCUnsigned *parc_seq = parcUnsigned_Create(seq);
-  if (!parcHashMap_Contains(ll->pending_probes_ticks, parc_seq)){
-    parcUnsigned_Release(&parc_seq);
-    return;
-  }
-
-  //here numberSet_Length(egressId) should be 1
-  for (unsigned i = 0; i < numberSet_Length(egressId); i++) {
-    unsigned outId = numberSet_GetItem(egressId, i);
-    PARCUnsigned *cid = parcUnsigned_Create(outId);
-
-    const StrategyNexthopStateLL *state =
-        parcHashMap_Get(ll->strategy_state, cid);
-    if (state != NULL) {
-      Ticks time = parcUnsigned_GetUnsigned(
-            parcHashMap_Get(ll->pending_probes_ticks, parc_seq));
-      Ticks now = forwarder_GetTicks(ll->forwarder);
-      Ticks RTT =  now - time;
-      if(RTT <= 0)
-        RTT = 1;
-      strategyNexthopStateLL_AddRttSample(
-                          (StrategyNexthopStateLL *) state, (unsigned int)RTT);
-      parcHashMap_Remove(ll->pending_probes_ticks, parc_seq);
-    } else {
-      // this may happen if we remove a face/route while downloading a file
-      // we should ignore this timeout
-    }
-    parcUnsigned_Release(&cid);
-  }
-  parcUnsigned_Release(&parc_seq);
-}
-
-static void _strategyLowLatency_OnTimeout(StrategyImpl *strategy,
-                                            const NumberSet *egressId) {}
-
-static NumberSet *_strategyLowLatency_LookupNexthop(StrategyImpl *strategy,
-#ifdef WITH_POLICY
-        NumberSet * nexthops,
-#endif /* WITH_POLICY */
-        const Message *interestMessage) {
-  //unsigned out_connection;
-  NumberSet *out = numberSet_Create();
-
-  StrategyLowLatency *ll = (StrategyLowLatency *)strategy->context;
-
-  //update is_allowed flag of all the next hops
-  PARCIterator *iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
-  while(parcIterator_HasNext(iterator)){
-    PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
-    StrategyNexthopStateLL *state =
-        (StrategyNexthopStateLL *) parcHashMap_Get(ll->strategy_state, cid);
-    if(numberSet_Contains(nexthops, parcUnsigned_GetUnsigned(cid))){
-      strategyNexthopStateLL_SetIsAllowed(state,true);
-    }else{
-      strategyNexthopStateLL_SetIsAllowed(state,false);
-    }
-  }
-  parcIterator_Release(&iterator);
-
-  if(ll->bestFaces[0] != NULL &&
-      !strategyNexthopStateLL_IsAllowed(ll->bestFaces[0])){
-    //if ll->bestFaces[0] is not allowed we need to find a new face
-    strategyLowLatency_SelectBestFaces(ll, false);
-  }
-
-  //at this point ll->bestFaces[0] must be allowed
-  //single path case
-  if(ll->bestFaces[0] != NULL && (ll->bestFaces[1] == NULL || !ll->use2paths)){
-    strategyNexthopStateLL_SendPacket(ll->bestFaces[0]);
-    numberSet_Add(out, strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]));
-
-  //multipath case
-  }else if(ll->bestFaces[0] != NULL && ll->bestFaces[1] != NULL && ll->use2paths){
-    //it may happen that ll->bestFaces[1] is not allowed, in that case we send on
-    //ll->bestFaces[0] until the next best face selection
-    if(!strategyNexthopStateLL_IsAllowed(ll->bestFaces[1])){
-      strategyNexthopStateLL_SendPacket(ll->bestFaces[0]);
-      numberSet_Add(out, strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]));
-    }else{
-      double queue0 = strategyNexthopStateLL_GetQueuing(ll->bestFaces[0]);
-      double queue1 = strategyNexthopStateLL_GetQueuing(ll->bestFaces[1]);
-      double prob0 = 0.5;
-      if(queue0 > 1 || queue1 > 1){
-        prob0 = 1.0 - (queue0 / (queue0 + queue1));
-      }
-      double coin  = ((double) rand() / (RAND_MAX));
-      if(coin < prob0){
-        strategyNexthopStateLL_SendPacket(ll->bestFaces[0]);
-        numberSet_Add(out, strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]));
-      }else{
-        strategyNexthopStateLL_SendPacket(ll->bestFaces[1]);
-        numberSet_Add(out, strategyNexthopStateLL_GetFaceId(ll->bestFaces[1]));
-      }
-    }
-  }
-  return out;
-}
-
-
-#ifndef WITH_POLICY
-static NumberSet *_strategyLowLatency_ReturnNexthops(StrategyImpl *strategy) {
-  StrategyLoadBalancerLL *ll = (StrategyLoadBalancerLL *)strategy->context;
-  return ll->nexthops;
-}
-
-unsigned _strategyLowLatency_CountNexthops(StrategyImpl *strategy) {
-  StrategyLoadBalancerLL *ll = (StrategyLoadBalancerLL *)strategy->context;
-  return (unsigned)numberSet_Length(ll->nexthops);
-}
-#endif /* ! WITH_POLICY */
-
-static void _strategyLowLatency_AddNexthop(StrategyImpl *strategy,
-                                             unsigned connectionId) {
-  PARCUnsigned *cid = parcUnsigned_Create(connectionId);
-
-  StrategyLowLatency *ll = (StrategyLowLatency *)strategy->context;
-
-  if (!parcHashMap_Contains(ll->strategy_state, cid)) {
-    StrategyNexthopStateLL *state = strategyNexthopStateLL_Create(connectionId);
-    parcHashMap_Put(ll->strategy_state, cid, state);
-    if(ll->bestFaces[0] == NULL){
-      ll->bestFaces[0] = state;
-    }
-#ifndef WITH_POLICY
-    numberSet_Add(ll->nexthops, connectionId);
-#endif /* WITH_POLICY */
-  }
-
-  if(parcHashMap_Size(ll->strategy_state) >= 2){
-    _startTimers(strategy);
-  }
-
-  parcUnsigned_Release(&cid);
-}
-
-static void _strategyLowLatency_RemoveNexthop(StrategyImpl *strategy,
-                                                unsigned connectionId) {
-  StrategyLowLatency *ll = (StrategyLowLatency *)strategy->context;
-
-  bool reset_bestFaces = false;
-
-  if((ll->bestFaces[0] != NULL &&
-      strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]) == connectionId) ||
-      (ll->bestFaces[1] != NULL &&
-      strategyNexthopStateLL_GetFaceId(ll->bestFaces[1]) == connectionId)){
-    reset_bestFaces = true;
-  }
-
-  PARCUnsigned *cid = parcUnsigned_Create(connectionId);
-
-  if (parcHashMap_Contains(ll->strategy_state, cid)) {
-    parcHashMap_Remove(ll->strategy_state, cid);
-#ifndef WITH_POLICY
-    numberSet_Remove(lb->nexthops, connectionId);
-#endif /* WITH_POLICY */
-  }
-
-  if(reset_bestFaces){
-    ll->bestFaces[0] = NULL;
-    ll->bestFaces[1] = NULL;
-    strategyLowLatency_SelectBestFaces(ll, false);
-  }
-
-  if(parcHashMap_Size(ll->strategy_state) < 2){
-    _stopTimers(strategy);
-  }
-
-  parcUnsigned_Release(&cid);
-}
-
-static void _strategyLowLatency_ImplDestroy(StrategyImpl **strategyPtr) {
-  parcAssertNotNull(strategyPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*strategyPtr,
-                    "Parameter must dereference to non-null pointer");
-
-  StrategyImpl *impl = *strategyPtr;
-  StrategyLowLatency *strategy = (StrategyLowLatency *)impl->context;
-
-  _stopTimers(impl);
-
-  parcEventTimer_Destroy(&(strategy->sendProbes));
-  parcEventTimer_Destroy(&(strategy->computeBestFace));
-
-  if (parcHashMap_Size(strategy->strategy_state) > 0) {
-    PARCIterator *it = parcHashMap_CreateKeyIterator(strategy->strategy_state);
-    while (parcIterator_HasNext(it)) {
-      PARCUnsigned *cid = parcIterator_Next(it);
-      StrategyNexthopStateLL *state =
-          (StrategyNexthopStateLL *)parcHashMap_Get(strategy->strategy_state, cid);
-      parcObject_Release((void**)&state);
-    }
-    parcIterator_Release(&it);
-  }
-
-  parcHashMap_Release(&(strategy->strategy_state));
-  parcHashMap_Release(&(strategy->pending_probes_ticks));
-  parcHashMap_Release(&(strategy->pending_probes_faces));
-
-  parcMemory_Deallocate(&(strategy->probe));
-  parcMemory_Deallocate(&(strategy->name));
-
-  for(unsigned i = 0; i < strategy->related_prefixes_len; i++){
-    name_Release(&(strategy->related_prefixes[i]));
-  }
-  free(strategy->related_prefixes);
-
-#ifndef WITH_POLICY
-  numberSet_Release(&(strategy->nexthops));
-#endif /* ! WITH_POLICY */
-
-  parcMemory_Deallocate((void **)&strategy);
-  parcMemory_Deallocate((void **)&impl);
-  *strategyPtr = NULL;
-}
diff --git a/hicn-light/src/hicn/strategies/lowLatency.h b/hicn-light/src/hicn/strategies/lowLatency.h
deleted file mode 100644
index 736c8783d..000000000
--- a/hicn-light/src/hicn/strategies/lowLatency.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * Forward on the path with lowest latency
- */
-
-#ifndef lowLatency_h
-#define lowLatency_h
-
-#include <hicn/strategies/strategyImpl.h>
-#include <hicn/core/forwarder.h>
-
-StrategyImpl *strategyLowLatency_Create();
-
-void strategyLowLatency_SetStrategy(StrategyImpl *strategy,
-                                    const Forwarder * forwarder,
-                                    const FibEntry * fibEntry,
-                                    unsigned related_prefixes_len,
-                                    Name **related_prefixes);
-#endif  // lowLatency_h
diff --git a/hicn-light/src/hicn/strategies/low_latency.c b/hicn-light/src/hicn/strategies/low_latency.c
new file mode 100644
index 000000000..1e5a74c1a
--- /dev/null
+++ b/hicn-light/src/hicn/strategies/low_latency.c
@@ -0,0 +1,776 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if 0
+
+#include <hicn/hicn-light/config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <math.h>
+
+#include <hicn/base/khash.h>
+
+#include <parc/assert/parc_Assert.h>
+#include <parc/algol/parc_HashMap.h>
+#include <parc/algol/parc_Memory.h>
+#include <parc/algol/parc_Object.h>
+#include <parc/algol/parc_Unsigned.h>
+
+#include <hicn/core/messageHandler.h>
+
+#include "low_latency.h"
+
+#define STABILITY_FACTOR 15
+#define MAX_SWITCH_TRY 10
+#define MAX_LATENCY_DIFF 10
+#define MAX_TOLLERATED_LATENCY_DIFF 15
+#define MAX_ROUNDS_MP_WITHOUT_CHECK 2
+#define MAX_ROUNDS_AVOIDING_MULTIPATH 40 /* about 20 sec */
+#define MAX_ROUNDS_WITH_ERROR 4
+#define PROBE_LIFETIME 500 /* ms */
+
+#define MAX_ROUNS_WITHOUT_PROBES 4
+
+/*
+ * If we do not receives probes for 4 rounds it means that we had no responce
+ * from any producer for 2 sec we can say that this interface is daed
+ */
+#define MIN_NON_LOSSY_ROUNDS 10
+
+/*
+ * Number of rounds in non lossy mode before switch to no lossy state
+ * Defaults to 10 %
+ */
+#define MAX_LOSS_RATE 0.10
+
+/* Shorthands */
+#define nexthop_state_t strategy_low_latency_nexthop_state_t
+#define state_t strategy_low_latency_state_t
+
+#define NEXTHOP_STATE_INIT                                              \
+  {                                                                     \
+    .in_use = false, .is_allowed = true, .sent_packets = 0,             \
+    .last_try_to_switch_round = 0, .try_to_switch_counter = 0,          \
+    .recevied_probes = 0, .rounds_without_probes = 0, .sent_probes = 0, \
+    .lost_probes = 0, .non_lossy_rounds = MIN_NON_LOSSY_ROUNDS,         \
+    .avg_rtt = -1.0, .avg_rtt_in_use = -1.0, .avg_queue = 0.0001,       \
+    .avg_loss_rate = 0.0,                                               \
+  }
+
+// XXX ????
+#define STATE_INIT \
+  {}
+
+static
+    void
+strategy_low_latency_SendProbesCB(int fd, PARCEventType which_event, void *data)
+{
+    parcAssertTrue(which_event & PARCEventType_Timeout,
+            "Event incorrect, expecting %X set, got %X",
+            PARCEventType_Timeout, which_event);
+
+    StrategyLowLatency *ll = (StrategyLowLatency *) data;
+
+    //delete old pending probes
+    if(parcHashMap_Size(ll->pending_probes_ticks) != 0){
+        Ticks now = forwarder_GetTicks(ll->forwarder);
+        PARCIterator *iterator = parcHashMap_CreateKeyIterator(ll->pending_probes_ticks);
+        NumberSet *to_remove = numberSet_Create();
+        while(parcIterator_HasNext(iterator)) {
+            PARCUnsigned *parc_seq = (PARCUnsigned *) parcIterator_Next(iterator);
+            PARCUnsigned *parc_time = (PARCUnsigned *) parcHashMap_Get(ll->pending_probes_ticks, parc_seq);
+            Ticks sent_time = parcUnsigned_GetUnsigned(parc_time);
+            if((now - sent_time) > PROBE_LIFETIME){
+                //probes to delete
+                numberSet_Add(to_remove, parcUnsigned_GetUnsigned(parc_seq));
+            }
+        }
+        parcIterator_Release(&iterator);
+
+        for(int i = 0; i < numberSet_Length(to_remove); i++){
+            PARCUnsigned *prob_seq = parcUnsigned_Create(numberSet_GetItem(to_remove,i));
+            PARCUnsigned *cid = (PARCUnsigned *) parcHashMap_Get(ll->pending_probes_faces, prob_seq);
+            StrategyNexthopStateLL *state =
+                (StrategyNexthopStateLL *) parcHashMap_Get(ll->strategy_state, cid);
+            strategyNexthopStateLL_LostProbe(state);
+            parcHashMap_Remove(ll->pending_probes_ticks, prob_seq);
+            parcHashMap_Remove(ll->pending_probes_faces, prob_seq);
+            parcUnsigned_Release(&prob_seq);
+        }
+        numberSet_Release(&to_remove);
+    }
+
+    ConnectionTable * ct = forwarder_GetConnectionTable(ll->forwarder);
+
+    PARCIterator *iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
+    while(parcIterator_HasNext(iterator)){
+        PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
+        Connection *conn =
+            (Connection *)connectionTable_FindById(ct,
+                    parcUnsigned_GetUnsigned(cid));
+        if(!conn)
+            continue;
+
+        StrategyNexthopStateLL *state =
+            (StrategyNexthopStateLL *) parcHashMap_Get(ll->strategy_state, cid);
+
+        //probe only usable paths
+        if(!strategyNexthopStateLL_IsAllowed(state))
+            continue;
+
+        uint32_t seq = rand();
+        messageHandler_SetProbeName(ll->probe, HF_INET6_TCP,
+                ll->name, seq);
+        connection_Probe(conn, ll->probe);
+
+        PARCUnsigned *parc_seq = parcUnsigned_Create(seq);
+        Ticks now = forwarder_GetTicks(ll->forwarder);
+        PARCUnsigned *parc_time = parcUnsigned_Create((unsigned int)now);
+        parcHashMap_Put(ll->pending_probes_ticks, parc_seq, parc_time);
+        parcHashMap_Put(ll->pending_probes_faces, parc_seq, cid);
+        strategyNexthopStateLL_SentProbe(state);
+        parcUnsigned_Release(&parc_seq);
+        parcUnsigned_Release(&parc_time);
+    }
+    parcIterator_Release(&iterator);
+
+    struct timeval timeout = {0,50000};
+    parcEventTimer_Start(ll->sendProbes, &timeout);
+}
+
+static
+void
+strategy_low_latency_SendMapmeUpdate(StrategyLowLatency *ll,
+        const NumberSet * nexthops){
+    MapMe * mapme = forwarder_getMapmeInstance(ll->forwarder);
+    FIB * fib = forwarder_getFib((Forwarder*) ll->forwarder);
+    for(unsigned i = 0; i < ll->related_prefixes_len; i++){
+        FibEntry *fibEntry = fib_MatchName(fib, ll->related_prefixes[i]);
+        if (!fibEntry)
+            continue;
+        mapme_maybe_send_to_nexthops(mapme, fibEntry, nexthops);
+    }
+}
+
+static
+void
+strategy_low_latency_SelectBestFaces(StrategyLowLatency *ll, bool new_round)
+{
+
+    StrategyNexthopStateLL * old_faces[2];
+    old_faces[0] = ll->bestFaces[0];
+    old_faces[1] = ll->bestFaces[1];
+
+    if(new_round){
+        ll->round++;
+    }
+
+    if(parcHashMap_Size(ll->strategy_state) == 0){
+        ll->bestFaces[0] = NULL;
+        ll->bestFaces[1] = NULL;
+        ll->use2paths = false;
+        goto NEW_ROUND;
+    }
+
+    if(ll->use2paths && ll->bestFaces[0] != NULL && ll->bestFaces[1] != NULL){
+        //multipath  case
+
+        if(!strategyNexthopStateLL_IsLossy(ll->bestFaces[0])
+                && !strategyNexthopStateLL_IsLossy(ll->bestFaces[1])
+                && strategyNexthopStateLL_IsAllowed(ll->bestFaces[0])
+                && strategyNexthopStateLL_IsAllowed(ll->bestFaces[1])){
+
+            if(ll->rounds_in_multipath < MAX_ROUNDS_MP_WITHOUT_CHECK){
+                //we are at the first rounds of the multipath let's wait a bit
+                //(MAX_ROUNDS_MP_WITHOUT_CHECK) to make the queuing converge
+                ll->rounds_in_multipath++;
+                goto NEW_ROUND;
+            }
+
+            //we need to decide if we want ot keep using two paths or not
+            ll->rounds_in_multipath++;
+            double rtt0 = strategyNexthopStateLL_GetRTTLive(ll->bestFaces[0]);
+            double rtt1 = strategyNexthopStateLL_GetRTTLive(ll->bestFaces[1]);
+            double diff = fabs(rtt0 - rtt1);
+
+            if(diff < MAX_LATENCY_DIFF){
+                //everything is working, keep using the two paths
+                ll->rounds_with_error = 0;
+                goto NEW_ROUND;
+            }
+
+            //check for how many rounds we had problems
+            if(ll->rounds_with_error < MAX_ROUNDS_WITH_ERROR &&
+                    diff < MAX_TOLLERATED_LATENCY_DIFF){
+                //we can tollerate few round with errors
+                ll->rounds_with_error++;
+                goto NEW_ROUND;
+            }
+
+            //prevent the usage of multiple paths
+            ll->rounds_with_error = 0;
+            ll->avoid_multipath = true;
+            ll->rounds_avoiding_multipath = 0;
+        } //else
+        //at least one of the two path is lossy
+        //or it is not allowed by the policies.
+        //search for a better possibility
+    }
+
+    ll->bestFaces[0] = NULL;
+    ll->bestFaces[1] = NULL;
+
+    //check if there is at least one non lossy connection
+    PARCIterator *iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
+    bool check_losses = true;
+    bool found_good_face = false;
+    while(parcIterator_HasNext(iterator) && !found_good_face){
+        PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
+        const StrategyNexthopStateLL *state = parcHashMap_Get(ll->strategy_state, cid);
+        if(!strategyNexthopStateLL_IsLossy(state) &&
+                strategyNexthopStateLL_IsAllowed(state)){
+            found_good_face = true;
+        }
+    }
+    parcIterator_Release(&iterator);
+    if(!found_good_face){
+        // all the available faces are lossy, so we take into account only
+        // the latency computed with the probes
+        check_losses = false;
+    }
+
+    if(ll->bestFaces[0] == NULL){
+        //try to take a random face
+        PARCIterator *iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
+        bool face_found = false;
+        while(parcIterator_HasNext(iterator) && !face_found) {
+            PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
+            StrategyNexthopStateLL *state = (StrategyNexthopStateLL *)
+                parcHashMap_Get(ll->strategy_state, cid);
+
+            if((check_losses && strategyNexthopStateLL_IsLossy(state)) ||
+                    !strategyNexthopStateLL_IsAllowed(state)){
+                //skip the face
+                continue;
+            }
+
+            ll->bestFaces[0] = state;
+            face_found = true;
+        }
+        parcIterator_Release(&iterator);
+    }
+
+    if(ll->bestFaces[0] == NULL){
+        //no usable face exists
+        ll->bestFaces[0] = NULL;
+        ll->bestFaces[1] = NULL;
+        ll->use2paths = false;
+        goto NEW_ROUND;
+    }
+
+    double bestRtt = strategyNexthopStateLL_GetRTTLive(ll->bestFaces[0]);
+
+    if(ll->avoid_multipath)
+        ll->rounds_avoiding_multipath++;
+
+    if(ll->rounds_avoiding_multipath > MAX_ROUNDS_AVOIDING_MULTIPATH){
+        ll->avoid_multipath = false;
+        ll->rounds_avoiding_multipath = 0;
+    }
+
+    iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
+    while (parcIterator_HasNext(iterator)) {
+
+        PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
+        StrategyNexthopStateLL *state = (StrategyNexthopStateLL *)
+            parcHashMap_Get(ll->strategy_state, cid);
+        double rtt = strategyNexthopStateLL_GetRTTLive(state);
+
+        if((check_losses && strategyNexthopStateLL_IsLossy(state)) ||
+                !strategyNexthopStateLL_IsAllowed(state)){
+            //skip the face
+            continue;
+        }
+
+        if(rtt + STABILITY_FACTOR < bestRtt){
+            //maybe we found a better face
+            double rttInUse = strategyNexthopStateLL_GetRTTInUse(state);
+            unsigned try = strategyNexthopStateLL_GetTryToSwitch(state);
+
+            //we check the rtt in use to check if the new face that we found
+            //gets congested when we use it to send the traffic
+            if(rttInUse < bestRtt || try > MAX_SWITCH_TRY){
+                //we have a new best face!
+                strategyNexthopStateLL_ResetTryToSwitch((StrategyNexthopStateLL*) state);
+                bestRtt = rtt;
+                if(ll->bestFaces[0] != NULL)
+                    strategyNexthopStateLL_SetUnusedFace(ll->bestFaces[0]);
+                ll->bestFaces[0] = (StrategyNexthopStateLL*) state;
+            }else{
+                //in this case we should switch but we wait MAX_SWITCH_TRY
+                //before switch to avoid ossillations between different paths
+                strategyNexthopStateLL_IncreaseTryToSwitch(
+                        (StrategyNexthopStateLL*) state, ll->round);
+            }
+        }
+    }
+
+    parcIterator_Release(&iterator);
+
+    if(ll->bestFaces[0] == NULL){
+        //we found no face so return
+        ll->bestFaces[0] = NULL;
+        ll->bestFaces[1] = NULL;
+        ll->use2paths = false;
+        goto NEW_ROUND;
+    }
+
+    if(parcHashMap_Size(ll->strategy_state) == 1 || ll->avoid_multipath){
+        //in this case (one face available or avoid multipath) we stop the
+        //search here. Just reset face 1 if needed
+        if(ll->bestFaces[1] != NULL){
+            strategyNexthopStateLL_SetUnusedFace(ll->bestFaces[1]);
+            ll->bestFaces[1] = NULL;
+        }
+        ll->use2paths = false;
+        goto NEW_ROUND;
+    }
+
+    //if we are here we have more than 1 interface, so we search for a second one
+    //to use in case of multipath
+    iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
+    while (parcIterator_HasNext(iterator)) {
+        PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
+        if(parcUnsigned_GetUnsigned(cid) !=
+                strategyNexthopStateLL_GetFaceId(ll->bestFaces[0])){
+
+            StrategyNexthopStateLL *state = (StrategyNexthopStateLL *)
+                parcHashMap_Get(ll->strategy_state, cid);
+
+            if((check_losses && strategyNexthopStateLL_IsLossy(state)) ||
+                    !strategyNexthopStateLL_IsAllowed(state)){
+                //skip the face
+                continue;
+            }
+
+            if(ll->bestFaces[1] == NULL){
+                //in case of 2 faces we should pass always here
+                ll->bestFaces[1] = state;
+            }else{
+                //TODO this must be tested with more then 2 faces
+                double rtt1 = strategyNexthopStateLL_GetRTTLive(ll->bestFaces[1]);
+                double rttNewFace = strategyNexthopStateLL_GetRTTLive(state);
+                if(rttNewFace + STABILITY_FACTOR < rtt1){
+                    strategyNexthopStateLL_SetUnusedFace(ll->bestFaces[1]);
+                    ll->bestFaces[1] = state;
+                }
+            }
+        }
+    }
+    parcIterator_Release(&iterator);
+
+    if(ll->bestFaces[1] != NULL){
+        //we are not using the second face yet so we use the normal rtt for comparison
+        double rtt0 = strategyNexthopStateLL_GetRTTProbe(ll->bestFaces[0]);
+        double rtt1 = strategyNexthopStateLL_GetRTTProbe(ll->bestFaces[1]);
+        double diff = fabs(rtt0 - rtt1);
+        if(diff < MAX_LATENCY_DIFF) {
+            //let's start to use 2 paths
+            ll->rounds_with_error = 0;
+            ll->use2paths = true;
+            ll->rounds_in_multipath = 0;
+        }else{
+            //we use only one path
+            strategyNexthopStateLL_SetUnusedFace(ll->bestFaces[1]);
+            ll->bestFaces[1] = NULL;
+            ll->use2paths = false;
+        }
+    }else{
+        ll->use2paths = false;
+    }
+
+NEW_ROUND:
+    {
+        Logger * log = forwarder_GetLogger(ll->forwarder);
+        if(log != NULL &&
+                logger_IsLoggable(log, LoggerFacility_Strategy, PARCLogLevel_Info)){
+            if(ll->use2paths){
+                logger_Log(log, LoggerFacility_Strategy, PARCLogLevel_Info,
+                        __func__, "use 2 paths. rtt face %d = %f queue = %f is_lossy = %d,"
+                        "rtt face %d = %f queue = %f is_lossy = %d\n",
+                        strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]),
+                        strategyNexthopStateLL_GetRTTLive(ll->bestFaces[0]),
+                        strategyNexthopStateLL_GetQueuing(ll->bestFaces[0]),
+                        strategyNexthopStateLL_IsLossy(ll->bestFaces[0]),
+                        strategyNexthopStateLL_GetFaceId(ll->bestFaces[1]),
+                        strategyNexthopStateLL_GetRTTLive(ll->bestFaces[1]),
+                        strategyNexthopStateLL_GetQueuing(ll->bestFaces[1]),
+                        strategyNexthopStateLL_IsLossy(ll->bestFaces[1]));
+            }else{
+                if(ll->bestFaces[0] != NULL){
+                    logger_Log(log, LoggerFacility_Strategy,
+                            PARCLogLevel_Info, __func__,
+                            "use 1 path. rtt face %d = %f is_lossy = %d, "
+                            "(avoid multipath = %d)\n",
+                            strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]),
+                            strategyNexthopStateLL_GetRTTLive(ll->bestFaces[0]),
+                            strategyNexthopStateLL_IsLossy(ll->bestFaces[0]),
+                            ll->avoid_multipath);
+                }else{
+                    logger_Log(log, LoggerFacility_Strategy, PARCLogLevel_Info,
+                            __func__, "no face to use!\n");
+                }
+            }
+        }
+    }
+
+    //update the round only at the end for all the faces
+    if(new_round){
+        PARCIterator * iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
+        while (parcIterator_HasNext(iterator)) {
+            PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
+            strategyNexthopStateLL_StartNewRound((StrategyNexthopStateLL *)
+                    parcHashMap_Get(ll->strategy_state, cid));
+        }
+        parcIterator_Release(&iterator);
+    }
+
+    //mapme updates
+    //if ll->bestFaces[0] == NULL we don't have any output faces
+    //so don't need to send any updates since we are disconnected
+    if(ll->related_prefixes_len != 0){
+        if(ll->bestFaces[0] != NULL){
+            NumberSet *out = numberSet_Create();
+            if(old_faces[0] == NULL ||
+                    (strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]) !=
+                     strategyNexthopStateLL_GetFaceId(old_faces[0]))){
+                //there is a new face 0 so we need a map me update
+                //if ll->bestFaces[1] != NULL we need to send the update
+                //even if it is the same as before
+                numberSet_Add(out,
+                        strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]));
+                if(ll->bestFaces[1] != NULL){
+                    numberSet_Add(out,
+                            strategyNexthopStateLL_GetFaceId(ll->bestFaces[1]));
+                }
+                strategy_low_latency_SendMapmeUpdate(ll,out);
+            }else{
+                if(ll->bestFaces[1] != NULL){
+                    if(old_faces[1] == NULL ||
+                            (strategyNexthopStateLL_GetFaceId(ll->bestFaces[1]) !=
+                             strategyNexthopStateLL_GetFaceId(old_faces[1]))){
+                        //send a mapme both with face 0 and face 1
+                        numberSet_Add(out,
+                                strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]));
+                        numberSet_Add(out,
+                                strategyNexthopStateLL_GetFaceId(ll->bestFaces[1]));
+                        strategy_low_latency_SendMapmeUpdate(ll,out);
+                    }
+                }else{
+                    if(old_faces[1] != NULL){
+                        //in the previuos round we were using two faces, now only one
+                        //send update with only face 0
+                        numberSet_Add(out,
+                                strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]));
+                        strategy_low_latency_SendMapmeUpdate(ll,out);
+                    }
+                }
+            }
+            numberSet_Release(&out);
+        }
+    }
+}
+
+static
+void
+strategy_low_latency_BestFaceCB(int fd, PARCEventType which_event, void *data)
+{
+    parcAssertTrue(which_event & PARCEventType_Timeout,
+            "Event incorrect, expecting %X set, got %X",
+            PARCEventType_Timeout, which_event);
+
+    StrategyLowLatency * ll = (StrategyLowLatency *) data;
+    strategy_low_latency_SelectBestFaces(ll, true);
+
+    struct timeval timeout = {0, 500000};
+    parcEventTimer_Start(ll->computeBestFace, &timeout);
+}
+
+static
+void
+_startTimers(strategy_entry_t * entry)
+{
+    struct timeval timeoutProbes = {0, 10000};
+    struct timeval timeoutBF = {1, 0};
+
+    parcEventTimer_Start(entry->state.sendProbes, &timeoutProbes);
+    parcEventTimer_Start(entry->state.computeBestFace, &timeoutBF);
+}
+
+static
+void
+_stopTimers(strategy_entry_t * entry)
+{
+    parcEventTimer_Stop(entry->state.sendProbes);
+    parcEventTimer_Stop(entry->state.computeBestFace);
+}
+
+static
+void
+strategy_low_latency_initialize(strategy_entry_t * entry)
+{
+    srand((unsigned int)time(NULL));
+
+    /* XXX TODO Three hashmaps to initialize */
+    strategy->strategy_state = parcHashMap_Create();
+    strategy->pending_probes_ticks = parcHashMap_Create();
+    strategy->pending_probes_faces = parcHashMap_Create();
+
+    Dispatcher *dispatcher = forwarder_GetDispatcher((Forwarder *)ll->forwarder);
+    ip_prefix_t address;
+    nameBitvector_ToIPAddress(name_GetContentName(
+                fibEntry_GetPrefix(fibEntry)), &address);
+
+    entry->state = {
+        .probe = messageHandler_CreateProbePacket(HF_INET6_TCP, PROBE_LIFETIME),
+        .name = messageHandler_CreateProbeName(&address);
+        .sendProbes = dispatcher_CreateTimer(dispatcher, false,
+                strategy_low_latency_SendProbesCB, ll);
+        .round = 0;
+        .rounds_in_multipath = 0;
+        .rounds_with_error = 0;
+        .rounds_avoiding_multipath = 0;
+        .use2paths = false;
+        .avoid_multipath = false;
+        .computeBestFace = dispatcher_CreateTimer(dispatcher, false,
+                strategy_low_latency_BestFaceCB, ll);
+        .related_prefixes_len = related_prefixes_len;
+        // XXX TODO
+        .related_prefixes = malloc(sizeof(Name *) * related_prefixes_len);
+    };
+
+    for(unsigned i = 0; i < entry->state.related_prefixes_len; i++){
+        entry->state.related_prefixes[i] = name_Copy(related_prefixes[i]);
+    }
+}
+
+static
+void
+strategy_low_latency_finalize(strategy_entry_t * entry)
+{
+    _stopTimers(entry);
+
+    parcEventTimer_Destroy(&(strategy->sendProbes));
+    parcEventTimer_Destroy(&(strategy->computeBestFace));
+
+    if (parcHashMap_Size(strategy->strategy_state) > 0) {
+        PARCIterator *it = parcHashMap_CreateKeyIterator(strategy->strategy_state);
+        while (parcIterator_HasNext(it)) {
+            PARCUnsigned *cid = parcIterator_Next(it);
+            StrategyNexthopStateLL *state =
+                (StrategyNexthopStateLL *)parcHashMap_Get(strategy->strategy_state, cid);
+            parcObject_Release((void**)&state);
+        }
+        parcIterator_Release(&it);
+    }
+
+    parcHashMap_Release(&(strategy->strategy_state));
+    parcHashMap_Release(&(strategy->pending_probes_ticks));
+    parcHashMap_Release(&(strategy->pending_probes_faces));
+
+    parcMemory_Deallocate(&(strategy->probe));
+    parcMemory_Deallocate(&(strategy->name));
+
+    for(unsigned i = 0; i < strategy->related_prefixes_len; i++){
+        name_Release(&(strategy->related_prefixes[i]));
+    }
+    free(strategy->related_prefixes);
+
+    parcMemory_Deallocate((void **)&strategy);
+    parcMemory_Deallocate((void **)&impl);
+    *strategyPtr = NULL;
+}
+
+static
+void
+strategy_low_latency_add_nexthop(strategy_entry_t * entry, unsigned nexthop, nexthop_state_t * state)
+{
+    PARCUnsigned *cid = parcUnsigned_Create(connectionId);
+
+    StrategyLowLatency *ll = (StrategyLowLatency *)strategy->context;
+
+    if (!parcHashMap_Contains(ll->strategy_state, cid)) {
+        StrategyNexthopStateLL *state = strategyNexthopStateLL_Create(connectionId);
+        parcHashMap_Put(ll->strategy_state, cid, state);
+        if(ll->bestFaces[0] == NULL){
+            ll->bestFaces[0] = state;
+        }
+    }
+
+    if(parcHashMap_Size(ll->strategy_state) >= 2){
+        _startTimers(strategy);
+    }
+
+    parcUnsigned_Release(&cid);
+}
+
+static
+void
+strategy_low_latency_remove_nexthop(strategy_entry_t * entry, unsigned nexthop, nexthop_state_t * state)
+{
+    bool reset_bestFaces = false;
+
+    if((entry->state.bestFaces[0] != NULL &&
+                strategyNexthopStateLL_GetFaceId(entry->state.bestFaces[0]) == connectionId) ||
+            (entry->state.bestFaces[1] != NULL &&
+             strategyNexthopStateLL_GetFaceId(entry->state.bestFaces[1]) == connectionId)){
+        reset_bestFaces = true;
+    }
+
+    PARCUnsigned *cid = parcUnsigned_Create(connectionId);
+
+    if (parcHashMap_Contains(entry->state.strategy_state, cid)) {
+        parcHashMap_Remove(entry->state.strategy_state, cid);
+    }
+
+    if(reset_bestFaces){
+        entry->state.bestFaces[0] = NULL;
+        entry->state.bestFaces[1] = NULL;
+        strategy_low_latency_SelectBestFaces(ll, false);
+    }
+
+    if(parcHashMap_Size(entry->state.strategy_state) < 2){
+        _stopTimers(strategy);
+    }
+
+    parcUnsigned_Release(&cid);
+}
+
+static
+nexthops_t *
+strategy_low_latency_lookup_nexthops(strategy_entry_t * entry,
+        const msgbuf_t * msgbuf)
+{
+    //unsigned out_connection;
+    NumberSet *out = numberSet_Create();
+
+    StrategyLowLatency *ll = (StrategyLowLatency *)strategy->context;
+
+    //update is_allowed flag of all the next hops
+    PARCIterator *iterator = parcHashMap_CreateKeyIterator(ll->strategy_state);
+    while(parcIterator_HasNext(iterator)){
+        PARCUnsigned *cid = (PARCUnsigned *) parcIterator_Next(iterator);
+        StrategyNexthopStateLL *state =
+            (StrategyNexthopStateLL *) parcHashMap_Get(ll->strategy_state, cid);
+        if(numberSet_Contains(nexthops, parcUnsigned_GetUnsigned(cid))){
+            strategyNexthopStateLL_SetIsAllowed(state,true);
+        }else{
+            strategyNexthopStateLL_SetIsAllowed(state,false);
+        }
+    }
+    parcIterator_Release(&iterator);
+
+    if(ll->bestFaces[0] != NULL &&
+            !strategyNexthopStateLL_IsAllowed(ll->bestFaces[0])){
+        //if ll->bestFaces[0] is not allowed we need to find a new face
+        strategy_low_latency_SelectBestFaces(ll, false);
+    }
+
+    //at this point ll->bestFaces[0] must be allowed
+    //single path case
+    if(ll->bestFaces[0] != NULL && (ll->bestFaces[1] == NULL || !ll->use2paths)){
+        strategyNexthopStateLL_SendPacket(ll->bestFaces[0]);
+        numberSet_Add(out, strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]));
+
+        //multipath case
+    }else if(ll->bestFaces[0] != NULL && ll->bestFaces[1] != NULL && ll->use2paths){
+        //it may happen that ll->bestFaces[1] is not allowed, in that case we send on
+        //ll->bestFaces[0] until the next best face selection
+        if(!strategyNexthopStateLL_IsAllowed(ll->bestFaces[1])){
+            strategyNexthopStateLL_SendPacket(ll->bestFaces[0]);
+            numberSet_Add(out, strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]));
+        }else{
+            double queue0 = strategyNexthopStateLL_GetQueuing(ll->bestFaces[0]);
+            double queue1 = strategyNexthopStateLL_GetQueuing(ll->bestFaces[1]);
+            double prob0 = 0.5;
+            if(queue0 > 1 || queue1 > 1){
+                prob0 = 1.0 - (queue0 / (queue0 + queue1));
+            }
+            double coin  = ((double) rand() / (RAND_MAX));
+            if(coin < prob0){
+                strategyNexthopStateLL_SendPacket(ll->bestFaces[0]);
+                numberSet_Add(out, strategyNexthopStateLL_GetFaceId(ll->bestFaces[0]));
+            }else{
+                strategyNexthopStateLL_SendPacket(ll->bestFaces[1]);
+                numberSet_Add(out, strategyNexthopStateLL_GetFaceId(ll->bestFaces[1]));
+            }
+        }
+    }
+    return out;
+}
+
+
+
+static
+void
+strategy_low_latency_on_data(strategy_entry_t * entry,
+        const nexthops_t * nexthops, const msgbuf_t * msgbuf,
+        Ticks pitEntryCreation, Ticks objReception)
+{
+    if (!msgbuf_is_probe(msgbuf))
+        return;
+
+    uint32_t seq = messageHandler_GetSegment(message_FixedHeader(objectMessage));
+    if (!parcHashMap_Contains(ll->pending_probes_ticks, seq))
+        return; // unexpected
+
+    /* A single nexthop is expected */
+    unsigned nexthop;
+    nexthops_foreach(nexthops, nexthop, {
+        const StrategyNexthopStateLL *state =
+            parcHashMap_Get(ll->strategy_state, nexthop);
+        if (!state)
+            // this may happen if we remove a face/route while downloading a file
+            // we should ignore this timeout
+            continue;
+
+        Ticks time = parcUnsigned_GetUnsigned(
+                parcHashMap_Get(ll->pending_probes_ticks, seq));
+        Ticks now = forwarder_GetTicks(ll->forwarder);
+        Ticks RTT =  now - time;
+        if(RTT <= 0)
+            RTT = 1;
+        strategyNexthopStateLL_AddRttSample(
+                (StrategyNexthopStateLL *) state, (unsigned int)RTT);
+        parcHashMap_Remove(ll->pending_probes_ticks, seq);
+    }
+    };
+}
+
+static
+void
+strategy_low_latency_on_timeout(strategy_entry_t * entry, const nexthops_t * nexthops)
+{
+    /* Nothing to do */
+}
+
+DECLARE_STRATEGY(low_latency);
+
+#undef nexthop_state_t
+#undef state_t
+
+#endif
diff --git a/hicn-light/src/hicn/strategies/low_latency.h b/hicn-light/src/hicn/strategies/low_latency.h
new file mode 100644
index 000000000..6b3001637
--- /dev/null
+++ b/hicn-light/src/hicn/strategies/low_latency.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Forward on the path with lowest latency
+ */
+
+#ifndef HICNLIGHT_STRATEGY_LOW_LATENCY_H
+#define HICNLIGHT_STRATEGY_LOW_LATENCY_H
+
+struct name_s;
+
+#include <hicn/strategy.h>
+
+typedef struct {
+  void *_;
+} strategy_low_latency_nexthop_state_t;
+
+typedef struct {
+  void *_;
+} strategy_low_latency_state_t;
+
+typedef struct {
+  // Name ** related_prefixes;
+  struct name_s *related_prefixes[MAX_FWD_STRATEGY_RELATED_PREFIXES];
+  unsigned related_prefixes_len;
+} strategy_low_latency_options_t;
+
+#if 0
+
+/*
+ * We have global state in addition to state associated for each next hop :
+ */
+typedef struct {
+  bool in_use;
+  bool is_allowed; // XXX TODO the policy may not allow the use of this face
+//  unsigned face_id;
+  unsigned sent_packets;
+  /* switch metrics */
+  unsigned last_try_to_switch_round;
+  unsigned try_to_switch_counter;
+  /* probes counters */
+  unsigned recevied_probes;
+  unsigned rounds_without_probes;
+  unsigned sent_probes;
+  unsigned lost_probes;
+  unsigned non_lossy_rounds;
+  /* Averages */
+  double avg_rtt;
+  double avg_rtt_in_use;
+  double avg_queue;
+  double avg_loss_rate;
+} strategy_low_latency_nexthop_state_t;
+
+typedef struct {
+  // hash map from connectionId to StrategyNexthopStateLL
+  //PARCHashMap *strategy_state;
+  // XXX This is now store in each nexthop state
+
+  /*
+   * Hhash map from sequence number to ticks (sent time)
+   *
+   * TODO improvement: the tick and face id could be stored in the probe and
+   * repeated in the reply to avoid state to be maintained.
+   *
+   * Also, in case we have few probes, linear scan might be more effective
+   */
+  PARCHashMap *pending_probes_ticks;
+
+  /* hash map from sequence number to face id */
+  PARCHashMap *pending_probes_faces;
+
+  const Forwarder * forwarder;
+  PARCEventTimer *sendProbes;
+  PARCEventTimer *computeBestFace;
+  uint8_t * probe;
+  hicn_name_t * name;
+  StrategyNexthopStateLL * bestFaces[2];
+  unsigned round;
+  unsigned rounds_in_multipath;
+  unsigned rounds_with_error;
+  unsigned rounds_avoiding_multipath;
+  bool use2paths;
+  bool avoid_multipath;
+} strategy_low_latency_state_t;
+
+#endif
+
+#endif /* HICNLIGHT_STRATEGY_LOW_LATENCY_H */
diff --git a/hicn-light/src/hicn/strategies/nexthopState.c b/hicn-light/src/hicn/strategies/nexthopState.c
deleted file mode 100644
index 40af14832..000000000
--- a/hicn-light/src/hicn/strategies/nexthopState.c
+++ /dev/null
@@ -1,212 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <parc/algol/parc_DisplayIndented.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Object.h>
-
-#include <parc/assert/parc_Assert.h>
-#include <hicn/strategies/nexthopState.h>
-
-#define AVG_PI_THRESHOLD 1e-3
-
-struct strategy_nexthop_state {
-  unsigned int pi;
-  double avg_pi;
-  double weight;
-};
-
-static bool _strategyNexthopState_Destructor(
-    StrategyNexthopState **instancePtr) {
-  return true;
-}
-
-parcObject_ImplementAcquire(strategyNexthopState, StrategyNexthopState);
-
-parcObject_ImplementRelease(strategyNexthopState, StrategyNexthopState);
-
-parcObject_Override(
-    StrategyNexthopState, PARCObject,
-    .destructor = (PARCObjectDestructor *)_strategyNexthopState_Destructor,
-    .copy = (PARCObjectCopy *)strategyNexthopState_Copy,
-    .display = (PARCObjectDisplay *)strategyNexthopState_Display,
-    .toString = (PARCObjectToString *)strategyNexthopState_ToString,
-    .equals = (PARCObjectEquals *)strategyNexthopState_Equals,
-    .compare = (PARCObjectCompare *)strategyNexthopState_Compare,
-    .hashCode = (PARCObjectHashCode *)strategyNexthopState_HashCode,
-    .display = (PARCObjectDisplay *)strategyNexthopState_Display);
-
-void strategyNexthopState_AssertValid(const StrategyNexthopState *instance) {
-  parcAssertTrue(strategyNexthopState_IsValid(instance),
-                 "StrategyNexthopState is not valid.");
-}
-
-StrategyNexthopState *strategyNexthopState_Create() {
-  StrategyNexthopState *result =
-      parcObject_CreateInstance(StrategyNexthopState);
-  if (result != NULL) {
-    result->pi = 0;
-    result->avg_pi = 0.0;
-    result->weight = 1;
-  }
-  return result;
-}
-
-void strategyNexthopState_Reset(StrategyNexthopState *x) {
-  x->pi = 0;
-  x->avg_pi = 0.0;
-  x->weight = 1;
-}
-
-int strategyNexthopState_Compare(const StrategyNexthopState *val,
-                                 const StrategyNexthopState *other) {
-  if (val == NULL) {
-    if (other != NULL) {
-      return -1;
-    }
-  } else if (other == NULL) {
-    return 1;
-  } else {
-    strategyNexthopState_OptionalAssertValid(val);
-    strategyNexthopState_OptionalAssertValid(other);
-
-    if (val->pi < other->pi) {
-      return -1;
-    } else if (val->pi > other->pi) {
-      return 1;
-    }
-
-    if (val->avg_pi < other->avg_pi) {
-      return -1;
-    } else if (val->avg_pi > other->avg_pi) {
-      return 1;
-    }
-
-    if (val->weight < other->weight) {
-      return -1;
-    } else if (val->weight > other->weight) {
-      return 1;
-    }
-  }
-
-  return 0;
-}
-
-StrategyNexthopState *strategyNexthopState_Copy(
-    const StrategyNexthopState *original) {
-  StrategyNexthopState *result = strategyNexthopState_Create();
-  result->pi = original->pi;
-  result->avg_pi = original->avg_pi;
-  result->weight = original->weight;
-
-  return result;
-}
-
-void strategyNexthopState_Display(const StrategyNexthopState *instance,
-                                  int indentation) {
-  parcDisplayIndented_PrintLine(indentation, "StrategyNexthopState@%p {",
-                                instance);
-  parcDisplayIndented_PrintLine(indentation + 1, "%d", instance->pi);
-  parcDisplayIndented_PrintLine(indentation + 1, "%f", instance->avg_pi);
-  parcDisplayIndented_PrintLine(indentation + 1, "%f", instance->weight);
-  parcDisplayIndented_PrintLine(indentation, "}");
-}
-
-bool strategyNexthopState_Equals(const StrategyNexthopState *x,
-                                 const StrategyNexthopState *y) {
-  bool result = false;
-
-  if (x == y) {
-    result = true;
-  } else if (x == NULL || y == NULL) {
-    result = false;
-  } else {
-    strategyNexthopState_OptionalAssertValid(x);
-    strategyNexthopState_OptionalAssertValid(y);
-
-    if (strategyNexthopState_Compare(x, y) == 0) {
-      result = true;
-    }
-  }
-
-  return result;
-}
-
-PARCHashCode strategyNexthopState_HashCode(const StrategyNexthopState *x) {
-  PARCHashCode result = 0;
-  char str[128];
-  sprintf(str, "PI:%d: AVG_PI:%f: W:%f", x->pi, x->avg_pi, x->weight);
-  result = parcHashCode_Hash((uint8_t *)&str, strlen(str));
-  return result;
-}
-
-bool strategyNexthopState_IsValid(const StrategyNexthopState *x) {
-  bool result = false;
-
-  if (x != NULL) {
-    result = true;
-  }
-
-  return result;
-}
-
-char *strategyNexthopState_ToString(const StrategyNexthopState *x) {
-  // this is not implemented
-  parcTrapNotImplemented("strategyNexthopState_ToString is not implemented");
-  return NULL;
-}
-
-unsigned strategyNexthopState_GetPI(const StrategyNexthopState *x) {
-  strategyNexthopState_OptionalAssertValid(x);
-
-  return x->pi;
-}
-
-double strategyNexthopState_GetAvgPI(const StrategyNexthopState *x) {
-  strategyNexthopState_OptionalAssertValid(x);
-
-  return x->avg_pi;
-}
-
-double strategyNexthopState_GetWeight(const StrategyNexthopState *x) {
-  strategyNexthopState_OptionalAssertValid(x);
-
-  return x->weight;
-}
-
-double strategyNexthopState_UpdateState(StrategyNexthopState *x, bool inc,
-                                        double alpha) {
-  if (inc) {
-    x->pi++;
-  } else {
-    if (x->pi > 0) {
-      x->pi--;
-    }
-  }
-  x->avg_pi = (x->avg_pi * alpha) + (x->pi * (1 - alpha));
-#ifdef WITH_POLICY
-  if (x->avg_pi < AVG_PI_THRESHOLD) {
-#else
-  if (x->avg_pi == 0.0) {
-#endif /* WITH_POLICY */
-    x->avg_pi = 0.1;
-  }
-  x->weight = 1 / x->avg_pi;
-
-  return x->weight;
-}
diff --git a/hicn-light/src/hicn/strategies/nexthopState.h b/hicn-light/src/hicn/strategies/nexthopState.h
deleted file mode 100644
index 35a9f497b..000000000
--- a/hicn-light/src/hicn/strategies/nexthopState.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * 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 nexthopstate_h
-#define nexthopstate_h
-
-#include <parc/algol/parc_HashCode.h>
-#include <parc/algol/parc_Object.h>
-
-struct strategy_nexthop_state;
-typedef struct strategy_nexthop_state StrategyNexthopState;
-extern parcObjectDescriptor_Declaration(StrategyNexthopState);
-
-/**
- */
-StrategyNexthopState *strategyNexthopState_Acquire(
-    const StrategyNexthopState *instance);
-
-#ifdef PARCLibrary_DISABLE_VALIDATION
-#define strategyNexthopState_OptionalAssertValid(_instance_)
-#else
-#define strategyNexthopState_OptionalAssertValid(_instance_) \
-  strategyNexthopState_AssertValid(_instance_)
-#endif
-
-/**
- */
-void strategyNexthopState_AssertValid(const StrategyNexthopState *instance);
-
-/**
- */
-StrategyNexthopState *strategyNexthopState_Create();
-
-void strategyNexthopState_Reset(StrategyNexthopState *x);
-/**
- */
-int strategyNexthopState_Compare(const StrategyNexthopState *instance,
-                                 const StrategyNexthopState *other);
-
-/**
- */
-StrategyNexthopState *strategyNexthopState_Copy(
-    const StrategyNexthopState *original);
-
-/**
- */
-void strategyNexthopState_Display(const StrategyNexthopState *instance,
-                                  int indentation);
-
-/**
- */
-bool strategyNexthopState_Equals(const StrategyNexthopState *x,
-                                 const StrategyNexthopState *y);
-
-/**
- */
-PARCHashCode strategyNexthopState_HashCode(
-    const StrategyNexthopState *instance);
-
-/**
- */
-bool strategyNexthopState_IsValid(const StrategyNexthopState *instance);
-
-/**
- */
-void strategyNexthopState_Release(StrategyNexthopState **instancePtr);
-
-/**
- */
-char *strategyNexthopState_ToString(const StrategyNexthopState *instance);
-
-/**
- */
-unsigned strategyNexthopState_GetPI(const StrategyNexthopState *x);
-
-double strategyNexthopState_GetAvgPI(const StrategyNexthopState *x);
-
-double strategyNexthopState_GetWeight(const StrategyNexthopState *x);
-
-double strategyNexthopState_UpdateState(StrategyNexthopState *x, bool inc,
-                                        double alpha);
-#endif
diff --git a/hicn-light/src/hicn/strategies/nexthopStateLowLatency.c b/hicn-light/src/hicn/strategies/nexthopStateLowLatency.c
index a3953987f..3caed8130 100644
--- a/hicn-light/src/hicn/strategies/nexthopStateLowLatency.c
+++ b/hicn-light/src/hicn/strategies/nexthopStateLowLatency.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -24,303 +24,17 @@
 #include <parc/assert/parc_Assert.h>
 #include <hicn/strategies/nexthopStateLowLatency.h>
 
-const unsigned MAX_ROUNS_WITHOUT_PROBES = 4;
-        //if we do not receives probes for 4 rounds it means
-        //that we had no responce from any producer for 2 sec
-        //we can say that this interface is daed
-const unsigned MIN_NON_LOSSY_ROUNDS = 10;
-        //number of rounds in non lossy mode before switch to
-        //no lossy state
-const double MAX_LOSS_RATE = 0.10; //10%
-
-struct strategy_nexthop_state_ll {
-  bool in_use;
-  bool is_allowed; // the policy may not allow the use of this face
-  unsigned face_id;
-  unsigned sent_packets;
-  //switch metrics
-  unsigned last_try_to_switch_round;
-  unsigned try_to_switch_counter;
-  //probes counters
-  unsigned recevied_probes;
-  unsigned rounds_without_probes;
-  unsigned sent_probes;
-  unsigned lost_probes;
-  unsigned non_lossy_rounds;
-  //avgs
-  double avg_rtt;
-  double avg_rtt_in_use;
-  double avg_queue;
-  double avg_loss_rate;
-
-};
-
-static bool _strategyNexthopStateLL_Destructor(
-    StrategyNexthopStateLL **instancePtr) {
-  return true;
-}
-
-parcObject_ImplementAcquire(strategyNexthopStateLL, StrategyNexthopStateLL);
-
-parcObject_ImplementRelease(strategyNexthopStateLL, StrategyNexthopStateLL);
-
-parcObject_Override(
-    StrategyNexthopStateLL, PARCObject,
-    .destructor = (PARCObjectDestructor *)_strategyNexthopStateLL_Destructor,
-    .copy = (PARCObjectCopy *)strategyNexthopStateLL_Copy,
-    .display = (PARCObjectDisplay *)strategyNexthopStateLL_Display,
-    .toString = (PARCObjectToString *)strategyNexthopStateLL_ToString,
-    .equals = (PARCObjectEquals *)strategyNexthopStateLL_Equals,
-    .compare = (PARCObjectCompare *)strategyNexthopStateLL_Compare,
-    .hashCode = (PARCObjectHashCode *)strategyNexthopStateLL_HashCode,
-    .display = (PARCObjectDisplay *)strategyNexthopStateLL_Display);
-
-void strategyNexthopStateLL_AssertValid(const StrategyNexthopStateLL *instance) {
-  parcAssertTrue(strategyNexthopStateLL_IsValid(instance),
-                 "StrategyNexthopState is not valid.");
-}
-
-StrategyNexthopStateLL *strategyNexthopStateLL_Create(unsigned face_id) {
-  StrategyNexthopStateLL *result =
-      parcObject_CreateInstance(StrategyNexthopStateLL);
-  if (result != NULL) {
-    result->in_use = false;
-    result->is_allowed = true;
-    result->face_id = face_id;
-    result->sent_packets = 0;
-    result->last_try_to_switch_round = 0;
-    result->try_to_switch_counter = 0;
-    result->recevied_probes = 0;
-    result->rounds_without_probes = 0;
-    result->sent_probes = 0;
-    result->lost_probes = 0;
-    result->non_lossy_rounds = MIN_NON_LOSSY_ROUNDS;
-    result->avg_rtt = -1.0;
-    result->avg_rtt_in_use = -1.0;
-    result->avg_queue = 0.0001;
-    result->avg_loss_rate = 0.0;
-  }
-  return result;
-}
-
-void strategyNexthopStateLL_Reset(StrategyNexthopStateLL *x) {
-    x->in_use = false;
-    x->is_allowed = true;
-    x->sent_packets = 0;
-    x->last_try_to_switch_round = 0;
-    x->try_to_switch_counter = 0;
-    x->recevied_probes = 0;
-    x->rounds_without_probes = 0;
-    x->sent_probes = 0;
-    x->lost_probes = 0;
-    x->non_lossy_rounds = MIN_NON_LOSSY_ROUNDS;
-    x->avg_rtt = -1.0;
-    x->avg_rtt_in_use = -1.0;
-    x->avg_queue = 0.0001;
-    x->avg_loss_rate = 0.0;
-}
-
-
-int strategyNexthopStateLL_Compare(const StrategyNexthopStateLL *val,
-                                 const StrategyNexthopStateLL *other) {
-  if (val == NULL) {
-    if (other != NULL) {
-      return -1;
-    }
-  } else if (other == NULL) {
-    return 1;
-  } else {
-    strategyNexthopStateLL_OptionalAssertValid(val);
-    strategyNexthopStateLL_OptionalAssertValid(other);
-
-    if (val->in_use < other->in_use){
-      return -1;
-    }else if (val->in_use > other->in_use){
-      return 1;
-    }
-
-    if (val->is_allowed < other->is_allowed){
-      return -1;
-    }else if (val->is_allowed> other->is_allowed){
-      return 1;
-    }
-
-    if (val->face_id < other->face_id) {
-      return -1;
-    } else if (val->face_id > other->face_id) {
-      return 1;
-    }
-
-    if (val->sent_packets < other->sent_packets){
-      return -1;
-    } else if (val->sent_packets > other->sent_packets){
-      return 1;
-    }
-
-    if (val->last_try_to_switch_round <
-              other->last_try_to_switch_round) {
-      return -1;
-    } else if (val->last_try_to_switch_round >
-              other->last_try_to_switch_round) {
-      return 1;
-    }
-
-    if (val->try_to_switch_counter <
-                 other->try_to_switch_counter) {
-      return -1;
-    } else if (val->try_to_switch_counter >
-                 other->try_to_switch_counter) {
-      return 1;
-    }
-
-    if (val->recevied_probes < other->recevied_probes) {
-      return -1;
-    } else if (val->recevied_probes > other->recevied_probes) {
-      return 1;
-    }
-
-    if (val->rounds_without_probes < other->rounds_without_probes) {
-      return -1;
-    } else if (val->rounds_without_probes > other->rounds_without_probes) {
-      return 1;
-    }
-
-    if (val->sent_probes < other->sent_probes) {
-      return -1;
-    } else if (val->sent_probes > other->sent_probes) {
-      return 1;
-    }
-
-    if (val->lost_probes < other->lost_probes) {
-      return -1;
-    } else if (val->lost_probes > other->lost_probes) {
-      return 1;
-    }
-
-    if (val->non_lossy_rounds < other->non_lossy_rounds) {
-      return -1;
-    } else if (val->non_lossy_rounds > other->non_lossy_rounds) {
-      return 1;
-    }
-
-    if (val->avg_rtt < other->avg_rtt) {
-      return -1;
-    } else if (val->avg_rtt > other->avg_rtt) {
-      return 1;
-    }
-
-    if (val->avg_rtt_in_use < other->avg_rtt_in_use) {
-      return -1;
-    } else if (val->avg_rtt_in_use > other->avg_rtt_in_use) {
-      return 1;
-    }
-
-    if (val->avg_queue < other->avg_queue) {
-      return -1;
-    } else if (val->avg_queue > other->avg_queue) {
-      return 1;
-    }
-
-    if (val->avg_loss_rate < other->avg_loss_rate) {
-      return -1;
-    } else if (val->avg_loss_rate > other->avg_loss_rate) {
-      return 1;
-    }
-  }
-
-  return 0;
-}
-
-StrategyNexthopStateLL *strategyNexthopStateLL_Copy(
-    const StrategyNexthopStateLL *original) {
-  StrategyNexthopStateLL *result = strategyNexthopStateLL_Create(original->face_id);
-  result->in_use = original->in_use;
-  result->is_allowed = original->is_allowed;
-  result->sent_packets = original->sent_packets;
-  result->last_try_to_switch_round = original->last_try_to_switch_round;
-  result->try_to_switch_counter = original->try_to_switch_counter;
-  result->recevied_probes = original->recevied_probes;
-  result->rounds_without_probes = original->rounds_without_probes;
-  result->sent_probes = original->sent_probes;
-  result->lost_probes = original->lost_probes;
-  result->non_lossy_rounds = original->non_lossy_rounds;
-  result->avg_rtt = original->avg_rtt;
-  result->avg_rtt_in_use = original->avg_rtt_in_use;
-  result->avg_queue = original->avg_queue;
-  result->avg_loss_rate = original->avg_loss_rate;
-  return result;
-}
-
-void strategyNexthopStateLL_Display(const StrategyNexthopStateLL *instance,
-                                  int indentation) {
-  parcDisplayIndented_PrintLine(indentation, "StrategyNexthopStateLL@%p {",
-                                instance);
-  parcDisplayIndented_PrintLine(indentation + 1, "%d", instance->face_id);
-  parcDisplayIndented_PrintLine(indentation + 1, "%f", instance->avg_rtt);
-  parcDisplayIndented_PrintLine(indentation + 1, "%f", instance->avg_rtt_in_use);
-  parcDisplayIndented_PrintLine(indentation + 1, "%f", instance->avg_queue);
-  parcDisplayIndented_PrintLine(indentation + 1, "%f", instance->avg_loss_rate);
-  parcDisplayIndented_PrintLine(indentation, "}");
-}
-
-
-bool strategyNexthopStateLL_Equals(const StrategyNexthopStateLL *x,
-                                 const StrategyNexthopStateLL *y) {
-  bool result = false;
-
-  if (x == y) {
-    result = true;
-  } else if (x == NULL || y == NULL) {
-    result = false;
-  } else {
-    strategyNexthopStateLL_OptionalAssertValid(x);
-    strategyNexthopStateLL_OptionalAssertValid(y);
-
-    if (strategyNexthopStateLL_Compare(x, y) == 0) {
-      result = true;
-    }
-  }
-
-  return result;
-}
-
-PARCHashCode strategyNexthopStateLL_HashCode(const StrategyNexthopStateLL *x) {
-  PARCHashCode result = 0;
-  char str[128];
-  sprintf(str, "ID:%d: RTT:%f: RTTUSE:%f: Q:%f L:%f", x->face_id, x->avg_rtt,
-                            x->avg_rtt_in_use, x->avg_queue, x->avg_loss_rate);
-  result = parcHashCode_Hash((uint8_t *)&str, strlen(str));
-  return result;
-}
-
-bool strategyNexthopStateLL_IsValid(const StrategyNexthopStateLL *x) {
-  bool result = false;
-
-  if (x != NULL) {
-    result = true;
-  }
-
-  return result;
-}
-
-char *strategyNexthopStateLL_ToString(const StrategyNexthopStateLL *x) {
-  // this is not implemented
-  parcTrapNotImplemented("strategyNexthopStateLL_ToString is not implemented");
-  return NULL;
-}
-
 double strategyNexthopStateLL_GetRTTProbe(StrategyNexthopStateLL *x) {
   strategyNexthopStateLL_OptionalAssertValid(x);
 
-  if(x->rounds_without_probes > MAX_ROUNS_WITHOUT_PROBES)
-    return DBL_MAX;
+  if (x->rounds_without_probes > MAX_ROUNS_WITHOUT_PROBES) return DBL_MAX;
 
-  if(x->avg_rtt == -1.0){
-    if(x->avg_rtt_in_use == -1.0){
+  if (x->avg_rtt == -1.0) {
+    if (x->avg_rtt_in_use == -1.0) {
       return 0.0;
-    }else{
-      //this happens if the face recevied probes only in in_use mode
-      //we set the avf_rtt with rtt_in_use
+    } else {
+      // this happens if the face recevied probes only in in_use mode
+      // we set the avf_rtt with rtt_in_use
       x->avg_rtt = x->avg_rtt_in_use;
     }
   }
@@ -331,11 +45,9 @@ double strategyNexthopStateLL_GetRTTProbe(StrategyNexthopStateLL *x) {
 double strategyNexthopStateLL_GetRTTInUse(StrategyNexthopStateLL *x) {
   strategyNexthopStateLL_OptionalAssertValid(x);
 
-  if(x->rounds_without_probes > MAX_ROUNS_WITHOUT_PROBES)
-    return DBL_MAX;
+  if (x->rounds_without_probes > MAX_ROUNS_WITHOUT_PROBES) return DBL_MAX;
 
-  if(x->avg_rtt_in_use == -1.0)
-    return strategyNexthopStateLL_GetRTTProbe(x);
+  if (x->avg_rtt_in_use == -1.0) return strategyNexthopStateLL_GetRTTProbe(x);
 
   return x->avg_rtt_in_use;
 }
@@ -343,9 +55,9 @@ double strategyNexthopStateLL_GetRTTInUse(StrategyNexthopStateLL *x) {
 double strategyNexthopStateLL_GetRTTLive(StrategyNexthopStateLL *x) {
   strategyNexthopStateLL_OptionalAssertValid(x);
 
-  if(x->in_use){
+  if (x->in_use) {
     return strategyNexthopStateLL_GetRTTInUse(x);
-  }else{
+  } else {
     return strategyNexthopStateLL_GetRTTProbe(x);
   }
 }
@@ -353,46 +65,45 @@ double strategyNexthopStateLL_GetRTTLive(StrategyNexthopStateLL *x) {
 double strategyNexthopStateLL_GetQueuing(const StrategyNexthopStateLL *x) {
   strategyNexthopStateLL_OptionalAssertValid(x);
 
-  if(x->rounds_without_probes > MAX_ROUNS_WITHOUT_PROBES)
-    return 0.0;
+  if (x->rounds_without_probes > MAX_ROUNS_WITHOUT_PROBES) return 0.0;
 
   return x->avg_queue;
 }
 
 void strategyNexthopStateLL_AddRttSample(StrategyNexthopStateLL *x,
-                                                unsigned int rtt){
+                                         unsigned int rtt) {
   strategyNexthopStateLL_OptionalAssertValid(x);
 
   x->recevied_probes++;
-  //form uint to double
+  // form uint to double
   double drtt = rtt;
 
-  if(x->in_use){
-    if(x->avg_rtt_in_use == -1.0){
+  if (x->in_use) {
+    if (x->avg_rtt_in_use == -1.0) {
       x->avg_rtt_in_use = drtt;
-    }else{
+    } else {
       x->avg_rtt_in_use = (x->avg_rtt_in_use * 0.9) + (drtt * 0.1);
     }
-  }else{
-    if(x->avg_rtt == -1.0){
-       x->avg_rtt = drtt;
-    }else{
+  } else {
+    if (x->avg_rtt == -1.0) {
+      x->avg_rtt = drtt;
+    } else {
       x->avg_rtt = (x->avg_rtt * 0.9) + (drtt * 0.1);
     }
   }
 
-  if(x->avg_rtt_in_use == -1.0 || x->avg_rtt == -1.0){
+  if (x->avg_rtt_in_use == -1.0 || x->avg_rtt == -1.0) {
     x->avg_queue = 0.0001;
-  }else{
+  } else {
     double queue = x->avg_rtt_in_use - x->avg_rtt;
-    if(queue < 0){
+    if (queue < 0) {
       queue = 0.0001;
     }
     x->avg_queue = (x->avg_queue * 0.95) + (0.05 * queue);
   }
 }
 
-void strategyNexthopStateLL_SetUnusedFace(StrategyNexthopStateLL *x){
+void strategyNexthopStateLL_SetUnusedFace(StrategyNexthopStateLL *x) {
   strategyNexthopStateLL_OptionalAssertValid(x);
   x->in_use = false;
 }
@@ -403,75 +114,76 @@ unsigned strategyNexthopStateLL_GetFaceId(StrategyNexthopStateLL *x) {
 }
 
 void strategyNexthopStateLL_IncreaseTryToSwitch(StrategyNexthopStateLL *x,
-                                                      unsigned round){
-  if(x->try_to_switch_counter == 0 ||
-        round == (x->last_try_to_switch_round + 1)){
+                                                unsigned round) {
+  if (x->try_to_switch_counter == 0 ||
+      round == (x->last_try_to_switch_round + 1)) {
     x->last_try_to_switch_round = round;
     x->try_to_switch_counter++;
-  }else{
+  } else {
     x->try_to_switch_counter = 0;
   }
 }
 
-unsigned strategyNexthopStateLL_GetTryToSwitch(const StrategyNexthopStateLL *x){
+unsigned strategyNexthopStateLL_GetTryToSwitch(
+    const StrategyNexthopStateLL *x) {
   return x->try_to_switch_counter;
 }
 
-void strategyNexthopStateLL_ResetTryToSwitch(StrategyNexthopStateLL *x){
+void strategyNexthopStateLL_ResetTryToSwitch(StrategyNexthopStateLL *x) {
   x->try_to_switch_counter = 0;
 }
 
-void strategyNexthopStateLL_SendPacket(StrategyNexthopStateLL *x){
+void strategyNexthopStateLL_SendPacket(StrategyNexthopStateLL *x) {
   x->in_use = true;
   x->sent_packets++;
 }
 
-void strategyNexthopStateLL_SentProbe(StrategyNexthopStateLL *x){
+void strategyNexthopStateLL_SentProbe(StrategyNexthopStateLL *x) {
   x->sent_probes++;
 }
 
-void strategyNexthopStateLL_LostProbe(StrategyNexthopStateLL *x){
+void strategyNexthopStateLL_LostProbe(StrategyNexthopStateLL *x) {
   x->lost_probes++;
 }
 
-bool strategyNexthopStateLL_IsLossy(const StrategyNexthopStateLL *x){
-  if(x->non_lossy_rounds < 10 ||
-     x->avg_loss_rate > MAX_LOSS_RATE){
+bool strategyNexthopStateLL_IsLossy(const StrategyNexthopStateLL *x) {
+  if (x->non_lossy_rounds < 10 || x->avg_loss_rate > MAX_LOSS_RATE) {
     return true;
   }
   return false;
 }
 
-void strategyNexthopStateLL_SetIsAllowed(StrategyNexthopStateLL *x, bool allowed){
+void strategyNexthopStateLL_SetIsAllowed(StrategyNexthopStateLL *x,
+                                         bool allowed) {
   x->is_allowed = allowed;
 }
 
-bool strategyNexthopStateLL_IsAllowed(const StrategyNexthopStateLL *x){
+bool strategyNexthopStateLL_IsAllowed(const StrategyNexthopStateLL *x) {
   return x->is_allowed;
 }
 
-void strategyNexthopStateLL_StartNewRound(StrategyNexthopStateLL *x){
+void strategyNexthopStateLL_StartNewRound(StrategyNexthopStateLL *x) {
   strategyNexthopStateLL_OptionalAssertValid(x);
-  if(x->sent_packets == 0) //the face was not used in the last round
+  if (x->sent_packets == 0)  // the face was not used in the last round
     x->in_use = false;
 
   x->sent_packets = 0;
 
-  if(x->recevied_probes == 0){
+  if (x->recevied_probes == 0) {
     x->rounds_without_probes++;
-  }else{
+  } else {
     x->rounds_without_probes = 0;
   }
 
   x->recevied_probes = 0;
 
-  //compute losses in this round
-  if(x->sent_probes != 0){
-    double loss_rate = (double) x->lost_probes / (double) x->sent_probes;
+  // compute losses in this round
+  if (x->sent_probes != 0) {
+    double loss_rate = (double)x->lost_probes / (double)x->sent_probes;
     x->avg_loss_rate = x->avg_loss_rate * 0.7 + loss_rate * 0.3;
-    if(x->avg_loss_rate > MAX_LOSS_RATE){
+    if (x->avg_loss_rate > MAX_LOSS_RATE) {
       x->non_lossy_rounds = 0;
-    }else{
+    } else {
       x->non_lossy_rounds++;
     }
   }
diff --git a/hicn-light/src/hicn/strategies/nexthopStateLowLatency.h b/hicn-light/src/hicn/strategies/nexthopStateLowLatency.h
index 34dbb8262..7f4181d44 100644
--- a/hicn-light/src/hicn/strategies/nexthopStateLowLatency.h
+++ b/hicn-light/src/hicn/strategies/nexthopStateLowLatency.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -47,7 +47,7 @@ void strategyNexthopStateLL_Reset(StrategyNexthopStateLL *x);
 /**
  */
 int strategyNexthopStateLL_Compare(const StrategyNexthopStateLL *instance,
-                                 const StrategyNexthopStateLL *other);
+                                   const StrategyNexthopStateLL *other);
 
 /**
  */
@@ -57,12 +57,12 @@ StrategyNexthopStateLL *strategyNexthopStateLL_Copy(
 /**
  */
 void strategyNexthopStateLL_Display(const StrategyNexthopStateLL *instance,
-                                  int indentation);
+                                    int indentation);
 
 /**
  */
 bool strategyNexthopStateLL_Equals(const StrategyNexthopStateLL *x,
-                                 const StrategyNexthopStateLL *y);
+                                   const StrategyNexthopStateLL *y);
 
 /**
  */
@@ -88,11 +88,10 @@ double strategyNexthopStateLL_GetRTTInUse(StrategyNexthopStateLL *x);
 double strategyNexthopStateLL_GetRTTLive(StrategyNexthopStateLL *x);
 double strategyNexthopStateLL_GetQueuing(const StrategyNexthopStateLL *x);
 void strategyNexthopStateLL_AddRttSample(StrategyNexthopStateLL *x,
-                                                unsigned int rtt);
-
+                                         unsigned int rtt);
 
 void strategyNexthopStateLL_IncreaseTryToSwitch(StrategyNexthopStateLL *x,
-                                                      unsigned round);
+                                                unsigned round);
 unsigned strategyNexthopStateLL_GetTryToSwitch(const StrategyNexthopStateLL *x);
 void strategyNexthopStateLL_ResetTryToSwitch(StrategyNexthopStateLL *x);
 
@@ -108,7 +107,8 @@ void strategyNexthopStateLL_LostProbe(StrategyNexthopStateLL *x);
 
 bool strategyNexthopStateLL_IsLossy(const StrategyNexthopStateLL *x);
 
-void strategyNexthopStateLL_SetIsAllowed(StrategyNexthopStateLL *x, bool allowed);
+void strategyNexthopStateLL_SetIsAllowed(StrategyNexthopStateLL *x,
+                                         bool allowed);
 
 bool strategyNexthopStateLL_IsAllowed(const StrategyNexthopStateLL *x);
 
diff --git a/hicn-light/src/hicn/strategies/probe_generator.c b/hicn-light/src/hicn/strategies/probe_generator.c
new file mode 100644
index 000000000..439de0a12
--- /dev/null
+++ b/hicn-light/src/hicn/strategies/probe_generator.c
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "probe_generator.h"
+
+#include <hicn/core/forwarder.h>
+#include <hicn/core/nexthops.h>
+
+// map functions
+static void add_to_map(probe_generator_t *pg, unsigned seq, Ticks now) {
+  khiter_t k;
+  int ret;
+  k = kh_put_bp_map(pg->ticks_by_seq, seq, &ret);
+  kh_value(pg->ticks_by_seq, k) = now;
+}
+
+static Ticks get_from_map(probe_generator_t *pg, unsigned seq) {
+  khiter_t k;
+  k = kh_get_bp_map(pg->ticks_by_seq, seq);
+  if (k == kh_end(pg->ticks_by_seq)) return 0;
+  Ticks t = kh_value(pg->ticks_by_seq, k);
+  return t;
+}
+
+static void remove_from_map(probe_generator_t *pg, unsigned seq) {
+  khiter_t k;
+  k = kh_get_bp_map(pg->ticks_by_seq, seq);
+  if (k != kh_end(pg->ticks_by_seq)) kh_del_bp_map(pg->ticks_by_seq, k);
+}
+
+static void clear_map(probe_generator_t *pg) {
+  kh_clear(bp_map, pg->ticks_by_seq);
+}
+
+// seq number generator
+
+static uint32_t get_seq_number(probe_generator_t *pg) {
+  uint32_t seq = 0;
+  uint32_t try = 0;
+  while (try < 3) {  // try up to 3 times
+    seq =
+        (rand() % (MAX_PROBE_SUFFIX - MIN_PROBE_SUFFIX + 1)) + MIN_PROBE_SUFFIX;
+    Ticks time = get_from_map(pg, seq);
+    if (time == 0) return seq;  // seq does not exists
+    try++;
+  }
+  return 0;
+}
+
+// probing functions
+
+probe_generator_t *create_probe_generator() {
+  probe_generator_t *pg = calloc(1, sizeof(probe_generator_t));
+  if (!pg) return NULL;
+
+  pg->ticks_by_seq = kh_init_bp_map();
+  return pg;
+}
+
+void destroy_probe_generator(probe_generator_t *pg) {
+  kh_destroy_bp_map(pg->ticks_by_seq);
+  free(pg);
+}
+
+int generate_probe(probe_generator_t *pg, const msgbuf_t *msgbuf,
+                   const forwarder_t *forwarder, nexthop_t nexthop) {
+  msgbuf_pool_t *msgbuf_pool = forwarder_get_msgbuf_pool(forwarder);
+  connection_table_t *table = forwarder_get_connection_table(forwarder);
+  const connection_t *conn = connection_table_get_by_id(table, nexthop);
+  if (!conn) return -1;
+
+  msgbuf_t *probe;
+  off_t msg_id = msgbuf_pool_get_id(msgbuf_pool, (msgbuf_t *)msgbuf);
+  off_t probe_offset = msgbuf_pool_clone(msgbuf_pool, &probe, msg_id);
+
+  uint32_t seq = get_seq_number(pg);
+  if (seq == 0) return -1;
+
+  messageHandler_ModifySuffix(msgbuf_get_packet(probe), seq);
+  connection_send(conn, probe_offset, true);
+  connection_flush(conn);
+  add_to_map(pg, seq, ticks_now());
+  msgbuf_pool_put(msgbuf_pool, probe);
+
+  return 0;
+}
+
+Ticks register_probe(probe_generator_t *pg, unsigned seq) {
+  Ticks now = ticks_now();
+  add_to_map(pg, seq, now);
+  return now;
+}
+
+Ticks get_probe_send_time(probe_generator_t *pg, unsigned seq) {
+  return get_from_map(pg, seq);
+}
+
+void delete_probe(probe_generator_t *pg, unsigned seq) {
+  remove_from_map(pg, seq);
+}
+
+void delete_all_probes(probe_generator_t *pg) { clear_map(pg); }
diff --git a/hicn-light/src/hicn/strategies/probe_generator.h b/hicn-light/src/hicn/strategies/probe_generator.h
new file mode 100644
index 000000000..26d6a3a22
--- /dev/null
+++ b/hicn-light/src/hicn/strategies/probe_generator.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HICNLIGHT_PROBE_GENERATOR
+#define HICNLIGHT_PROBE_GENERATOR
+
+#include "../base/khash.h"
+#include <hicn/core/ticks.h>
+#include <hicn/core/msgbuf.h>
+
+KHASH_MAP_INIT_INT64(bp_map, Ticks);
+
+struct forwarder_s;
+
+typedef struct probe_generator {
+  kh_bp_map_t *ticks_by_seq;
+} probe_generator_t;
+
+probe_generator_t *create_probe_generator();
+
+void destroy_probe_generator(probe_generator_t *pg);
+
+int generate_probe(probe_generator_t *pg, const msgbuf_t *msgbuf,
+                   const struct forwarder_s *forwarder, unsigned nexthop);
+
+Ticks register_probe(probe_generator_t *pg, unsigned seq);
+
+Ticks get_probe_send_time(probe_generator_t *pg, unsigned seq);
+
+void delete_probe(probe_generator_t *pg, unsigned seq);
+
+void delete_all_probes(probe_generator_t *pg);
+
+#endif /* HICNLIGHT_PROBE_GENERATOR */
diff --git a/hicn-light/src/hicn/strategies/random.c b/hicn-light/src/hicn/strategies/random.c
new file mode 100644
index 000000000..5b076df7c
--- /dev/null
+++ b/hicn-light/src/hicn/strategies/random.c
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <hicn/hicn-light/config.h>
+
+#include <hicn/core/nexthops.h>
+#include <hicn/core/strategy.h>
+#include <hicn/core/strategy_vft.h>
+
+#include "random.h"
+
+static int strategy_random_initialize(strategy_entry_t *entry,
+                                      const void *forwarder) {
+  srand((unsigned int)time(NULL));
+  entry->forwarder = forwarder;
+  return 0;
+}
+
+static int strategy_random_finalize(strategy_entry_t *entry) {
+  /* Nothing to do */
+  return 0;
+}
+
+static int strategy_random_add_nexthop(strategy_entry_t *entry,
+                                       nexthops_t *nexthops, off_t offset) {
+  /* Nothing to do */
+  return 0;
+}
+
+static int strategy_random_remove_nexthop(strategy_entry_t *entry,
+                                          nexthops_t *nexthops, off_t offset) {
+  /* Nothing to do */
+  return 0;
+}
+
+static nexthops_t *strategy_random_lookup_nexthops(strategy_entry_t *entry,
+                                                   nexthops_t *nexthops,
+                                                   const msgbuf_t *msgbuf) {
+  nexthops_select(nexthops, rand() % nexthops_get_len(nexthops));
+  return nexthops;
+}
+
+static int strategy_random_on_data(strategy_entry_t *entry,
+                                   nexthops_t *nexthops,
+                                   const nexthops_t *data_nexthops,
+                                   const msgbuf_t *msgbuf,
+                                   Ticks pitEntryCreation, Ticks objReception) {
+  /* Nothing to do */
+  return 0;
+}
+
+static int strategy_random_on_timeout(strategy_entry_t *entry,
+                                      nexthops_t *nexthops,
+                                      const nexthops_t *timeout_nexthops) {
+  /* Nothing to do */
+  return 0;
+}
+
+DECLARE_STRATEGY(random);
diff --git a/hicn-light/src/hicn/config/controlRemovePunting.h b/hicn-light/src/hicn/strategies/random.h
index 858d6f969..bdea5e4dd 100644
--- a/hicn-light/src/hicn/config/controlRemovePunting.h
+++ b/hicn-light/src/hicn/strategies/random.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,14 +14,22 @@
  */
 
 /**
- * @file control_RemovePunting.h
- *
+ * Forward randomly
  */
 
-#ifndef Control_RemovePunting_h
-#define Control_RemovePunting_h
+#ifndef HICNLIGHT_STRATEGY_RANDOM_H
+#define HICNLIGHT_STRATEGY_RANDOM_H
+
+typedef struct {
+  void *_;
+} strategy_random_nexthop_state_t;
+
+typedef struct {
+  void *_;
+} strategy_random_state_t;
+
+typedef struct {
+  void *_;
+} strategy_random_options_t;
 
-#include <hicn/config/controlState.h>
-CommandOps *controlRemovePunting_Create(ControlState *state);
-CommandOps *controlRemovePunting_HelpCreate(ControlState *state);
-#endif  // Control_RemovePunting_h
+#endif /* HICNLIGHT_STRATEGY_RANDOM_H */
diff --git a/hicn-light/src/hicn/strategies/replication.c b/hicn-light/src/hicn/strategies/replication.c
new file mode 100644
index 000000000..86a3e3431
--- /dev/null
+++ b/hicn-light/src/hicn/strategies/replication.c
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <hicn/hicn-light/config.h>
+
+#include <hicn/core/nexthops.h>
+#include <hicn/core/strategy.h>
+#include <hicn/core/strategy_vft.h>
+
+#include "replication.h"
+
+/* Shorthand */
+#define strategy_state_t strategy_replication_state_t
+
+static int strategy_replication_initialize(strategy_entry_t *entry,
+                                           const void *forwarder) {
+  entry->forwarder = forwarder;
+  strategy_state_t *state = &entry->state.replication;
+  state->prev_nexthops = malloc(sizeof(nexthops_t));
+  *((nexthops_t *)state->prev_nexthops) = NEXTHOPS_EMPTY;
+  return 0;
+}
+
+static int strategy_replication_finalize(strategy_entry_t *entry) {
+  /* Nothing to do */
+  strategy_state_t *state = &entry->state.replication;
+  free(state->prev_nexthops);
+  return 0;
+}
+
+static int strategy_replication_add_nexthop(strategy_entry_t *entry,
+                                            nexthops_t *nexthops,
+                                            off_t offset) {
+  /* Nothing to do */
+  return 0;
+}
+
+static int strategy_replication_remove_nexthop(strategy_entry_t *entry,
+                                               nexthops_t *nexthops,
+                                               off_t offset) {
+  /* Nothing to do */
+  return 0;
+}
+
+static nexthops_t *strategy_replication_lookup_nexthops(
+    strategy_entry_t *entry, nexthops_t *nexthops, const msgbuf_t *msgbuf) {
+  // if nexthops is different from prev_nexthops send updates
+  strategy_state_t *state = &entry->state.replication;
+
+  if (!nexthops_equal((nexthops_t *)state->prev_nexthops, nexthops)) {
+    // send updates
+    strategy_replication_options_t *options = &entry->options.replication;
+    update_remote_node_paths(nexthops, entry->forwarder,
+                             options->local_prefixes);
+
+    // update next hops
+    nexthops_copy(nexthops, (nexthops_t *)state->prev_nexthops);
+  }
+
+  // Return all next hops
+  return nexthops;
+}
+
+static int strategy_replication_on_data(strategy_entry_t *entry,
+                                        nexthops_t *nexthops,
+                                        const nexthops_t *data_nexthops,
+                                        const msgbuf_t *msgbuf,
+                                        Ticks pitEntryCreation,
+                                        Ticks objReception) {
+  /* Nothing to do */
+  return 0;
+}
+
+static int strategy_replication_on_timeout(strategy_entry_t *entry,
+                                           nexthops_t *nexthops,
+                                           const nexthops_t *timeout_nexthops) {
+  /* Nothing to do */
+  return 0;
+}
+
+DECLARE_STRATEGY(replication);
diff --git a/hicn-light/src/hicn/config/controlAddPolicy.h b/hicn-light/src/hicn/strategies/replication.h
index 273e3a476..753ae4744 100644
--- a/hicn-light/src/hicn/config/controlAddPolicy.h
+++ b/hicn-light/src/hicn/strategies/replication.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,22 +14,24 @@
  */
 
 /**
- * @file control_AddPolicy.h
- * @brief Add a static policy
- *
- * Implements the "add policy" node of the CLI tree
- *
+ * Forward replication of the interest on all the paths
  */
 
-#ifndef Control_AddPolicy_h
-#define Control_AddPolicy_h
+#ifndef HICNLIGHT_STRATEGY_REPLICATION_H
+#define HICNLIGHT_STRATEGY_REPLICATION_H
+
+#include "local_prefixes.h"
 
-#ifdef WITH_POLICY
+typedef struct {
+  void *_;
+} strategy_replication_nexthop_state_t;
 
-#include <hicn/config/controlState.h>
-CommandOps *controlAddPolicy_Create(ControlState *state);
-CommandOps *controlAddPolicy_HelpCreate(ControlState *state);
+typedef struct {
+  void *prev_nexthops;
+} strategy_replication_state_t;
 
-#endif /* WITH_POLICY */
+typedef struct {
+  local_prefixes_t *local_prefixes;
+} strategy_replication_options_t;
 
-#endif  // Control_AddPolicy_h
+#endif /* HICNLIGHT_STRATEGY_REPLICATION_H */
diff --git a/hicn-light/src/hicn/strategies/rnd.c b/hicn-light/src/hicn/strategies/rnd.c
deleted file mode 100644
index 064f3965b..000000000
--- a/hicn-light/src/hicn/strategies/rnd.c
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <parc/algol/parc_HashMap.h>
-#include <parc/algol/parc_Memory.h>
-
-#include <hicn/strategies/rnd.h>
-
-static void _strategyRnd_ReceiveObject(StrategyImpl *strategy,
-                                       const NumberSet *egressId,
-                                       const Message *objectMessage,
-                                       Ticks pitEntryCreation,
-                                       Ticks objReception);
-static void _strategyRnd_OnTimeout(StrategyImpl *strategy,
-                                   const NumberSet *egressId);
-
-static NumberSet *_strategyRnd_LookupNexthop(StrategyImpl *strategy,
-#ifdef WITH_POLICY
-    NumberSet * nexthops,
-#endif /* WITH_POLICY */
-    const Message *interestMessage);
-#ifndef WITH_POLICY
-static NumberSet *_strategyRnd_ReturnNexthops(StrategyImpl *strategy);
-static unsigned _strategyRnd_CountNexthops(StrategyImpl *strategy);
-#endif /* ! WITH_POLICY */
-static void _strategyRnd_AddNexthop(StrategyImpl *strategy,
-                                    unsigned connectionId);
-static void _strategyRnd_RemoveNexthop(StrategyImpl *strategy,
-                                       unsigned connectionId);
-static void _strategyRnd_ImplDestroy(StrategyImpl **strategyPtr);
-static strategy_type _strategyRnd_GetStrategy(StrategyImpl *strategy);
-
-static StrategyImpl _template = {
-    .context = NULL,
-    .receiveObject = &_strategyRnd_ReceiveObject,
-    .onTimeout = &_strategyRnd_OnTimeout,
-    .lookupNexthop = &_strategyRnd_LookupNexthop,
-#ifndef WITH_POLICY
-    .returnNexthops = &_strategyRnd_ReturnNexthops,
-    .countNexthops = &_strategyRnd_CountNexthops,
-#endif /* ! WITH_POLICY */
-    .addNexthop = &_strategyRnd_AddNexthop,
-    .removeNexthop = &_strategyRnd_RemoveNexthop,
-    .destroy = &_strategyRnd_ImplDestroy,
-    .getStrategy = &_strategyRnd_GetStrategy,
-};
-
-#ifndef WITH_POLICY
-struct strategy_rnd;
-typedef struct strategy_rnd StrategyRnd;
-
-struct strategy_rnd {
-  NumberSet *nexthops;
-};
-#endif /* ! WITH_POLICY */
-
-StrategyImpl *strategyRnd_Create() {
-#ifndef WITH_POLICY
-  StrategyRnd *strategy = parcMemory_AllocateAndClear(sizeof(StrategyRnd));
-  parcAssertNotNull(strategy, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(StrategyRnd));
-
-  strategy->nexthops = numberSet_Create();
-#endif /* ! WITH_POLICY */
-  srand((unsigned int)time(NULL));
-
-  StrategyImpl *impl = parcMemory_AllocateAndClear(sizeof(StrategyImpl));
-  parcAssertNotNull(impl, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(StrategyImpl));
-  memcpy(impl, &_template, sizeof(StrategyImpl));
-#ifndef WITH_POLICY
-  impl->context = strategy;
-#endif /* ! WITH_POLICY */
-  return impl;
-}
-
-// =======================================================
-// Dispatch API
-
-strategy_type _strategyRnd_GetStrategy(StrategyImpl *strategy) {
-  return SET_STRATEGY_RANDOM;
-}
-
-#ifndef WITH_POLICY
-static int _select_Nexthop(StrategyRnd *strategy) {
-  unsigned len = (unsigned)numberSet_Length(strategy->nexthops);
-  if (len == 0) {
-    return -1;
-  }
-
-  int rnd = (rand() % len);
-  return numberSet_GetItem(strategy->nexthops, rnd);
-}
-#endif /* ! WITH_POLICY */
-
-static void _strategyRnd_ReceiveObject(StrategyImpl *strategy,
-                                       const NumberSet *egressId,
-                                       const Message *objectMessage,
-                                       Ticks pitEntryCreation,
-                                       Ticks objReception) {}
-
-static void _strategyRnd_OnTimeout(StrategyImpl *strategy,
-                                   const NumberSet *egressId) {}
-
-static NumberSet *_strategyRnd_LookupNexthop(StrategyImpl *strategy,
-#ifdef WITH_POLICY
-        NumberSet * nexthops,
-#endif /* WITH_POLICY */
-        const Message *interestMessage) {
-  unsigned out_connection;
-  NumberSet *out = numberSet_Create();
-
-#ifdef WITH_POLICY
-  // We return one next hop at random
-  out_connection = numberSet_GetItem(nexthops, rand() % numberSet_Length(nexthops));
-
-#else
-  StrategyRnd *srnd = (StrategyRnd *)strategy->context;
-  unsigned in_connection = message_GetIngressConnectionId(interestMessage);
-  unsigned nexthopSize = (unsigned)numberSet_Length(srnd->nexthops);
-
-  if ((nexthopSize == 0) ||
-      ((nexthopSize == 1) &&
-       numberSet_Contains(srnd->nexthops, in_connection))) {
-    // there are no output faces or the input face is also the only output face.
-    // return null to avoid loops
-    return out;
-  }
-
-  do {
-    out_connection = _select_Nexthop(srnd);
-  } while (out_connection == in_connection);
-
-  if (out_connection == -1) {
-    return out;
-  }
-#endif /* WITH_POLICY */
-
-  numberSet_Add(out, out_connection);
-  return out;
-}
-
-#ifndef WITH_POLICY
-static NumberSet *_strategyRnd_ReturnNexthops(StrategyImpl *strategy) {
-  StrategyRnd *srnd = (StrategyRnd *)strategy->context;
-  return srnd->nexthops;
-}
-
-unsigned _strategyRnd_CountNexthops(StrategyImpl *strategy) {
-  StrategyRnd *srnd = (StrategyRnd *)strategy->context;
-  return (unsigned)numberSet_Length(srnd->nexthops);
-}
-#endif /* ! WITH_POLICY */
-
-static void _strategyRnd_AddNexthop(StrategyImpl *strategy,
-                                    unsigned connectionId) {
-#ifndef WITH_POLICY
-  StrategyRnd *srnd = (StrategyRnd *)strategy->context;
-  if (!numberSet_Contains(srnd->nexthops, connectionId)) {
-    numberSet_Add(srnd->nexthops, connectionId);
-  }
-#endif /* ! WITH_POLICY */
-}
-
-static void _strategyRnd_RemoveNexthop(StrategyImpl *strategy,
-                                       unsigned connectionId) {
-#ifndef WITH_POLICY
-  StrategyRnd *srnd = (StrategyRnd *)strategy->context;
-
-  if (numberSet_Contains(srnd->nexthops, connectionId)) {
-    numberSet_Remove(srnd->nexthops, connectionId);
-  }
-#endif /* ! WITH_POLICY */
-}
-
-static void _strategyRnd_ImplDestroy(StrategyImpl **strategyPtr) {
-  parcAssertNotNull(strategyPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*strategyPtr,
-                    "Parameter must dereference to non-null pointer");
-
-  StrategyImpl *impl = *strategyPtr;
-
-#ifndef WITH_POLICY
-  StrategyRnd *strategy = (StrategyRnd *)impl->context;
-  numberSet_Release(&(strategy->nexthops));
-  parcMemory_Deallocate((void **)&strategy);
-#endif /* ! WITH_POLICY */
-
-  parcMemory_Deallocate((void **)&impl);
-  *strategyPtr = NULL;
-}
diff --git a/hicn-light/src/hicn/strategies/strategyImpl.h b/hicn-light/src/hicn/strategies/strategyImpl.h
deleted file mode 100644
index 140da5bf8..000000000
--- a/hicn-light/src/hicn/strategies/strategyImpl.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * 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 strategyImpl.h
- * @brief Defines the function structure for a Strategy implementation
- *
- * <#Detailed Description#>
- *
- */
-
-/**
- * A dispatch structure for a concrete implementation of a forwarding strategy.
- */
-
-#ifndef strategyImpl_h
-#define strategyImpl_h
-
-#include <hicn/core/message.h>
-#include <hicn/core/numberSet.h>
-
-struct strategy_impl;
-typedef struct strategy_impl StrategyImpl;
-
-/**
- * @typedef StrategyImpl
- * @abstract Forwarding strategy implementation
- * @constant receiveObject is called when we receive an object and have a
- * measured round trip time.  This allows a strategy to update its performance
- * data.
- * @constant lookupNexthop Find the set of nexthops to use for the Interest.
- *           May be empty, should not be NULL.  Must be destroyed.
- * @constant addNexthop Add a nexthop to the list of available nexthops with a
- * routing protocol-specific cost.
- * @constant destroy cleans up the strategy, freeing all memory and state.  A
- * strategy is reference counted, so the final destruction only happens after
- * the last reference is released.
- * @discussion <#Discussion#>
- */
-struct strategy_impl {
-  void *context;
-  void (*receiveObject)(StrategyImpl *strategy, const NumberSet *egressId,
-                        const Message *objectMessage, Ticks pitEntryCreation,
-                        Ticks objReception);
-  void (*onTimeout)(StrategyImpl *strategy, const NumberSet *egressId);
-  NumberSet *(*lookupNexthop)(StrategyImpl *strategy,
-#ifdef WITH_POLICY
-    NumberSet * nexthops,
-#endif /* WITH_POLICY */
-                              const Message *interestMessage);
-#ifndef WITH_POLICY
-  NumberSet *(*returnNexthops)(StrategyImpl *strategy);
-  unsigned (*countNexthops)(StrategyImpl *strategy);
-#endif /* ! WITH_POLICY */
-  void (*addNexthop)(StrategyImpl *strategy, unsigned connectionId);
-  void (*removeNexthop)(StrategyImpl *strategy, unsigned connectionId);
-  void (*destroy)(StrategyImpl **strategyPtr);
-  strategy_type (*getStrategy)(StrategyImpl *strategy);
-};
-
-#endif  // strategyImpl_h
diff --git a/hicn-light/src/hicn/test/CMakeLists.txt b/hicn-light/src/hicn/test/CMakeLists.txt
new file mode 100644
index 000000000..0ded4253d
--- /dev/null
+++ b/hicn-light/src/hicn/test/CMakeLists.txt
@@ -0,0 +1,43 @@
+# Copyright (c) 2021 Cisco and/or its affiliates.
+
+include(BuildMacros)
+
+list(APPEND TESTS_SRC
+  test-bitmap.cc
+  test-configuration.cc
+  test-hash.cc
+  test-khash.cc
+  test-loop.cc
+  test-pool.cc
+  test-parser.cc
+  test-ctrl.cc
+  test-ring.cc
+  test-vector.cc
+  test-msgbuf_pool.cc
+  test-nexthops.cc
+  test-connection_table.cc
+  test-listener_table.cc
+  test-packet_cache.cc
+  test-strategy-load-balancing.cc
+  test-strategy-random.cc
+  test-strategy-replication.cc
+  test-strategy-best-path.cc
+  test-subscription.cc
+  test-local_prefixes.cc
+  test-probe_generator.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/../config/command_listener.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/../config/command_route.c
+  main.cc
+)
+
+build_executable(hicn_light_tests
+    NO_INSTALL
+    SOURCES ${TESTS_SRC}
+    LINK_LIBRARIES ${LIBHICN_LIGHT_STATIC} ${GTEST_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
+    INCLUDE_DIRS ${HICN_LIGHT_INCLUDE_DIRS} ${GTEST_INCLUDE_DIRS}
+    DEPENDS gtest ${LIBHICNCTRL_STATIC} ${LIBHICN_LIGHT_SHARED}
+    COMPONENT ${HICN_LIGHT}
+    DEFINITIONS "${COMPILER_DEFINITIONS}"
+)
+
+add_test_internal(hicn_light_tests)
diff --git a/hicn-light/src/hicn/strategies/loadBalancer.h b/hicn-light/src/hicn/test/main.cc
index 74920768d..49cc28f66 100644
--- a/hicn-light/src/hicn/strategies/loadBalancer.h
+++ b/hicn-light/src/hicn/test/main.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,15 +13,9 @@
  * limitations under the License.
  */
 
-/**
- * Forward on the less loaded path
- */
-
-#ifndef loadBalancer_h
-#define loadBalancer_h
-
-#include <hicn/strategies/strategyImpl.h>
-
-StrategyImpl *strategyLoadBalancer_Create();
+#include <gtest/gtest.h>
 
-#endif  // loadBalancer_h
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/hicn-light/src/hicn/test/test-bitmap.cc b/hicn-light/src/hicn/test/test-bitmap.cc
new file mode 100644
index 000000000..f1bf1ae5a
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-bitmap.cc
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <netinet/in.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/base/bitmap.h>
+}
+
+#define DEFAULT_SIZE 10
+
+class BitmapTest : public ::testing::Test {
+ protected:
+  BitmapTest() {}
+
+  virtual ~BitmapTest() {}
+
+  bitmap_t* bitmap;
+};
+
+/*
+ * TEST: bitmap allocation
+ */
+TEST_F(BitmapTest, BitmapAllocation) {
+  int rc;
+
+  /*
+   * We take a value < 32 on purpose to avoid confusion on the choice of a 32
+   * or 64 bit integer for storage
+   */
+  size_t size_not_pow2 = DEFAULT_SIZE;
+  bitmap_init(bitmap, size_not_pow2, 0);
+
+  /*
+   * Bitmap should have been allocated with a size rounded to the next power
+   * of 2
+   */
+  EXPECT_EQ(bitmap_get_alloc_size(bitmap), 1UL);
+
+  /* By default, no element should be set */
+  EXPECT_FALSE(bitmap_is_set(bitmap, 0));
+  EXPECT_TRUE(bitmap_is_unset(bitmap, 0));
+
+  EXPECT_EQ(bitmap_get_alloc_size(bitmap), 1UL);
+
+  EXPECT_FALSE(bitmap_is_set(bitmap, size_not_pow2 - 1));
+  EXPECT_TRUE(bitmap_is_unset(bitmap, size_not_pow2 - 1));
+
+  /* Bitmap should not have been reallocated */
+  EXPECT_EQ(bitmap_get_alloc_size(bitmap), 1UL);
+
+  /* After setting a bit after the end, bitmap should have been reallocated */
+  bitmap_set(bitmap, sizeof(bitmap[0]) * 8 - 1);
+  EXPECT_EQ(bitmap_get_alloc_size(bitmap), 1UL);
+
+  /* After setting a bit after the end, bitmap should have been reallocated */
+  rc = bitmap_set(bitmap, sizeof(bitmap[0]) * 8);
+  EXPECT_GE(rc, 0);
+  EXPECT_EQ(bitmap_get_alloc_size(bitmap), 2UL);
+
+  rc = bitmap_set(bitmap, sizeof(bitmap[0]) * 8 + 1);
+  EXPECT_GE(rc, 0);
+  EXPECT_EQ(bitmap_get_alloc_size(bitmap), 2UL);
+
+  bitmap_free(bitmap);
+
+  size_t size_pow2 = 16;
+
+  /* Limiting test for allocation size */
+  bitmap_init(bitmap, size_pow2, 0);
+  EXPECT_EQ(bitmap_get_alloc_size(bitmap), 1UL);
+
+  bitmap_free(bitmap);
+}
+
+TEST_F(BitmapTest, BitmapSet) {
+  bitmap_init(bitmap, DEFAULT_SIZE, 0);
+
+  bitmap_set(bitmap, 20);
+  EXPECT_TRUE(bitmap_is_set(bitmap, 20));
+  EXPECT_FALSE(bitmap_is_unset(bitmap, 20));
+  EXPECT_FALSE(bitmap_is_set(bitmap, 19));
+  EXPECT_TRUE(bitmap_is_unset(bitmap, 19));
+
+  bitmap_free(bitmap);
+}
+
+TEST_F(BitmapTest, BitmapUnSet) {
+  bitmap_init(bitmap, DEFAULT_SIZE, 0);
+
+  bitmap_set(bitmap, 20);
+  bitmap_set(bitmap, 19);
+  bitmap_unset(bitmap, 20);
+  EXPECT_FALSE(bitmap_is_set(bitmap, 20));
+  EXPECT_TRUE(bitmap_is_unset(bitmap, 20));
+  EXPECT_TRUE(bitmap_is_set(bitmap, 19));
+  EXPECT_FALSE(bitmap_is_unset(bitmap, 19));
+
+  bitmap_free(bitmap);
+}
+
+TEST_F(BitmapTest, BitmapSetTo) {
+  bitmap_init(bitmap, DEFAULT_SIZE, 0);
+
+  bitmap_set_to(bitmap, 40);
+  EXPECT_TRUE(bitmap_is_set(bitmap, 20));
+  EXPECT_TRUE(bitmap_is_set(bitmap, 21));
+  EXPECT_TRUE(bitmap_is_unset(bitmap, 41));
+  EXPECT_TRUE(bitmap_is_unset(bitmap, 42));
+
+  bitmap_free(bitmap);
+}
diff --git a/hicn-light/src/hicn/test/test-configuration.cc b/hicn-light/src/hicn/test/test-configuration.cc
new file mode 100644
index 000000000..b631bb20b
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-configuration.cc
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ */
+
+#include <gtest/gtest.h>
+
+extern "C" {
+#include <hicn/config/configuration.h>
+}
+
+static inline size_t CS_SIZE = 10;
+static inline char CONFIG_FILE[] = "setup.conf";
+static inline int LOG_LEVEL = LOG_DEBUG;
+static inline char LOG_FILE[] = "/dev/null";
+static inline uint16_t PORT = 1234;
+static inline uint16_t CONF_PORT = 5678;
+static inline bool IS_DAEMON_MODE = true;
+static inline char PREFIX[] = "b001::/16";
+static inline char PREFIX_2[] = "c001::/16";
+static inline strategy_type_t STRATEGY_TYPE = STRATEGY_TYPE_BESTPATH;
+
+class ConfigurationTest : public ::testing::Test {
+ protected:
+  ConfigurationTest() {
+    config = configuration_create();
+    log_conf.log_level = LOG_FATAL;
+    log_conf.log_file = NULL;
+  }
+  virtual ~ConfigurationTest() { configuration_free(config); }
+
+  configuration_t *config;
+};
+
+TEST_F(ConfigurationTest, CreateConfiguration) {
+  // Check configuration creation
+  ASSERT_NE(config, nullptr);
+}
+
+TEST_F(ConfigurationTest, SetGeneralParameters) {
+  configuration_set_cs_size(config, CS_SIZE);
+  size_t cs_size = configuration_get_cs_size(config);
+  EXPECT_EQ(cs_size, CS_SIZE);
+
+  configuration_set_fn_config(config, CONFIG_FILE);
+  const char *config_file = configuration_get_fn_config(config);
+  EXPECT_EQ(config_file, CONFIG_FILE);
+
+  configuration_set_port(config, PORT);
+  uint16_t port = configuration_get_port(config);
+  EXPECT_EQ(port, PORT);
+
+  configuration_set_configuration_port(config, CONF_PORT);
+  uint16_t conf_port = configuration_get_configuration_port(config);
+  EXPECT_EQ(conf_port, CONF_PORT);
+
+  configuration_set_daemon(config, IS_DAEMON_MODE);
+  bool is_daemon_mode = configuration_get_daemon(config);
+  EXPECT_EQ(is_daemon_mode, IS_DAEMON_MODE);
+}
+
+TEST_F(ConfigurationTest, SetLogParameters) {
+  configuration_set_loglevel(config, LOG_LEVEL);
+  int log_level = configuration_get_loglevel(config);
+  EXPECT_EQ(log_level, LOG_LEVEL);
+  EXPECT_EQ(log_conf.log_level, LOG_LEVEL);
+
+  configuration_set_logfile(config, LOG_FILE);
+  const char *log_file = configuration_get_logfile(config);
+  EXPECT_EQ(log_file, LOG_FILE);
+  int write_fd = configuration_get_logfile_fd(config);
+  EXPECT_NE(write_fd, -1);
+}
+
+TEST_F(ConfigurationTest, SetStrategyParameter) {
+  configuration_set_strategy(config, PREFIX, STRATEGY_TYPE);
+  strategy_type_t strategy_type = configuration_get_strategy(config, PREFIX);
+  EXPECT_EQ(strategy_type, STRATEGY_TYPE);
+
+  // Check strategy for non-registered prefix
+  strategy_type = configuration_get_strategy(config, PREFIX_2);
+  EXPECT_EQ(strategy_type, STRATEGY_TYPE_UNDEFINED);
+}
diff --git a/hicn-light/src/hicn/test/test-connection_table.cc b/hicn-light/src/hicn/test/test-connection_table.cc
new file mode 100644
index 000000000..6bbf478e2
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-connection_table.cc
@@ -0,0 +1,250 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <netinet/in.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/core/connection_table.h>
+}
+
+#define CONNECTION_NAME "connection_name_test"
+#define CONNECTION_NAME_2 "connection_name_test_2"
+
+class ConnectionTableTest : public ::testing::Test {
+ protected:
+  ConnectionTableTest() {
+    log_conf.log_level = LOG_INFO;
+
+    conn_table_ = connection_table_create();
+    pair_ =
+        address_pair_factory(_ADDRESS4_LOCALHOST(1), _ADDRESS4_LOCALHOST(2));
+  }
+  virtual ~ConnectionTableTest() { connection_table_free(conn_table_); }
+
+  connection_table_t *conn_table_;
+  connection_t *connection_;
+  address_pair_t pair_;
+};
+
+TEST_F(ConnectionTableTest, CreateTable) {
+  /* Check connection_table allocation */
+  EXPECT_NE(conn_table_, nullptr);
+
+  /* Check connection_table size */
+  size_t conn_table_size = connection_table_len(conn_table_);
+  EXPECT_EQ(conn_table_size, (size_t)0);
+}
+
+TEST_F(ConnectionTableTest, AddConnection) {
+  // Add connection to connection table
+  connection_ = connection_table_allocate(conn_table_, &pair_, CONNECTION_NAME);
+  connection_->type = FACE_TYPE_TCP;
+
+  size_t conn_table_size = connection_table_len(conn_table_);
+  EXPECT_EQ(conn_table_size, (size_t)1);
+  EXPECT_NE(connection_, nullptr);
+
+  // Get connection by name and by pair
+  khiter_t k_name = kh_get_ct_name(conn_table_->id_by_name, CONNECTION_NAME);
+  EXPECT_NE(k_name, kh_end(conn_table_->id_by_name));
+  khiter_t k_pair = kh_get_ct_pair(conn_table_->id_by_pair, &pair_);
+  EXPECT_NE(k_pair, kh_end(conn_table_->id_by_pair));
+}
+
+TEST_F(ConnectionTableTest, GetConnection) {
+  // Add connection to connection table
+  connection_ = connection_table_allocate(conn_table_, &pair_, CONNECTION_NAME);
+  connection_->type = FACE_TYPE_TCP;
+
+  size_t conn_table_size = connection_table_len(conn_table_);
+  EXPECT_EQ(conn_table_size, (size_t)1);
+  EXPECT_NE(connection_, nullptr);
+
+  // Get connection by name
+  connection_t *connection_retrieved =
+      connection_table_get_by_name(conn_table_, CONNECTION_NAME);
+  ASSERT_NE(connection_retrieved, nullptr);
+  EXPECT_EQ(connection_retrieved, connection_);
+
+  // Get connection by pair
+  connection_retrieved = connection_table_get_by_pair(conn_table_, &pair_);
+  ASSERT_NE(connection_retrieved, nullptr);
+  EXPECT_EQ(connection_retrieved, connection_);
+}
+
+TEST_F(ConnectionTableTest, GetConnectionWithIdOutOfRange) {
+  connection_t *connection = _connection_table_get_by_id(conn_table_, ~0);
+  EXPECT_EQ(connection, nullptr);
+}
+
+TEST_F(ConnectionTableTest, GetConnectionWithInvalidId) {
+  // First connection inserted has always id equal to 0
+  int non_valid_id = 5;
+
+  connection_ = connection_table_allocate(conn_table_, &pair_, CONNECTION_NAME);
+  connection_->type = FACE_TYPE_TCP;
+
+  connection_t *connection_not_found =
+      connection_table_get_by_id(conn_table_, non_valid_id);
+  ASSERT_EQ(connection_not_found, nullptr);
+}
+
+TEST_F(ConnectionTableTest, GetConnectionWithValidId) {
+  connection_ = connection_table_allocate(conn_table_, &pair_, CONNECTION_NAME);
+  connection_->type = FACE_TYPE_TCP;
+
+  int id = connection_table_get_connection_id(conn_table_, connection_);
+  connection_t *connection_found = connection_table_get_by_id(conn_table_, id);
+  ASSERT_EQ(connection_found, connection_);
+}
+
+TEST_F(ConnectionTableTest, GetConnectionIdFromValidName) {
+  connection_ = connection_table_allocate(conn_table_, &pair_, CONNECTION_NAME);
+  connection_->type = FACE_TYPE_TCP;
+
+  int id = connection_table_get_id_by_name(conn_table_, CONNECTION_NAME);
+  ASSERT_TRUE(listener_id_is_valid(id));
+}
+
+TEST_F(ConnectionTableTest, GetConnectionIdFromInvalidName) {
+  connection_ = connection_table_allocate(conn_table_, &pair_, CONNECTION_NAME);
+  connection_->type = FACE_TYPE_TCP;
+
+  int id = connection_table_get_id_by_name(conn_table_, CONNECTION_NAME_2);
+  ASSERT_FALSE(listener_id_is_valid(id));
+}
+
+TEST_F(ConnectionTableTest, RemoveConnection) {
+  // Add connection (connection name and pair must be set)
+  connection_ = connection_table_allocate(conn_table_, &pair_, CONNECTION_NAME);
+  connection_->type = FACE_TYPE_TCP;
+
+  connection_->name = (char *)CONNECTION_NAME;
+  connection_->pair = pair_;
+
+  // Remove connection
+  int id = connection_table_get_connection_id(conn_table_, connection_);
+  connection_table_remove_by_id(conn_table_, id);
+
+  // Check connection table size
+  size_t conn_table_size = connection_table_len(conn_table_);
+  EXPECT_EQ(conn_table_size, (size_t)0);
+
+  // Check that previous connection is not valid anymore
+  connection_t *connection_not_found =
+      connection_table_get_by_id(conn_table_, id);
+  EXPECT_EQ(connection_not_found, nullptr);
+  connection_not_found =
+      connection_table_get_by_name(conn_table_, CONNECTION_NAME);
+  EXPECT_EQ(connection_not_found, nullptr);
+  connection_not_found = connection_table_get_by_pair(conn_table_, &pair_);
+  EXPECT_EQ(connection_not_found, nullptr);
+}
+
+TEST_F(ConnectionTableTest, PrintTable) {
+  connection_ = connection_table_allocate(conn_table_, &pair_, CONNECTION_NAME);
+  connection_->type = FACE_TYPE_TCP;
+
+  // Insert an additional connection
+  address_pair_t pair_2 =
+      address_pair_factory(_ADDRESS4_LOCALHOST(3), _ADDRESS4_LOCALHOST(4));
+  connection_t *connection_2 =
+      connection_table_allocate(conn_table_, &pair_2, CONNECTION_NAME_2);
+  connection_2->type = FACE_TYPE_TCP;
+
+  testing::internal::CaptureStdout();
+  connection_table_print_by_pair(conn_table_);
+  std::string std_out = testing::internal::GetCapturedStdout();
+
+  ASSERT_NE(std_out, "");
+
+  EXPECT_THAT(std_out, testing::HasSubstr("127.0.0.1:1"));
+  EXPECT_THAT(std_out, testing::HasSubstr("127.0.0.1:2"));
+  EXPECT_THAT(std_out, testing::HasSubstr("127.0.0.1:3"));
+  EXPECT_THAT(std_out, testing::HasSubstr("127.0.0.1:4"));
+}
+
+TEST_F(ConnectionTableTest, AddMultipleConnections) {
+  connection_ = connection_table_allocate(conn_table_, &pair_, CONNECTION_NAME);
+  connection_->type = FACE_TYPE_TCP;
+
+  // Insert an additional connection
+  address_pair_t pair_2 =
+      address_pair_factory(_ADDRESS4_LOCALHOST(3), _ADDRESS4_LOCALHOST(4));
+  connection_t *connection_2 =
+      connection_table_allocate(conn_table_, &pair_2, CONNECTION_NAME_2);
+  connection_2->type = FACE_TYPE_TCP;
+
+  // Check connection table size
+  size_t conn_table_size = connection_table_len(conn_table_);
+  EXPECT_EQ(conn_table_size, (size_t)2);
+
+  connection_t *c1 = connection_table_get_by_name(conn_table_, CONNECTION_NAME);
+  ASSERT_NE(c1, nullptr);
+  connection_t *c2 =
+      connection_table_get_by_name(conn_table_, CONNECTION_NAME_2);
+  ASSERT_NE(c2, nullptr);
+  EXPECT_NE(c1, c2);
+}
+
+TEST_F(ConnectionTableTest, Iterate) {
+  connection_ = connection_table_allocate(conn_table_, &pair_, CONNECTION_NAME);
+  connection_->type = FACE_TYPE_TCP;
+  connection_->pair = pair_;
+
+  // Insert an additional connection
+  address_pair_t pair_2 =
+      address_pair_factory(_ADDRESS4_LOCALHOST(3), _ADDRESS4_LOCALHOST(4));
+  connection_t *connection_2 =
+      connection_table_allocate(conn_table_, &pair_2, CONNECTION_NAME_2);
+  connection_2->type = FACE_TYPE_TCP;
+  connection_2->pair = pair_2;
+
+  // Iterate over the connection table and count the connections
+  connection_t *c;
+  int count = 0;
+  connection_table_foreach(conn_table_, c, { count++; });
+  EXPECT_EQ(count, 2);
+
+  // Iterate over the connection table and check the connections
+  char local_addr_str[NI_MAXHOST], remote_addr_str[NI_MAXHOST];
+  int local_port, remote_port;
+  testing::internal::CaptureStdout();
+  connection_table_foreach(conn_table_, c, {
+    const address_pair_t *pair = connection_get_pair(c);
+    address_to_string(&pair->local, local_addr_str, &local_port);
+    address_to_string(&pair->remote, remote_addr_str, &remote_port);
+
+    printf("%s:%d\t%s:%d\n", local_addr_str, local_port, remote_addr_str,
+           remote_port);
+  });
+
+  std::string std_out = testing::internal::GetCapturedStdout();
+  ASSERT_NE(std_out, "");
+  EXPECT_THAT(std_out, testing::HasSubstr("127.0.0.1:1"));
+  EXPECT_THAT(std_out, testing::HasSubstr("127.0.0.1:2"));
+  EXPECT_THAT(std_out, testing::HasSubstr("127.0.0.1:3"));
+  EXPECT_THAT(std_out, testing::HasSubstr("127.0.0.1:4"));
+}
diff --git a/hicn-light/src/hicn/test/test-ctrl.cc b/hicn-light/src/hicn/test/test-ctrl.cc
new file mode 100644
index 000000000..77b16a8af
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-ctrl.cc
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+extern "C" {
+#include <hicn/util/log.h>
+#include <hicn/ctrl.h>
+#include <hicn/config/parse.h>
+#include <hicn/ctrl/route.h>
+#include <hicn/util/sstrncpy.h>
+}
+
+class CtrlTest : public ::testing::Test {
+ protected:
+  CtrlTest() {
+    log_conf.log_level = LOG_INFO;
+    s_ = hc_sock_create_forwarder(HICNLIGHT_NG);
+  }
+  virtual ~CtrlTest() { hc_sock_free(s_); }
+
+  hc_sock_t *s_ = nullptr;
+  hc_command_t command_ = {};
+};
+
+/**
+ * The parse() function is used to easily create the command.
+ * Here we test the serialization of the commands i.e. from command
+ * to message sent to the forwarder.
+ */
+
+TEST_F(CtrlTest, AddValidListener) {
+  std::string cmd = "add listener udp udp0 10.0.0.1 9695 eth0";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), 0);
+
+  hc_result_t *result = hc_listener_create_conf(s_, &command_.object.listener);
+  bool success = hc_result_get_success(s_, result);
+  EXPECT_TRUE(success);
+}
+
+TEST_F(CtrlTest, AddListenerInvalidProtocol) {
+  // Set invalid protocol (icmp)
+  std::string cmd = "add listener icmp udp0 10.0.0.1 9696 eth0";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), 0);
+
+  hc_result_t *result = hc_listener_create_conf(s_, &command_.object.listener);
+  bool success = hc_result_get_success(s_, result);
+  EXPECT_FALSE(success);
+}
+
+TEST_F(CtrlTest, AddListenerInvalidLocalPort) {
+  std::string cmd = "add listener udp udp0 10.0.0.1 9695 eth0";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), 0);
+
+  // Override with invalid port
+  command_.object.listener.local_port = 0;
+
+  hc_result_t *result = hc_listener_create_conf(s_, &command_.object.listener);
+  bool success = hc_result_get_success(s_, result);
+  EXPECT_FALSE(success);
+}
+
+TEST_F(CtrlTest, AddListenerInvalidLocalAddress) {
+  std::string cmd = "add listener udp udp0 10.0.0.1 9695 eth0";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), 0);
+
+  // Override with invalid family
+  command_.object.listener.family = -1;
+
+  hc_result_t *result = hc_listener_create_conf(s_, &command_.object.listener);
+  bool success = hc_result_get_success(s_, result);
+  EXPECT_FALSE(success);
+}
+
+TEST_F(CtrlTest, AddListenerEmptyLocalAddress) {
+  std::string cmd = "add listener udp udp0 10.0.0.1 9695 eth0";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), 0);
+
+  // Override with invalid address
+  command_.object.listener.local_addr = IP_ADDRESS_EMPTY;
+
+  hc_result_t *result = hc_listener_create_conf(s_, &command_.object.listener);
+  bool success = hc_result_get_success(s_, result);
+  EXPECT_FALSE(success);
+}
+
+TEST_F(CtrlTest, AddListenerInvalidSymbolicName) {
+  std::string cmd = "add listener udp 0udp 10.0.0.1 9695 eth0";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), 0);
+
+  hc_result_t *result = hc_listener_create_conf(s_, &command_.object.listener);
+  bool success = hc_result_get_success(s_, result);
+  EXPECT_FALSE(success);
+}
+
+TEST_F(CtrlTest, AddListenerInvalidSymbolicName2) {
+  std::string cmd = "add listener udp udp! 10.0.0.1 9695 eth0";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), 0);
+
+  hc_result_t *result = hc_listener_create_conf(s_, &command_.object.listener);
+  bool success = hc_result_get_success(s_, result);
+  EXPECT_FALSE(success);
+}
+
+TEST_F(CtrlTest, AddListenerInvalidInterfaceName) {
+  std::string cmd = "add listener udp udp0 10.0.0.1 9695 eth/0";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), 0);
+
+  hc_result_t *result = hc_listener_create_conf(s_, &command_.object.listener);
+  bool success = hc_result_get_success(s_, result);
+  EXPECT_FALSE(success);
+}
+
+TEST_F(CtrlTest, AddValidRoute) {
+  std::string cmd = "add route conn0 c001::/64 1";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), 0);
+
+  hc_result_t *result = hc_route_create_conf(s_, &command_.object.route);
+  bool success = hc_result_get_success(s_, result);
+  EXPECT_TRUE(success);
+}
+
+TEST_F(CtrlTest, AddRouteInvalidLength) {
+  std::string cmd = "add route conn0 c001::/64 1";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), 0);
+
+  // Override with invalid prfix len
+  command_.object.route.len = MAX_IPV6_PREFIX_LEN + 1;
+
+  hc_result_t *result = hc_route_create_conf(s_, &command_.object.route);
+  bool success = hc_result_get_success(s_, result);
+  EXPECT_FALSE(success);
+}
+
+TEST_F(CtrlTest, AddRouteInvalidCost) {
+  std::string cmd = "add route conn0 c001::/64 1";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), 0);
+
+  // Override with invalid cost
+  command_.object.route.cost = MAX_ROUTE_COST + 1;
+
+  hc_result_t *result = hc_route_create_conf(s_, &command_.object.route);
+  bool success = hc_result_get_success(s_, result);
+  EXPECT_FALSE(success);
+
+  // Override with invalid cost
+  command_.object.route.cost = MIN_ROUTE_COST - 1;
+
+  result = hc_route_create_conf(s_, &command_.object.route);
+  success = hc_result_get_success(s_, result);
+  EXPECT_FALSE(success);
+}
\ No newline at end of file
diff --git a/hicn-light/src/hicn/test/test-hash.cc b/hicn-light/src/hicn/test/test-hash.cc
new file mode 100644
index 000000000..2b72e194a
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-hash.cc
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+// #include <hicn/transport/utils/hash.h>
+
+extern "C" {
+#include <hicn/base/hash.h>
+#include <hicn/core/address_pair.h>
+#include <hicn/core/listener.h>
+}
+
+TEST(HashTest, MultipleHashesForSameAddrPair) {
+  address_pair_t pair =
+      address_pair_factory(_ADDRESS4_LOCALHOST(1), _ADDRESS4_LOCALHOST(2));
+
+  unsigned h1 = hash_struct(&pair);
+  unsigned h2 = hash_struct(&pair);
+  EXPECT_EQ(h1, h2);
+}
+
+TEST(HashTest, SameAddrPairs) {
+  address_pair_t pair1 =
+      address_pair_factory(_ADDRESS4_LOCALHOST(1), _ADDRESS4_LOCALHOST(2));
+  address_pair_t pair2 = pair1;
+
+  unsigned h1 = hash_struct(&pair1);
+  unsigned h2 = hash_struct(&pair2);
+  EXPECT_EQ(h1, h2);
+}
+
+TEST(HashTest, DifferentAddrPairs) {
+  address_pair_t pair1 =
+      address_pair_factory(_ADDRESS4_LOCALHOST(1), _ADDRESS4_LOCALHOST(2));
+
+  address_pair_t pair2 =
+      address_pair_factory(_ADDRESS4_LOCALHOST(3), _ADDRESS4_LOCALHOST(4));
+
+  unsigned h1 = hash_struct(&pair1);
+  unsigned h2 = hash_struct(&pair2);
+  EXPECT_NE(h1, h2);
+}
+
+TEST(HashTest, SameLocalDifferentRemote) {
+  address_pair_t pair1 =
+      address_pair_factory(_ADDRESS4_LOCALHOST(1), _ADDRESS4_LOCALHOST(2));
+
+  address_pair_t pair2 =
+      address_pair_factory(_ADDRESS4_LOCALHOST(1), _ADDRESS4_LOCALHOST(4));
+
+  unsigned h1 = hash_struct(&pair1);
+  unsigned h2 = hash_struct(&pair2);
+  EXPECT_NE(h1, h2);
+}
+
+TEST(HashTest, SameRemoteDifferentLocal) {
+  address_pair_t pair1 =
+      address_pair_factory(_ADDRESS4_LOCALHOST(1), _ADDRESS4_LOCALHOST(2));
+
+  address_pair_t pair2 =
+      address_pair_factory(_ADDRESS4_LOCALHOST(3), _ADDRESS4_LOCALHOST(2));
+
+  unsigned h1 = hash_struct(&pair1);
+  unsigned h2 = hash_struct(&pair2);
+  EXPECT_NE(h1, h2);
+}
+
+TEST(HashTest, SameAddresses) {
+  address_t addr1 = _ADDRESS4_LOCALHOST(1);
+  address_t addr2 = _ADDRESS4_LOCALHOST(1);
+
+  unsigned h1 = hash_struct(&addr1);
+  unsigned h2 = hash_struct(&addr2);
+
+  EXPECT_EQ(h1, h2);
+}
+
+TEST(HashTest, SameListenerKeys) {
+  listener_key_t key1 =
+      listener_key_factory(_ADDRESS4_LOCALHOST(1), FACE_TYPE_UDP_LISTENER);
+  listener_key_t key2 =
+      listener_key_factory(_ADDRESS4_LOCALHOST(1), FACE_TYPE_UDP_LISTENER);
+
+  unsigned h1 = hash_struct(&key1);
+  unsigned h2 = hash_struct(&key2);
+
+  EXPECT_EQ(h1, h2);
+}
+
+TEST(HashTest, Collisions) {
+  uint32_t init_val = 2166136261UL;
+  (void)init_val;
+
+  std::map<u32, uint32_t> hashes;
+  for (int i = 0; i < 50000; i++) {
+    uint32_t seg = i;
+    // u32 h = utils::hash::fnv32_buf (&seg, sizeof (seg));
+    // u32 h = cumulative_hash32 (&seg, sizeof (seg), init_val);
+    u32 h = hash(&seg, sizeof(seg));
+    EXPECT_FALSE(hashes.find(h) != hashes.end()) << seg << " - " << hashes[h];
+    hashes[h] = seg;
+  }
+}
\ No newline at end of file
diff --git a/hicn-light/src/hicn/test/test-khash.cc b/hicn-light/src/hicn/test/test-khash.cc
new file mode 100644
index 000000000..4fcb48c31
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-khash.cc
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <netinet/in.h>
+
+extern "C" {
+#include <hicn/base/khash.h>
+}
+
+KHASH_MAP_INIT_INT(int, unsigned char)
+
+typedef struct {
+  unsigned key;
+  unsigned char val;
+} int_unpack_t;
+
+typedef struct {
+  unsigned key;
+  unsigned char val;
+} __attribute__((__packed__)) int_packed_t;
+
+#define hash_eq(a, b) ((a).key == (b).key)
+#define hash_func(a) ((a).key)
+
+KHASH_INIT(iun, int_unpack_t, char, 0, hash_func, hash_eq)
+KHASH_INIT(ipk, int_packed_t, char, 0, hash_func, hash_eq)
+
+class KHashTest : public ::testing::Test {
+ protected:
+  KHashTest() {}
+
+  virtual ~KHashTest() {
+    // You can do clean-up work that doesn't throw exceptions here.
+  }
+
+  // If the constructor and destructor are not enough for setting up
+  // and cleaning up each test, you can define the following methods:
+
+  virtual void SetUp() { khash = kh_init(int); }
+
+  virtual void TearDown() { kh_destroy(int, khash); }
+  khash_t(int) * khash;
+};
+
+TEST_F(KHashTest, KhashIntSize) {
+  int ret;
+  int k;
+  int size = kh_size(khash);
+
+  EXPECT_EQ(size, 0);
+  k = kh_put(int, khash, 10, &ret);
+  if (ret == 1) {
+    kh_val(khash, k) = 10;
+  }
+  size = kh_size(khash);
+  EXPECT_EQ(size, 1);
+}
+
+TEST_F(KHashTest, KhashIntPut) {
+  int ret;
+  int k;
+  k = kh_put(int, khash, 10, &ret);
+  if (ret == 1) {
+    kh_val(khash, k) = 10;
+  }
+  int size = kh_size(khash);
+  EXPECT_EQ(size, 1);
+  k = kh_put(int, khash, 20, &ret);
+  if (ret == 1) {
+    kh_val(khash, k) = 20;
+  }
+  size = kh_size(khash);
+  EXPECT_EQ(size, 2);
+}
+
+TEST_F(KHashTest, KhashCheckValue) {
+  int ret;
+  int k;
+  k = kh_put(int, khash, 10, &ret);
+  if (ret == 1) {
+    kh_val(khash, k) = 100;
+  }
+  k = kh_put(int, khash, 20, &ret);
+  if (ret == 1) {
+    kh_val(khash, k) = 200;
+  }
+
+  k = kh_put(int, khash, 10, &ret);
+  int val = -1;
+  if (!ret) val = kh_val(khash, k);
+  EXPECT_EQ(val, 100);
+
+  k = kh_put(int, khash, 20, &ret);
+  val = -1;
+  if (!ret) val = kh_val(khash, k);
+  EXPECT_EQ(val, 200);
+}
+
+// Check that there are no collisions in case of same key hash
+typedef struct {
+  int x;
+} Key;
+#define hash_key(key) 1  // Hash is always 1 to simulate collisions
+#define key_hash_eq(a, b) (a->x == b->x)  // Function used in case of collisions
+KHASH_INIT(test_map, const Key *, unsigned, 1, hash_key, key_hash_eq);
+
+TEST_F(KHashTest, Collisions) {
+  int ret;
+  khiter_t k;
+
+  kh_test_map_t *map = kh_init(test_map);
+  Key key1 = {.x = 10};
+  Key key2 = {.x = 11};
+
+  k = kh_put_test_map(map, &key1, &ret);
+  EXPECT_EQ(ret, 1);
+  kh_val(map, k) = 15;
+
+  k = kh_put_test_map(map, &key2, &ret);
+  EXPECT_EQ(ret, 1);
+  kh_val(map, k) = 27;
+
+  k = kh_get_test_map(map, &key1);
+  ASSERT_NE(k, kh_end(map));
+  unsigned val = kh_val(map, k);
+  EXPECT_EQ(val, 15u);
+
+  k = kh_get_test_map(map, &key2);
+  ASSERT_NE(k, kh_end(map));
+  val = kh_val(map, k);
+  EXPECT_EQ(val, 27u);
+
+  kh_destroy_test_map(map);
+}
diff --git a/hicn-light/src/hicn/test/test-listener_table.cc b/hicn-light/src/hicn/test/test-listener_table.cc
new file mode 100644
index 000000000..b2ed0c276
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-listener_table.cc
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <netinet/in.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/core/listener_table.h>
+}
+
+#define LISTENER_NAME "listener_name_test"
+#define LISTENER_NAME_2 "listener_name_test_2"
+
+class ListenerTableTest : public ::testing::Test {
+ protected:
+  ListenerTableTest() {
+    log_conf.log_level = LOG_INFO;
+
+    listener_table_ = listener_table_create();
+    key_ = listener_key_factory(_ADDRESS4_LOCALHOST(1), FACE_TYPE_UDP_LISTENER);
+  }
+  virtual ~ListenerTableTest() { listener_table_free(listener_table_); }
+
+  listener_table_t *listener_table_;
+  listener_t *listener_;
+  listener_key_t key_;
+};
+
+TEST_F(ListenerTableTest, CreateTable) {
+  // Check listener_table allocation
+  EXPECT_NE(listener_table_, nullptr);
+
+  // Check listener_table size
+  size_t listener_table_size = listener_table_len(listener_table_);
+  EXPECT_EQ(listener_table_size, (size_t)0);
+}
+
+TEST_F(ListenerTableTest, AddListener) {
+  // Add listener to listener table
+  listener_ = listener_table_allocate(listener_table_, &key_, LISTENER_NAME);
+  listener_->type = FACE_TYPE_UDP_LISTENER;
+
+  size_t listener_table_size = listener_table_len(listener_table_);
+  EXPECT_EQ(listener_table_size, (size_t)1);
+  EXPECT_NE(listener_, nullptr);
+
+  // Get listener by name and by key
+  khiter_t k_name = kh_get_lt_name(listener_table_->id_by_name, LISTENER_NAME);
+  EXPECT_NE(k_name, kh_end(listener_table_->id_by_name));
+  khiter_t k_key = kh_get_lt_key(listener_table_->id_by_key, &key_);
+  EXPECT_NE(k_key, kh_end(listener_table_->id_by_key));
+}
+
+TEST_F(ListenerTableTest, GetListener) {
+  // Add listener to listener table
+  listener_ = listener_table_allocate(listener_table_, &key_, LISTENER_NAME);
+  listener_->type = FACE_TYPE_UDP_LISTENER;
+
+  size_t listener_table_size = listener_table_len(listener_table_);
+  EXPECT_EQ(listener_table_size, (size_t)1);
+  ASSERT_NE(listener_, nullptr);
+
+  // Get listener by name
+  listener_t *listener_retrieved =
+      listener_table_get_by_name(listener_table_, LISTENER_NAME);
+  ASSERT_NE(listener_retrieved, nullptr);
+  EXPECT_EQ(listener_retrieved, listener_);
+
+  // Get listener by key
+  listener_retrieved = listener_table_get_by_key(listener_table_, &key_);
+  ASSERT_NE(listener_retrieved, nullptr);
+  EXPECT_EQ(listener_retrieved, listener_);
+}
+
+TEST_F(ListenerTableTest, GetListenerWithIdOutOfRange) {
+  listener_t *listener = _listener_table_get_by_id(listener_table_, ~0);
+  EXPECT_EQ(listener, nullptr);
+}
+
+TEST_F(ListenerTableTest, GetListenerWithInvalidId) {
+  // First listener inserted has always id equal to 0
+  int non_valid_id = 5;
+
+  listener_ = listener_table_allocate(listener_table_, &key_, LISTENER_NAME);
+  listener_->type = FACE_TYPE_UDP_LISTENER;
+
+  listener_t *listener_not_found =
+      listener_table_get_by_id(listener_table_, non_valid_id);
+  ASSERT_EQ(listener_not_found, nullptr);
+}
+
+TEST_F(ListenerTableTest, GetListenerWithValidId) {
+  listener_ = listener_table_allocate(listener_table_, &key_, LISTENER_NAME);
+  listener_->type = FACE_TYPE_UDP_LISTENER;
+
+  int id = listener_table_get_listener_id(listener_table_, listener_);
+  listener_t *listener_found = listener_table_get_by_id(listener_table_, id);
+  ASSERT_EQ(listener_found, listener_);
+}
+
+TEST_F(ListenerTableTest, GetListenerIdFromValidName) {
+  listener_ = listener_table_allocate(listener_table_, &key_, LISTENER_NAME);
+  listener_->type = FACE_TYPE_UDP_LISTENER;
+
+  int id = listener_table_get_id_by_name(listener_table_, LISTENER_NAME);
+  ASSERT_TRUE(listener_id_is_valid(id));
+}
+
+TEST_F(ListenerTableTest, GetListenerIdFromInvalidName) {
+  listener_ = listener_table_allocate(listener_table_, &key_, LISTENER_NAME);
+  listener_->type = FACE_TYPE_UDP_LISTENER;
+
+  int id = listener_table_get_id_by_name(listener_table_, LISTENER_NAME_2);
+  ASSERT_FALSE(listener_id_is_valid(id));
+}
+
+TEST_F(ListenerTableTest, RemoveListener) {
+  // Add listener (listerner name and key must be set)
+  listener_ = listener_table_allocate(listener_table_, &key_, LISTENER_NAME);
+  listener_->type = FACE_TYPE_UDP_LISTENER;
+  listener_->name = (char *)LISTENER_NAME;
+  listener_->key = key_;
+
+  // Remove listener
+  int id = listener_table_get_listener_id(listener_table_, listener_);
+  listener_table_remove_by_id(listener_table_, id);
+
+  // Check listener table size
+  size_t listener_table_size = listener_table_len(listener_table_);
+  EXPECT_EQ(listener_table_size, (size_t)0);
+
+  // Check that previous listener is not valid anymore
+  listener_t *listener_not_found =
+      listener_table_get_by_id(listener_table_, id);
+  EXPECT_EQ(listener_not_found, nullptr);
+  listener_not_found =
+      listener_table_get_by_name(listener_table_, LISTENER_NAME);
+  EXPECT_EQ(listener_not_found, nullptr);
+  listener_not_found = listener_table_get_by_key(listener_table_, &key_);
+  EXPECT_EQ(listener_not_found, nullptr);
+}
+
+TEST_F(ListenerTableTest, PrintTable) {
+  listener_ = listener_table_allocate(listener_table_, &key_, LISTENER_NAME);
+  listener_->type = FACE_TYPE_UDP_LISTENER;
+
+  // Insert an additional listener
+  listener_key_t key_2 =
+      listener_key_factory(_ADDRESS4_LOCALHOST(2), FACE_TYPE_TCP_LISTENER);
+  listener_t *listener_2 =
+      listener_table_allocate(listener_table_, &key_2, LISTENER_NAME_2);
+  listener_2->type = FACE_TYPE_UDP_LISTENER;
+
+  testing::internal::CaptureStdout();
+  listener_table_print_by_key(listener_table_);
+  std::string std_out = testing::internal::GetCapturedStdout();
+
+  ASSERT_NE(std_out, "");
+  EXPECT_THAT(std_out, testing::HasSubstr("127.0.0.1:1"));
+  EXPECT_THAT(std_out, testing::HasSubstr("127.0.0.1:2"));
+}
+
+TEST_F(ListenerTableTest, AddMultipleListeners) {
+  listener_ = listener_table_allocate(listener_table_, &key_, LISTENER_NAME);
+  listener_->type = FACE_TYPE_UDP_LISTENER;
+
+  // Insert an additional listener
+  listener_key_t key_2 =
+      listener_key_factory(_ADDRESS4_LOCALHOST(2), FACE_TYPE_TCP_LISTENER);
+  listener_t *listener_2 =
+      listener_table_allocate(listener_table_, &key_2, LISTENER_NAME_2);
+  listener_2->type = FACE_TYPE_UDP_LISTENER;
+
+  // Check listener table size
+  size_t listener_table_size = listener_table_len(listener_table_);
+  EXPECT_EQ(listener_table_size, (size_t)2);
+
+  listener_t *l1 = listener_table_get_by_name(listener_table_, LISTENER_NAME);
+  ASSERT_NE(l1, nullptr);
+  listener_t *l2 = listener_table_get_by_name(listener_table_, LISTENER_NAME_2);
+  ASSERT_NE(l2, nullptr);
+  EXPECT_NE(l1, l2);
+}
+
+TEST_F(ListenerTableTest, Iterate) {
+  listener_ = listener_table_allocate(listener_table_, &key_, LISTENER_NAME);
+  listener_->type = FACE_TYPE_UDP_LISTENER;
+  listener_->key = key_;
+
+  // Insert an additional listener
+  listener_key_t key_2 =
+      listener_key_factory(_ADDRESS4_LOCALHOST(2), FACE_TYPE_TCP_LISTENER);
+  listener_t *listener_2 =
+      listener_table_allocate(listener_table_, &key_2, LISTENER_NAME_2);
+  listener_2->type = FACE_TYPE_UDP_LISTENER;
+  listener_2->key = key_2;
+
+  // Iterate over the listener table and count the listeners
+  listener_t *l;
+  int count = 0;
+  listener_table_foreach(listener_table_, l, { count++; });
+  EXPECT_EQ(count, 2);
+
+  // Iterate over the listener table and check the listeners
+  char addr_str[NI_MAXHOST];
+  int port;
+  testing::internal::CaptureStdout();
+  listener_table_foreach(listener_table_, l, {
+    address_to_string(&l->address, addr_str, &port);
+    printf("%s\t%s:%d\n", face_type_str(l->type), addr_str, port);
+  });
+
+  std::string std_out = testing::internal::GetCapturedStdout();
+  ASSERT_NE(std_out, "");
+  EXPECT_THAT(std_out, testing::HasSubstr("127.0.0.1:1"));
+  EXPECT_THAT(std_out, testing::HasSubstr("127.0.0.1:2"));
+  EXPECT_THAT(std_out, testing::HasSubstr("UDP"));
+  EXPECT_THAT(std_out, testing::HasSubstr("TCP"));
+}
diff --git a/hicn-light/src/hicn/test/test-local_prefixes.cc b/hicn-light/src/hicn/test/test-local_prefixes.cc
new file mode 100644
index 000000000..80eb46501
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-local_prefixes.cc
@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/strategies/local_prefixes.h>
+#include <hicn/core/strategy.h>
+#include <hicn/core/name.h>
+}
+
+const char *name_str1 = "b001::0";
+const char *name_str2 = "b002::0";
+const char *name_str3 = "b003::0";
+const char *name_str4 = "b004::0";
+const char *name_str5 = "b005::0";
+const char *name_str6 = "b006::0";
+const char *name_str7 = "b007::0";
+const char *name_str8 = "b008::0";
+const char *name_str9 = "b009::0";
+const char *name_str10 = "b010::0";
+const char *name_str11 = "b011::0";
+
+class LocalPrefixesTest : public ::testing::Test {
+ protected:
+  LocalPrefixesTest() {}
+
+  virtual ~LocalPrefixesTest() {}
+};
+
+TEST_F(LocalPrefixesTest, LocalPrefixesAddName) {
+  local_prefixes_t *lp = create_local_prefixes();
+  EXPECT_FALSE(lp == nullptr);
+
+  ip_address_t result;
+  inet_pton(AF_INET6, name_str1, (struct in6_addr *)&result);
+  Name name1;
+  name_CreateFromAddress(&name1, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str2, (struct in6_addr *)&result);
+  Name name2;
+  name_CreateFromAddress(&name2, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str3, (struct in6_addr *)&result);
+  Name name3;
+  name_CreateFromAddress(&name3, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str4, (struct in6_addr *)&result);
+  Name name4;
+  name_CreateFromAddress(&name4, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str5, (struct in6_addr *)&result);
+  Name name5;
+  name_CreateFromAddress(&name5, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str6, (struct in6_addr *)&result);
+  Name name6;
+  name_CreateFromAddress(&name6, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str7, (struct in6_addr *)&result);
+  Name name7;
+  name_CreateFromAddress(&name7, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str8, (struct in6_addr *)&result);
+  Name name8;
+  name_CreateFromAddress(&name8, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str9, (struct in6_addr *)&result);
+  Name name9;
+  name_CreateFromAddress(&name9, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str10, (struct in6_addr *)&result);
+  Name name10;
+  name_CreateFromAddress(&name10, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str11, (struct in6_addr *)&result);
+  Name name11;
+  name_CreateFromAddress(&name11, AF_INET6, result, 128);
+
+  local_prefixes_add_prefix(lp, &name1);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)1);
+
+  local_prefixes_add_prefix(lp, &name1);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)1);
+
+  local_prefixes_add_prefix(lp, &name2);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)2);
+
+  local_prefixes_add_prefix(lp, &name2);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)2);
+
+  local_prefixes_add_prefix(lp, &name3);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)3);
+
+  local_prefixes_add_prefix(lp, &name4);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)4);
+
+  local_prefixes_add_prefix(lp, &name5);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)5);
+
+  local_prefixes_add_prefix(lp, &name6);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)6);
+
+  local_prefixes_add_prefix(lp, &name7);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)7);
+
+  local_prefixes_add_prefix(lp, &name8);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)8);
+
+  local_prefixes_add_prefix(lp, &name9);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)9);
+
+  local_prefixes_add_prefix(lp, &name10);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)10);
+
+  local_prefixes_add_prefix(lp, &name11);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)10);
+
+  free_local_prefixes(lp);
+}
+
+TEST_F(LocalPrefixesTest, LocalPrefixesAddPrefixes) {
+  local_prefixes_t *lp = create_local_prefixes();
+  EXPECT_FALSE(lp == nullptr);
+
+  ip_address_t result;
+
+  local_prefixes_t *lp1 = create_local_prefixes();
+  EXPECT_FALSE(lp1 == nullptr);
+
+  inet_pton(AF_INET6, name_str1, (struct in6_addr *)&result);
+  Name name1;
+  name_CreateFromAddress(&name1, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str2, (struct in6_addr *)&result);
+  Name name2;
+  name_CreateFromAddress(&name2, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str3, (struct in6_addr *)&result);
+  Name name3;
+  name_CreateFromAddress(&name3, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str4, (struct in6_addr *)&result);
+  Name name4;
+  name_CreateFromAddress(&name4, AF_INET6, result, 128);
+
+  local_prefixes_add_prefix(lp1, &name1);
+  local_prefixes_add_prefix(lp1, &name2);
+  local_prefixes_add_prefix(lp1, &name3);
+  local_prefixes_add_prefix(lp1, &name4);
+
+  EXPECT_EQ(local_prefixes_get_len(lp1), (unsigned)4);
+
+  local_prefixes_add_prefixes(lp, lp1);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)4);
+
+  local_prefixes_add_prefixes(lp, lp1);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)4);
+
+  local_prefixes_t *lp2 = create_local_prefixes();
+  EXPECT_FALSE(lp2 == nullptr);
+
+  inet_pton(AF_INET6, name_str5, (struct in6_addr *)&result);
+  Name name5;
+  name_CreateFromAddress(&name5, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str6, (struct in6_addr *)&result);
+  Name name6;
+  name_CreateFromAddress(&name6, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str7, (struct in6_addr *)&result);
+  Name name7;
+  name_CreateFromAddress(&name7, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str8, (struct in6_addr *)&result);
+  Name name8;
+  name_CreateFromAddress(&name8, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str9, (struct in6_addr *)&result);
+  Name name9;
+  name_CreateFromAddress(&name9, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str10, (struct in6_addr *)&result);
+  Name name10;
+  name_CreateFromAddress(&name10, AF_INET6, result, 128);
+
+  inet_pton(AF_INET6, name_str11, (struct in6_addr *)&result);
+  Name name11;
+  name_CreateFromAddress(&name11, AF_INET6, result, 128);
+
+  local_prefixes_add_prefix(lp2, &name5);
+  local_prefixes_add_prefix(lp2, &name6);
+  local_prefixes_add_prefix(lp2, &name7);
+  local_prefixes_add_prefix(lp2, &name8);
+  local_prefixes_add_prefix(lp2, &name9);
+  local_prefixes_add_prefix(lp2, &name10);
+  local_prefixes_add_prefix(lp2, &name11);
+
+  EXPECT_EQ(local_prefixes_get_len(lp2), (unsigned)7);
+
+  local_prefixes_add_prefixes(lp, lp2);
+  EXPECT_EQ(local_prefixes_get_len(lp), (unsigned)10);
+
+  free_local_prefixes(lp);
+  free_local_prefixes(lp1);
+  free_local_prefixes(lp2);
+}
diff --git a/hicn-light/src/hicn/test/test-loop.cc b/hicn-light/src/hicn/test/test-loop.cc
new file mode 100644
index 000000000..f783b0ada
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-loop.cc
@@ -0,0 +1,288 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <fcntl.h>
+
+extern "C" {
+#include <hicn/base/loop.h>
+}
+
+class LoopTest : public ::testing::Test {
+  static constexpr uint16_t BUFFER_SIZE = 1024;
+
+ protected:
+  LoopTest()
+      : server_port_(9191),
+        loop_(nullptr),
+        timer_tick_(2000),
+        connection_socket_(-1),
+        event_(nullptr),
+        timer_(nullptr) {}
+
+  virtual ~LoopTest() {
+    // You can do clean-up work that doesn't throw exceptions here.
+  }
+
+  // If the constructor and destructor are not enough for setting up
+  // and cleaning up each test, you can define the following methods:
+
+  virtual void SetUp() {
+    // Code here will be called immediately after the constructor (right
+    // before each test).
+  }
+
+  virtual void TearDown() {
+    // Code here will be called immediately after each test (right
+    // before the destructor).
+  }
+
+  static int onFirstTimerExpiration(void *owner, int fd, void *arg) {
+    std::cout << "This function should never be called" << std::endl;
+    EXPECT_TRUE(false);
+    return -1;
+  }
+
+  static int onSecondTimerExpiration(void *owner, int fd, void *arg) {
+    std::cout << "First timer expired. Cancel second timer." << std::endl;
+    LoopTest *test = (LoopTest *)(arg);
+    loop_event_unregister(test->timer_);
+    return 0;
+  }
+
+  static int onTimerExpiration(void *owner, int fd, void *arg) {
+    // Create client socket
+    struct sockaddr_in addr;
+    int client_socket;
+    LoopTest *test = (LoopTest *)(arg);
+
+    client_socket = socket(AF_INET, SOCK_STREAM, 0);
+    if (client_socket == -1) {
+      perror("socket");
+      return -1;
+    }
+
+    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(test->server_port_);
+
+    if (connect(client_socket, (struct sockaddr *)&addr,
+                sizeof(struct sockaddr)) == -1) {
+      perror("connect");
+      return -1;
+    }
+
+    if (send(client_socket, "Hello, world!\n", 14, 0) == -1) {
+      perror("send");
+      return -1;
+    }
+
+    close(client_socket);
+    loop_event_unregister(test->timer_);
+
+    return 0;
+  }
+
+  static int onNewConnection(void *owner, int fd, void *arg) {
+    LoopTest *test = (LoopTest *)arg;
+    struct sockaddr_in addr;
+    addr.sin_addr.s_addr = INADDR_ANY;
+    addr.sin_family = AF_INET;
+
+    socklen_t addr_len = sizeof(struct sockaddr_in);
+    int ret;
+
+    int client_fd =
+        accept(test->connection_socket_, (struct sockaddr *)(&addr), &addr_len);
+    if (client_fd == -1) {
+      if (errno != EAGAIN && errno != EWOULDBLOCK) {
+        fprintf(stderr, "accept failed");
+      }
+
+      perror("accept");
+      return -1;
+    }
+
+    // Read whatever data available and close connection.
+    ret = read(client_fd, test->buffer, BUFFER_SIZE);
+    if (ret < 0) {
+      perror("read");
+      return -1;
+    }
+
+    test->buffer[ret] = '\0';
+    std::cout << "Received: " << (char *)test->buffer << std::endl;
+
+    close(client_fd);
+    loop_event_unregister(test->event_);
+
+    return 0;
+  }
+
+  void createTcpSocketServer() {
+    struct sockaddr_in addr;
+    int ret;
+
+    /* Create local socket. */
+
+    connection_socket_ = socket(AF_INET, SOCK_STREAM, 0);
+    if (connection_socket_ == -1) {
+      perror("socket");
+      return;
+    }
+
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(server_port_);
+    addr.sin_addr.s_addr = htonl(INADDR_ANY);
+
+    ret = bind(connection_socket_, (const struct sockaddr *)&addr,
+               sizeof(struct sockaddr_in));
+    if (ret == -1) {
+      perror("bind");
+      return;
+    }
+
+    ret = listen(connection_socket_, 20);
+    if (ret == -1) {
+      perror("listen");
+      return;
+    }
+  }
+
+  uint16_t server_port_;
+  loop_t *loop_;
+  unsigned timer_tick_;
+  int connection_socket_;
+  event_t *event_;
+  event_t *timer_;
+  char buffer[BUFFER_SIZE];
+};
+
+TEST_F(LoopTest, LoopCreateAndFree) {
+  loop_ = loop_create();
+  EXPECT_TRUE(loop_ != NULL);
+  loop_free(loop_);
+  EXPECT_TRUE(loop_ != NULL);
+}
+
+TEST_F(LoopTest, EventCreateAndFree) {
+  int ret;
+
+  // Fake fd
+  int fd = socket(AF_INET, SOCK_STREAM, 0);
+  loop_ = loop_create();
+
+  ret = loop_fd_event_create(&event_, loop_, fd, nullptr,
+                             &LoopTest::onNewConnection, this);
+  EXPECT_TRUE(ret >= 0);
+  EXPECT_TRUE(event_);
+
+  // Register the event
+  ret = loop_fd_event_register(event_);
+  EXPECT_TRUE(ret >= 0);
+
+  // Unregister the event
+  ret = loop_event_free(event_);
+  EXPECT_TRUE(ret >= 0);
+
+  // close fd
+  ret = close(fd);
+  EXPECT_EQ(ret, 0);
+
+  // Free event loop
+  loop_free(loop_);
+}
+
+TEST_F(LoopTest, TimerCreateAndCancel) {
+  int ret;
+  event_t *timer2;
+  loop_ = loop_create();
+
+  ret = loop_timer_create(&timer_, loop_, nullptr,
+                          &LoopTest::onFirstTimerExpiration, this);
+  EXPECT_TRUE(ret >= 0);
+  EXPECT_TRUE(timer_);
+
+  ret = loop_timer_create(&timer2, loop_, nullptr,
+                          &LoopTest::onSecondTimerExpiration, this);
+  EXPECT_TRUE(ret >= 0);
+  EXPECT_TRUE(timer2);
+
+  // Register the 1st timer
+  ret = loop_timer_register(timer_, timer_tick_);
+  EXPECT_TRUE(ret >= 0);
+
+  // Register the 2nd timer
+  ret = loop_timer_register(timer2, timer_tick_ / 2);
+  EXPECT_TRUE(ret >= 0);
+
+  _loop_dispatch(loop_, 0);
+
+  loop_undispatch(loop_);
+
+  // Unregister the events
+  ret = loop_event_free(timer_);
+  ret += loop_event_free(timer2);
+  EXPECT_TRUE(ret >= 0);
+
+  // Free event loop
+  loop_free(loop_);
+}
+
+TEST_F(LoopTest, LoopDispatch) {
+  int ret;
+
+  // Create new unix socket
+  createTcpSocketServer();
+  loop_ = loop_create();
+
+  ret = loop_fd_event_create(&event_, loop_, connection_socket_, nullptr,
+                             &LoopTest::onNewConnection, this);
+  EXPECT_TRUE(ret >= 0);
+  EXPECT_TRUE(event_);
+
+  ret = loop_fd_event_register(event_);
+  EXPECT_TRUE(ret >= 0);
+
+  // Create timer.
+  ret = loop_timer_create(&timer_, loop_, nullptr, &LoopTest::onTimerExpiration,
+                          this);
+  EXPECT_TRUE(ret >= 0);
+  EXPECT_TRUE(timer_);
+
+  ret = loop_timer_register(timer_, timer_tick_);
+  EXPECT_TRUE(ret >= 0);
+
+  // Start event dispatching
+  _loop_dispatch(loop_, 0);
+
+  // Stop dispatching
+  loop_undispatch(loop_);
+
+  // Free events
+  loop_event_free(timer_);
+  loop_event_free(event_);
+
+  // Free event loop
+  loop_free(loop_);
+}
diff --git a/hicn-light/src/hicn/test/test-msgbuf_pool.cc b/hicn-light/src/hicn/test/test-msgbuf_pool.cc
new file mode 100644
index 000000000..5537aa216
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-msgbuf_pool.cc
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <netinet/in.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/core/msgbuf_pool.h>
+#include <hicn/base/pool.h>
+}
+
+class MsgbufPoolTest : public ::testing::Test {
+ protected:
+  MsgbufPoolTest() { msgbuf_pool = msgbuf_pool_create(); }
+  virtual ~MsgbufPoolTest() { msgbuf_pool_free(msgbuf_pool); }
+
+  msgbuf_pool_t *msgbuf_pool;
+};
+
+TEST_F(MsgbufPoolTest, Create) {
+  /* Check msgbuf_pool allocation */
+  EXPECT_NE(msgbuf_pool, nullptr);
+
+  /* Check msgbuf_pool size */
+  size_t msgbuf_pool_size = pool_hdr(msgbuf_pool->buffers)->alloc_size;
+  EXPECT_EQ(msgbuf_pool_size, (size_t)PACKET_POOL_DEFAULT_INIT_SIZE);
+}
+
+TEST_F(MsgbufPoolTest, GetMsgbuf) {
+  msgbuf_t *msgbuf = NULL;
+
+  /* Get valid msgbuf from msgbuf_pool */
+  off_t msgbuf_id = msgbuf_pool_get(msgbuf_pool, &msgbuf);
+  EXPECT_NE(msgbuf, nullptr);
+  EXPECT_NE(msgbuf_id_is_valid((unsigned long)msgbuf_id), 0);
+
+  /* Check if the returned id is correct */
+  off_t id = msgbuf_pool_get_id(msgbuf_pool, msgbuf);
+  EXPECT_EQ(id, msgbuf_id);
+
+  /* Check if the returned msgbuf is correct */
+  msgbuf_t *msgbuf_retrieved = msgbuf_pool_at(msgbuf_pool, id);
+  EXPECT_EQ(msgbuf_retrieved, msgbuf);
+}
+
+TEST_F(MsgbufPoolTest, PutMsgbuf) {
+  /* Check that asking a msgbuf right after releasing another one
+  returns the same msgbuf */
+
+  msgbuf_t *msgbuf = NULL;
+
+  off_t id1 = msgbuf_pool_get(msgbuf_pool, &msgbuf);
+  EXPECT_NE(msgbuf, nullptr);
+
+  msgbuf_pool_put(msgbuf_pool, msgbuf);
+
+  off_t id2 = msgbuf_pool_get(msgbuf_pool, &msgbuf);
+  EXPECT_NE(msgbuf, nullptr);
+
+  EXPECT_EQ(id2, id1);
+}
+
+TEST_F(MsgbufPoolTest, GetMultipleMsgbufs) {
+  const int NUM_MSG = 3;
+  msgbuf_t *msgbufs[NUM_MSG];
+
+  /* Check if successful allocation */
+  int ret = msgbuf_pool_getn(msgbuf_pool, msgbufs, NUM_MSG);
+  EXPECT_EQ(ret, 0);
+
+  /* Check if all msgbufs are valid */
+  for (unsigned i = 0; i < NUM_MSG; i++) {
+    msgbuf_pool_get_id(msgbuf_pool, msgbufs[i]);
+    EXPECT_NE(msgbufs[i], nullptr) << "Invalid index: " << i;
+  }
+}
+
+TEST_F(MsgbufPoolTest, AcquireMsgbuf) {
+  msgbuf_t *msgbuf = NULL;
+
+  // Get msgbuf from msgbuf_pool
+  off_t msgbuf_id = msgbuf_pool_get(msgbuf_pool, &msgbuf);
+  msgbuf->type = MSGBUF_TYPE_COMMAND;
+  EXPECT_NE(msgbuf, nullptr);
+  EXPECT_NE(msgbuf_id_is_valid((unsigned long)msgbuf_id), 0);
+
+  // Acquire the msgbuf
+  msgbuf_pool_acquire(msgbuf);
+  EXPECT_NE(msgbuf, nullptr);
+  EXPECT_EQ(msgbuf->refs, 1u);
+
+  msgbuf_pool_acquire(msgbuf);
+  EXPECT_NE(msgbuf, nullptr);
+  EXPECT_EQ(msgbuf->refs, 2u);
+}
+
+TEST_F(MsgbufPoolTest, ReleaseMsgbuf) {
+  msgbuf_t *msgbuf = NULL;
+
+  // Get msgbuf from msgbuf_pool
+  off_t msgbuf_id = msgbuf_pool_get(msgbuf_pool, &msgbuf);
+  msgbuf->type = MSGBUF_TYPE_COMMAND;
+  EXPECT_NE(msgbuf, nullptr);
+  EXPECT_NE(msgbuf_id_is_valid((unsigned long)msgbuf_id), 0);
+
+  // Acquire the msgbuf
+  msgbuf_pool_acquire(msgbuf);
+  EXPECT_EQ(msgbuf->refs, 1u);
+
+  // Release the msgbuf
+  msgbuf_pool_release(msgbuf_pool, &msgbuf);
+  EXPECT_EQ(msgbuf, nullptr);
+}
+
+TEST_F(MsgbufPoolTest, ReleaseNotAcquiredMsgbuf) {
+  msgbuf_t *msgbuf = NULL;
+
+  // Get valid msgbuf from msgbuf_pool
+  off_t msgbuf_id = msgbuf_pool_get(msgbuf_pool, &msgbuf);
+  msgbuf->type = MSGBUF_TYPE_COMMAND;
+  EXPECT_NE(msgbuf, nullptr);
+  EXPECT_NE(msgbuf_id_is_valid((unsigned long)msgbuf_id), 0);
+
+#ifndef NDEBUG
+  // Release the msgbuf even if it is not been acquired
+  ASSERT_DEATH(
+      {
+        msgbuf_pool_release(msgbuf_pool, &msgbuf);
+        ;
+      },
+      ".*Assertion.*");
+#endif
+}
+
+TEST_F(MsgbufPoolTest, MultipleAcquireAndReleaseMsgbuf) {
+  msgbuf_t *msgbuf = NULL;
+
+  // Get msgbuf from msgbuf_pool
+  off_t msgbuf_id = msgbuf_pool_get(msgbuf_pool, &msgbuf);
+  msgbuf->type = MSGBUF_TYPE_COMMAND;
+  EXPECT_NE(msgbuf, nullptr);
+  EXPECT_NE(msgbuf_id_is_valid((unsigned long)msgbuf_id), 0);
+
+  // Acquire the msgbuf multiple times
+  msgbuf_pool_acquire(msgbuf);
+  msgbuf_pool_acquire(msgbuf);
+  EXPECT_EQ(msgbuf->refs, 2u);
+
+  // Release the msgbuf
+  msgbuf_pool_release(msgbuf_pool, &msgbuf);
+  EXPECT_NE(msgbuf, nullptr);
+  EXPECT_EQ(msgbuf->refs, 1u);
+  msgbuf_pool_release(msgbuf_pool, &msgbuf);
+  EXPECT_EQ(msgbuf, nullptr);
+}
+
+TEST_F(MsgbufPoolTest, CloneMsgbuf) {
+  msgbuf_t *msgbuf = NULL;
+  off_t msgbuf_id = msgbuf_pool_get(msgbuf_pool, &msgbuf);
+  msgbuf->type = MSGBUF_TYPE_COMMAND;
+  EXPECT_NE(msgbuf, nullptr);
+  EXPECT_NE(msgbuf_id_is_valid((unsigned long)msgbuf_id), 0);
+
+  msgbuf_t *new_msgbuf;
+  off_t new_msg_id = msgbuf_pool_clone(msgbuf_pool, &new_msgbuf, msgbuf_id);
+
+  EXPECT_EQ(new_msgbuf, msgbuf_pool_at(msgbuf_pool, new_msg_id));
+  EXPECT_NE(new_msgbuf, msgbuf_pool_at(msgbuf_pool, msgbuf_id));
+  EXPECT_NE(new_msgbuf, msgbuf);
+  EXPECT_TRUE(memcmp(msgbuf, new_msgbuf, sizeof(msgbuf_t)) == 0);
+}
diff --git a/hicn-light/src/hicn/test/test-nexthops.cc b/hicn-light/src/hicn/test/test-nexthops.cc
new file mode 100644
index 000000000..9063298fd
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-nexthops.cc
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/core/nexthops.h>
+#include <hicn/core/strategy.h>
+}
+
+#define NEXTHOP1 50
+#define NEXTHOP2 51
+#define NEXTHOP3 52
+
+class NexthopsTest : public ::testing::Test {
+ protected:
+  NexthopsTest() {}
+
+  virtual ~NexthopsTest() {}
+
+  nexthops_t nexthops;
+};
+
+TEST_F(NexthopsTest, NexthopsAdd) {
+  nexthops = NEXTHOPS_EMPTY;
+  nexthops_add(&nexthops, NEXTHOP1);
+
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 1);
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP1));
+
+  nexthops_add(&nexthops, NEXTHOP2);
+  nexthops_add(&nexthops, NEXTHOP3);
+
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP3));
+}
+
+TEST_F(NexthopsTest, NexthopsRemove) {
+  nexthops = NEXTHOPS_EMPTY;
+  nexthops_add(&nexthops, NEXTHOP1);
+  nexthops_add(&nexthops, NEXTHOP2);
+  nexthops_add(&nexthops, NEXTHOP3);
+
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP3));
+
+  nexthops_remove(&nexthops, NEXTHOP2);
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 2);
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP3));
+
+  nexthops_remove(&nexthops, NEXTHOP3);
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 1);
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP3));
+
+  nexthops_remove(&nexthops, NEXTHOP3);
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 1);
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP3));
+
+  nexthops_remove(&nexthops, NEXTHOP1);
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 0);
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP3));
+}
+
+TEST_F(NexthopsTest, NexthopsClear) {
+  nexthops = NEXTHOPS_EMPTY;
+  nexthops_add(&nexthops, NEXTHOP1);
+  nexthops_add(&nexthops, NEXTHOP2);
+  nexthops_add(&nexthops, NEXTHOP3);
+
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP3));
+
+  nexthops_clear(&nexthops);
+
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 0);
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP3));
+}
+
+TEST_F(NexthopsTest, NexthopsGetOne) {
+  nexthops = NEXTHOPS_EMPTY;
+  nexthops_add(&nexthops, NEXTHOP1);
+  nexthops_add(&nexthops, NEXTHOP2);
+  nexthops_add(&nexthops, NEXTHOP3);
+
+  unsigned nexthop = nexthops_get_one(&nexthops);
+
+  EXPECT_TRUE(nexthops_contains(&nexthops, nexthop));
+}
+
+TEST_F(NexthopsTest, NexthopsSelect) {
+  int ret;
+  nexthops = NEXTHOPS_EMPTY;
+  nexthops_add(&nexthops, NEXTHOP1);
+  nexthops_add(&nexthops, NEXTHOP2);
+  nexthops_add(&nexthops, NEXTHOP3);
+
+  ret = nexthops_select(&nexthops, 2);
+
+  EXPECT_TRUE(ret == 0);
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_get_curlen(&nexthops) == 1);
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP3));
+
+  ret = nexthops_select(&nexthops, 0);
+
+  EXPECT_TRUE(ret == 0);
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_get_curlen(&nexthops) == 1);
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP3));
+
+  nexthops_reset(&nexthops);
+
+  EXPECT_TRUE(ret == 0);
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_get_curlen(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP3));
+
+  ret = nexthops_select(&nexthops, 4);
+
+  EXPECT_TRUE(ret == -1);
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_get_curlen(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP3));
+
+  ret = nexthops_select(&nexthops, 3);
+
+  EXPECT_TRUE(ret == -1);
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_get_curlen(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP3));
+}
+
+TEST_F(NexthopsTest, NexthopsDisable) {
+  int ret;
+  nexthops = NEXTHOPS_EMPTY;
+  nexthops_add(&nexthops, NEXTHOP1);
+  nexthops_add(&nexthops, NEXTHOP2);
+  nexthops_add(&nexthops, NEXTHOP3);
+
+  ret = nexthops_disable(&nexthops, 0);
+
+  EXPECT_TRUE(ret == 0);
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_get_curlen(&nexthops) == 2);
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP3));
+
+  ret = nexthops_disable(&nexthops, 2);
+
+  EXPECT_TRUE(ret == 0);
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_get_curlen(&nexthops) == 1);
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP3));
+
+  ret = nexthops_disable(&nexthops, 3);
+  EXPECT_TRUE(ret == -1);
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 3);
+  EXPECT_TRUE(nexthops_get_curlen(&nexthops) == 1);
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP3));
+}
+
+TEST_F(NexthopsTest, NexthopsState) {
+  strategy_nexthop_state_t state;
+  nexthops = NEXTHOPS_EMPTY;
+  nexthops_add(&nexthops, NEXTHOP1);
+  nexthops_add(&nexthops, NEXTHOP2);
+  nexthops_add(&nexthops, NEXTHOP3);
+  nexthops.state[0].load_balancer.pi = 100;
+  nexthops.state[1].load_balancer.pi = 200;
+  nexthops.state[2].load_balancer.pi = 300;
+
+  state = nexthops_state(&nexthops, 0);
+  EXPECT_TRUE(state.load_balancer.pi == 100);
+
+  state = nexthops_state(&nexthops, 1);
+  EXPECT_TRUE(state.load_balancer.pi == 200);
+
+  state = nexthops_state(&nexthops, 2);
+  EXPECT_TRUE(state.load_balancer.pi == 300);
+
+  nexthops_remove(&nexthops, NEXTHOP1);
+  EXPECT_TRUE(nexthops_get_len(&nexthops) == 2);
+  EXPECT_FALSE(nexthops_contains(&nexthops, NEXTHOP1));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP2));
+  EXPECT_TRUE(nexthops_contains(&nexthops, NEXTHOP3));
+
+  state = nexthops_state(&nexthops, 0);
+  EXPECT_TRUE(state.load_balancer.pi == 300);
+
+  state = nexthops_state(&nexthops, 1);
+  EXPECT_TRUE(state.load_balancer.pi == 200);
+}
+
+TEST_F(NexthopsTest, NexthopsEqual) {
+  nexthops = NEXTHOPS_EMPTY;
+  nexthops_t nexthops_eq = NEXTHOPS_EMPTY;
+  nexthops_t nexthops_not_eq = NEXTHOPS_EMPTY;
+
+  nexthops_add(&nexthops, NEXTHOP1);
+  nexthops_add(&nexthops, NEXTHOP3);
+  nexthops_add(&nexthops_eq, NEXTHOP1);
+  nexthops_add(&nexthops_eq, NEXTHOP3);
+  nexthops_add(&nexthops_not_eq, NEXTHOP2);
+
+  bool ret = nexthops_equal(&nexthops, &nexthops_eq);
+  EXPECT_TRUE(ret);
+
+  ret = nexthops_equal(&nexthops, &nexthops_not_eq);
+  EXPECT_FALSE(ret);
+}
+
+TEST_F(NexthopsTest, NexthopsCopy) {
+  nexthops = NEXTHOPS_EMPTY;
+  nexthops_t nexthops_eq = NEXTHOPS_EMPTY;
+
+  nexthops_add(&nexthops, NEXTHOP1);
+  nexthops_add(&nexthops, NEXTHOP3);
+  nexthops_copy(&nexthops, &nexthops_eq);
+
+  bool ret = nexthops_equal(&nexthops, &nexthops_eq);
+  EXPECT_TRUE(ret);
+}
diff --git a/hicn-light/src/hicn/test/test-packet_cache.cc b/hicn-light/src/hicn/test/test-packet_cache.cc
new file mode 100644
index 000000000..bb24daeb8
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-packet_cache.cc
@@ -0,0 +1,524 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <thread>
+#include <optional>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/core/packet_cache.h>
+}
+
+const unsigned CS_SIZE = 100;
+const unsigned CONN_ID = 0;
+const unsigned CONN_ID_2 = 1;
+const unsigned MSGBUF_ID = 0;
+const unsigned MSGBUF_ID_2 = 1;
+const unsigned MSGBUF_ID_3 = 2;
+const unsigned FIVE_SECONDS = 5000;
+const unsigned IPV4_LEN = 32;
+const unsigned IPV6_LEN = 128;
+
+class PacketCacheTest : public ::testing::Test {
+ protected:
+  PacketCacheTest() {
+    pkt_cache = pkt_cache_create(CS_SIZE);
+    name = (Name *)malloc(sizeof(Name));
+    name_CreateFromAddress(name, AF_INET, IPV4_ANY, IPV4_LEN);
+    msgbuf_pool = msgbuf_pool_create();
+  }
+  virtual ~PacketCacheTest() {
+    pkt_cache_free(pkt_cache);
+    msgbuf_pool_free(msgbuf_pool);
+  }
+
+  pkt_cache_t *pkt_cache;
+  pkt_cache_entry_t *entry = nullptr;
+  msgbuf_pool_t *msgbuf_pool;
+  Name *name;
+};
+
+msgbuf_t *msgbuf_factory(msgbuf_pool_t *msgbuf_pool, unsigned conn_id,
+                         Name *name,
+                         std::optional<Ticks> lifetime = FIVE_SECONDS) {
+  msgbuf_t *msgbuf;
+  msgbuf_pool_get(msgbuf_pool, &msgbuf);
+
+  msgbuf->connection_id = conn_id;
+  name_Copy(name, msgbuf_get_name(msgbuf));
+  hicn_packet_init_header(HF_INET6_TCP,
+                          (hicn_header_t *)msgbuf_get_packet(msgbuf));
+  // Same as 'msgbuf_set_data_expiry_time',
+  // it would write in the same field
+  msgbuf_set_interest_lifetime(msgbuf, *lifetime);
+
+  return msgbuf;
+}
+
+TEST_F(PacketCacheTest, CreatePacketCache) {
+  // Check packet cache allocation
+  EXPECT_NE(pkt_cache, nullptr);
+  pit_t *pit = pkt_cache_get_pit(pkt_cache);
+  ASSERT_NE(pit, nullptr);
+  cs_t *cs = pkt_cache_get_cs(pkt_cache);
+  ASSERT_NE(cs, nullptr);
+
+  // Check sizes
+  ASSERT_EQ(pkt_cache_get_size(pkt_cache), 0u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 0u);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 0u);
+}
+
+TEST_F(PacketCacheTest, AddPacketCacheEntry) {
+  // Add entry to the packet cache
+  entry = pkt_cache_allocate(pkt_cache, name);
+  EXPECT_NE(entry, nullptr);
+  ASSERT_EQ(pkt_cache_get_size(pkt_cache), 1u);
+
+  // // Get entry by name
+  Name name_key = name_key_factory(name);
+  khiter_t k = kh_get_pkt_cache_name(pkt_cache->index_by_name, &name_key);
+  EXPECT_NE(k, kh_end(pkt_cache->index_by_name));
+}
+
+TEST_F(PacketCacheTest, GetCS) {
+  cs_t *cs = pkt_cache_get_cs(pkt_cache);
+  ASSERT_NE(cs, nullptr);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 0u);
+
+  EXPECT_EQ(cs->type, CS_TYPE_LRU);
+  EXPECT_EQ(cs->num_entries, 0);
+  EXPECT_EQ(cs->lru.head, (off_t)INVALID_ENTRY_ID);
+  EXPECT_EQ(cs->lru.tail, (off_t)INVALID_ENTRY_ID);
+}
+
+TEST_F(PacketCacheTest, GetPIT) {
+  pit_t *pit = pkt_cache_get_pit(pkt_cache);
+  ASSERT_NE(pit, nullptr);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 0u);
+}
+
+TEST_F(PacketCacheTest, LookupEmpty) {
+  pkt_cache_lookup_t lookup_result;
+  off_t entry_id;
+  pkt_cache_entry_t *entry = pkt_cache_lookup(pkt_cache, name, msgbuf_pool,
+                                              &lookup_result, &entry_id, true);
+
+  EXPECT_EQ(lookup_result, PKT_CACHE_LU_NONE);
+  EXPECT_EQ(entry, nullptr);
+}
+
+TEST_F(PacketCacheTest, AddEntryAndLookup) {
+  // Add entry to the packet cache
+  entry = pkt_cache_allocate(pkt_cache, name);
+  entry->entry_type = PKT_CACHE_PIT_TYPE;
+  ASSERT_NE(entry, nullptr);
+
+  // Perform lookup
+  pkt_cache_lookup_t lookup_result;
+  off_t entry_id;
+  pkt_cache_entry_t *lu_entry = pkt_cache_lookup(
+      pkt_cache, name, msgbuf_pool, &lookup_result, &entry_id, true);
+
+  EXPECT_TRUE(lookup_result == PKT_CACHE_LU_INTEREST_NOT_EXPIRED ||
+              lookup_result == PKT_CACHE_LU_INTEREST_EXPIRED);
+  EXPECT_NE(lu_entry, nullptr);
+  EXPECT_EQ(lu_entry, entry);
+}
+
+TEST_F(PacketCacheTest, AddToPIT) {
+  // Prepare msgbuf
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name);
+
+  // Check if entry properly created
+  pkt_cache_entry_t *entry = pkt_cache_add_to_pit(pkt_cache, msgbuf);
+  ASSERT_NE(entry, nullptr);
+  EXPECT_EQ(entry->entry_type, PKT_CACHE_PIT_TYPE);
+  EXPECT_EQ(pit_entry_ingress_contains(&entry->u.pit_entry, CONN_ID), true);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 1u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 0u);
+
+  // Check if hashtable correctly updated
+  pkt_cache_lookup_t lookup_result;
+  off_t entry_id;
+  pkt_cache_entry_t *lu_entry = pkt_cache_lookup(
+      pkt_cache, name, msgbuf_pool, &lookup_result, &entry_id, true);
+  EXPECT_EQ(lookup_result, PKT_CACHE_LU_INTEREST_NOT_EXPIRED);
+  EXPECT_EQ(lu_entry, entry);
+}
+
+TEST_F(PacketCacheTest, AddToCS) {
+  // Prepare msgbuf
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name);
+
+  // Check if entry properly created
+  pkt_cache_entry_t *entry =
+      pkt_cache_add_to_cs(pkt_cache, msgbuf_pool, msgbuf, MSGBUF_ID);
+  cs_entry_t *cs_entry = &entry->u.cs_entry;
+  ASSERT_NE(entry, nullptr);
+  EXPECT_EQ(entry->entry_type, PKT_CACHE_CS_TYPE);
+  EXPECT_EQ(cs_entry->msgbuf_id, MSGBUF_ID);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 0u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 1u);
+
+  // Check if CS properly updated
+  cs_t *cs = pkt_cache_get_cs(pkt_cache);
+  off_t entry_id = pkt_cache_get_entry_id(pkt_cache, entry);
+  EXPECT_EQ(cs->num_entries, 1);
+  EXPECT_EQ(cs->lru.head, entry_id);
+  EXPECT_EQ(cs->lru.tail, entry_id);
+
+  // Check if hashtable correctly updated
+  pkt_cache_lookup_t lookup_result;
+  pkt_cache_entry_t *lu_entry = pkt_cache_lookup(
+      pkt_cache, name, msgbuf_pool, &lookup_result, &entry_id, true);
+  EXPECT_EQ(lookup_result, PKT_CACHE_LU_DATA_NOT_EXPIRED);
+  EXPECT_EQ(lu_entry, entry);
+}
+
+TEST_F(PacketCacheTest, PitToCS) {
+  // Prepare msgbuf and PIT entry
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name);
+  pkt_cache_entry_t *entry = pkt_cache_add_to_pit(pkt_cache, msgbuf);
+  off_t entry_id = pkt_cache_get_entry_id(pkt_cache, entry);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 1u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 0u);
+
+  // Check if entry properly updated
+  pkt_cache_pit_to_cs(pkt_cache, entry, msgbuf_pool, msgbuf, MSGBUF_ID,
+                      entry_id);
+  cs_entry_t *cs_entry = &entry->u.cs_entry;
+  ASSERT_NE(entry, nullptr);
+  EXPECT_EQ(entry->entry_type, PKT_CACHE_CS_TYPE);
+  EXPECT_EQ(cs_entry->msgbuf_id, MSGBUF_ID);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 0u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 1u);
+
+  // Check if CS properly updated
+  cs_t *cs = pkt_cache_get_cs(pkt_cache);
+  entry_id = pkt_cache_get_entry_id(pkt_cache, entry);
+  EXPECT_EQ(cs->num_entries, 1);
+  EXPECT_EQ(cs->lru.head, entry_id);
+  EXPECT_EQ(cs->lru.tail, entry_id);
+
+  // Check if hashtable correctly updated
+  pkt_cache_lookup_t lookup_result;
+  pkt_cache_entry_t *lu_entry = pkt_cache_lookup(
+      pkt_cache, name, msgbuf_pool, &lookup_result, &entry_id, true);
+  EXPECT_EQ(lookup_result, PKT_CACHE_LU_DATA_NOT_EXPIRED);
+  EXPECT_EQ(lu_entry, entry);
+}
+
+TEST_F(PacketCacheTest, CsToPIT) {
+  // Prepare msgbuf and CS entry
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name);
+  pkt_cache_entry_t *entry =
+      pkt_cache_add_to_cs(pkt_cache, msgbuf_pool, msgbuf, MSGBUF_ID);
+  off_t entry_id = pkt_cache_get_entry_id(pkt_cache, entry);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 0u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 1u);
+
+  // Check if entry properly updated
+  pkt_cache_cs_to_pit(pkt_cache, entry, msgbuf_pool, msgbuf, MSGBUF_ID,
+                      entry_id);
+  ASSERT_NE(entry, nullptr);
+  EXPECT_EQ(entry->entry_type, PKT_CACHE_PIT_TYPE);
+  EXPECT_EQ(pit_entry_ingress_contains(&entry->u.pit_entry, CONN_ID), true);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 1u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 0u);
+
+  // Check if hashtable correctly updated
+  pkt_cache_lookup_t lookup_result;
+  pkt_cache_entry_t *lu_entry = pkt_cache_lookup(
+      pkt_cache, name, msgbuf_pool, &lookup_result, &entry_id, true);
+  EXPECT_EQ(lookup_result, PKT_CACHE_LU_INTEREST_NOT_EXPIRED);
+  EXPECT_EQ(lu_entry, entry);
+}
+
+TEST_F(PacketCacheTest, UpdateInPIT) {
+  // Prepare msgbuf and PIT entry
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name);
+  pkt_cache_entry_t *entry = pkt_cache_add_to_pit(pkt_cache, msgbuf);
+  off_t entry_id = pkt_cache_get_entry_id(pkt_cache, entry);
+
+  Name new_name;
+  name_CreateFromAddress(&new_name, AF_INET, IPV4_LOOPBACK, IPV4_LEN);
+  msgbuf_t *new_msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID_2, &new_name);
+
+  // Check if entry properly updated
+  pkt_cache_update_pit(pkt_cache, entry, new_msgbuf);
+  ASSERT_NE(entry, nullptr);
+  EXPECT_EQ(entry->entry_type, PKT_CACHE_PIT_TYPE);
+  EXPECT_EQ(pit_entry_ingress_contains(&entry->u.pit_entry, CONN_ID_2), true);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 1u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 0u);
+
+  // Check if hashtable correctly updated
+  pkt_cache_lookup_t lookup_result;
+  pkt_cache_entry_t *lu_entry = pkt_cache_lookup(
+      pkt_cache, name, msgbuf_pool, &lookup_result, &entry_id, true);
+  EXPECT_EQ(lookup_result, PKT_CACHE_LU_INTEREST_NOT_EXPIRED);
+  EXPECT_EQ(lu_entry, entry);
+}
+
+TEST_F(PacketCacheTest, UpdateInCS) {
+  // Prepare msgbuf and CS entry
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name);
+  pkt_cache_entry_t *entry =
+      pkt_cache_add_to_cs(pkt_cache, msgbuf_pool, msgbuf, MSGBUF_ID);
+  off_t entry_id = pkt_cache_get_entry_id(pkt_cache, entry);
+
+  Name new_name;
+  name_CreateFromAddress(&new_name, AF_INET, IPV4_LOOPBACK, IPV4_LEN);
+  msgbuf_t *new_msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID_2, &new_name);
+
+  // Check if entry properly updated
+  pkt_cache_update_cs(pkt_cache, msgbuf_pool, entry, new_msgbuf, MSGBUF_ID_2);
+  cs_entry_t *cs_entry = &entry->u.cs_entry;
+  ASSERT_NE(entry, nullptr);
+  EXPECT_EQ(entry->entry_type, PKT_CACHE_CS_TYPE);
+  EXPECT_EQ(cs_entry->msgbuf_id, MSGBUF_ID_2);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 0u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 1u);
+
+  // Check if hashtable correctly updated
+  pkt_cache_lookup_t lookup_result;
+  pkt_cache_entry_t *lu_entry = pkt_cache_lookup(
+      pkt_cache, name, msgbuf_pool, &lookup_result, &entry_id, true);
+  EXPECT_EQ(lookup_result, PKT_CACHE_LU_DATA_NOT_EXPIRED);
+  EXPECT_EQ(lu_entry, entry);
+}
+
+TEST_F(PacketCacheTest, RemoveFromPIT) {
+  // Prepare msgbuf and PIT entry
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name);
+  pkt_cache_entry_t *entry = pkt_cache_add_to_pit(pkt_cache, msgbuf);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 1u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 0u);
+
+  pkt_cache_pit_remove_entry(pkt_cache, entry, name);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 0u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 0u);
+
+  // Check if hashtable correctly updated
+  pkt_cache_lookup_t lookup_result;
+  off_t entry_id;
+  pkt_cache_entry_t *lu_entry = pkt_cache_lookup(
+      pkt_cache, name, msgbuf_pool, &lookup_result, &entry_id, true);
+  EXPECT_EQ(lookup_result, PKT_CACHE_LU_NONE);
+  EXPECT_EQ(lu_entry, nullptr);
+}
+
+TEST_F(PacketCacheTest, RemoveFromCS) {
+  // Prepare msgbuf and CS entry
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name);
+  pkt_cache_entry_t *entry =
+      pkt_cache_add_to_cs(pkt_cache, msgbuf_pool, msgbuf, MSGBUF_ID);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 0u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 1u);
+
+  pkt_cache_cs_remove_entry(pkt_cache, entry, msgbuf_pool, false);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 0u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 0u);
+
+  // Check if CS properly updated
+  cs_t *cs = pkt_cache_get_cs(pkt_cache);
+  EXPECT_EQ(cs->num_entries, 0);
+  EXPECT_EQ(cs->lru.head, (off_t)INVALID_ENTRY_ID);
+  EXPECT_EQ(cs->lru.tail, (off_t)INVALID_ENTRY_ID);
+
+  // Check if hashtable correctly updated
+  pkt_cache_lookup_t lookup_result;
+  off_t entry_id;
+  pkt_cache_entry_t *lu_entry = pkt_cache_lookup(
+      pkt_cache, name, msgbuf_pool, &lookup_result, &entry_id, true);
+  EXPECT_EQ(lookup_result, PKT_CACHE_LU_NONE);
+  EXPECT_EQ(lu_entry, nullptr);
+}
+
+TEST_F(PacketCacheTest, AddTwoEntriesToCS) {
+  // Prepare msgbufs
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name);
+  Name new_name;
+  name_CreateFromAddress(&new_name, AF_INET, IPV4_LOOPBACK, IPV4_LEN);
+  msgbuf_t *new_msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID_2, &new_name);
+
+  pkt_cache_entry_t *entry_1 =
+      pkt_cache_add_to_cs(pkt_cache, msgbuf_pool, msgbuf, MSGBUF_ID);
+  pkt_cache_entry_t *entry_2 =
+      pkt_cache_add_to_cs(pkt_cache, msgbuf_pool, new_msgbuf, MSGBUF_ID_2);
+  off_t entry_id_1 = pkt_cache_get_entry_id(pkt_cache, entry_1);
+  off_t entry_id_2 = pkt_cache_get_entry_id(pkt_cache, entry_2);
+
+  // Check if the CS and LRU cache are properly updated
+  cs_t *cs = pkt_cache_get_cs(pkt_cache);
+  EXPECT_EQ(cs->num_entries, 2);
+  EXPECT_EQ(cs->lru.head, entry_id_2);
+  EXPECT_EQ(cs->lru.tail, entry_id_1);
+  ASSERT_EQ(pkt_cache_get_pit_size(pkt_cache), 0u);
+  ASSERT_EQ(pkt_cache_get_cs_size(pkt_cache), 2u);
+}
+
+TEST_F(PacketCacheTest, AggregateInPIT) {
+  // Prepare msgbufs
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name);
+  Name new_name;
+  name_CreateFromAddress(&new_name, AF_INET, IPV4_LOOPBACK, IPV4_LEN);
+  msgbuf_t *new_msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID_2, &new_name);
+
+  // Check if entry properly created (use sleep to get an updated ts)
+  pkt_cache_entry_t *entry = pkt_cache_add_to_pit(pkt_cache, msgbuf);
+  Ticks old_lifetime = entry->expire_ts;
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  bool is_aggregated =
+      pkt_cache_try_aggregate_in_pit(pkt_cache, entry, new_msgbuf);
+  Ticks new_lifetime = entry->expire_ts;
+
+  ASSERT_NE(entry, nullptr);
+  EXPECT_EQ(entry->entry_type, PKT_CACHE_PIT_TYPE);
+  EXPECT_GT(new_lifetime, old_lifetime);
+  ASSERT_EQ(is_aggregated, true);
+
+  // Check if hashtable correctly updated
+  pkt_cache_lookup_t lookup_result;
+  off_t entry_id;
+  pkt_cache_entry_t *lu_entry = pkt_cache_lookup(
+      pkt_cache, name, msgbuf_pool, &lookup_result, &entry_id, true);
+  EXPECT_EQ(lookup_result, PKT_CACHE_LU_INTEREST_NOT_EXPIRED);
+  EXPECT_EQ(lu_entry, entry);
+}
+
+TEST_F(PacketCacheTest, RetransmissionInPIT) {
+  // Prepare msgbufs (using same connection ID)
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name);
+  Name new_name;
+  name_CreateFromAddress(&new_name, AF_INET, IPV4_LOOPBACK, IPV4_LEN);
+  msgbuf_t *new_msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, &new_name);
+
+  // Check if entry properly created (use sleep to get an updated ts)
+  pkt_cache_entry_t *entry = pkt_cache_add_to_pit(pkt_cache, msgbuf);
+  Ticks old_lifetime = entry->expire_ts;
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  bool is_aggregated =
+      pkt_cache_try_aggregate_in_pit(pkt_cache, entry, new_msgbuf);
+  Ticks new_lifetime = entry->expire_ts;
+
+  ASSERT_NE(entry, nullptr);
+  EXPECT_EQ(entry->entry_type, PKT_CACHE_PIT_TYPE);
+  EXPECT_GT(new_lifetime, old_lifetime);
+  ASSERT_EQ(is_aggregated, false);
+
+  // Check if hashtable correctly updated
+  pkt_cache_lookup_t lookup_result;
+  off_t entry_id;
+  pkt_cache_entry_t *lu_entry = pkt_cache_lookup(
+      pkt_cache, name, msgbuf_pool, &lookup_result, &entry_id, true);
+  EXPECT_EQ(lookup_result, PKT_CACHE_LU_INTEREST_NOT_EXPIRED);
+  EXPECT_EQ(lu_entry, entry);
+}
+
+TEST_F(PacketCacheTest, LookupExpiredInterest) {
+  // Prepare msgbuf with 0 as interest lifetime
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name, 0);
+
+  // Add to PIT
+  pkt_cache_entry_t *entry = pkt_cache_add_to_pit(pkt_cache, msgbuf);
+  ASSERT_NE(entry, nullptr);
+
+  // Wait to make the interest expire
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+  pkt_cache_lookup_t lookup_result;
+  off_t entry_id;
+  pkt_cache_lookup(pkt_cache, name, msgbuf_pool, &lookup_result, &entry_id,
+                   true);
+  EXPECT_EQ(lookup_result, PKT_CACHE_LU_INTEREST_EXPIRED);
+}
+
+TEST_F(PacketCacheTest, LookupExpiredData) {
+  // Prepare msgbuf with 0 as data expiry time
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name, 0);
+
+  // Add to CS
+  pkt_cache_entry_t *entry =
+      pkt_cache_add_to_cs(pkt_cache, msgbuf_pool, msgbuf, MSGBUF_ID);
+  ASSERT_NE(entry, nullptr);
+
+  // Wait to make the interest expire
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+  pkt_cache_lookup_t lookup_result;
+  off_t entry_id;
+  pkt_cache_lookup(pkt_cache, name, msgbuf_pool, &lookup_result, &entry_id,
+                   true);
+  EXPECT_EQ(lookup_result, PKT_CACHE_LU_DATA_EXPIRED);
+}
+
+TEST_F(PacketCacheTest, GetStaleEntries) {
+  // Add to CS a msgbuf with immediate expiration (i.e. stale)
+  msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, CONN_ID, name, 0);
+  pkt_cache_add_to_cs(pkt_cache, msgbuf_pool, msgbuf, MSGBUF_ID);
+
+  // Add to CS another msgbuf with immediate expiration (i.e. stale)
+  Name name_2;
+  name_CreateFromAddress(&name_2, AF_INET, IPV4_LOOPBACK, IPV4_LEN);
+  msgbuf_t *msgbuf_2 = msgbuf_factory(msgbuf_pool, CONN_ID, &name_2, 0);
+  pkt_cache_add_to_cs(pkt_cache, msgbuf_pool, msgbuf_2, MSGBUF_ID_2);
+
+  // Add to CS a msgbuf with 5-seconds expiration (i.e. not stale)
+  Name name_3;
+  name_CreateFromAddress(&name_3, AF_INET6, IPV6_LOOPBACK, IPV6_LEN);
+  msgbuf_t *msgbuf_3 =
+      msgbuf_factory(msgbuf_pool, CONN_ID, &name_3, FIVE_SECONDS);
+  pkt_cache_add_to_cs(pkt_cache, msgbuf_pool, msgbuf_3, MSGBUF_ID_3);
+
+  size_t num_stale_entries = pkt_cache_get_num_cs_stale_entries(pkt_cache);
+  EXPECT_EQ(num_stale_entries, 2u);
+}
+
+TEST_F(PacketCacheTest, GetMultipleStaleEntries) {
+  ip_address_t addr;
+  char name[30];
+  const int NUM_STALES = 10;
+
+  // Add to CS multiple msgbufs with immediate expiration (i.e. 0 seconds),
+  // resulting in stale entries
+  for (int i = 0; i < NUM_STALES; i++) {
+    snprintf(name, 30, "b001::%d", i);
+    inet_pton(AF_INET6, name, (struct in6_addr *)&addr);
+    Name name;
+    name_CreateFromAddress(&name, AF_INET6, addr, IPV6_LEN);
+    msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, i, &name, 0);
+
+    pkt_cache_add_to_cs(pkt_cache, msgbuf_pool, msgbuf, i);
+  }
+
+  // Add to CS multiple msgbufs with 5-seconds expiration,
+  // resulting in non-stale entries
+  for (int i = NUM_STALES; i < 15; i++) {
+    snprintf(name, 30, "b001::%d", i);
+    inet_pton(AF_INET6, name, (struct in6_addr *)&addr);
+    Name name;
+    name_CreateFromAddress(&name, AF_INET6, addr, IPV6_LEN);
+    msgbuf_t *msgbuf = msgbuf_factory(msgbuf_pool, i, &name, FIVE_SECONDS);
+
+    pkt_cache_add_to_cs(pkt_cache, msgbuf_pool, msgbuf, i);
+  }
+
+  size_t num_stale_entries = pkt_cache_get_num_cs_stale_entries(pkt_cache);
+  EXPECT_EQ(num_stale_entries, (size_t)NUM_STALES);
+}
diff --git a/hicn-light/src/hicn/test/test-parser.cc b/hicn-light/src/hicn/test/test-parser.cc
new file mode 100644
index 000000000..3a8d2cdb2
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-parser.cc
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+extern "C" {
+#include <hicn/util/log.h>
+#include <hicn/config/parse.h>
+}
+
+class ParserTest : public ::testing::Test {
+ protected:
+  ParserTest() { log_conf.log_level = LOG_INFO; }
+  virtual ~ParserTest() {}
+
+  hc_command_t command_ = {};
+};
+
+TEST_F(ParserTest, AddValidListener) {
+  std::string cmd = "add listener udp udp0 10.0.0.1 9695 eth0";
+
+  ASSERT_EQ(parse(cmd.c_str(), &command_), 0);
+  EXPECT_EQ(command_.object.listener.type, FACE_TYPE_UDP_LISTENER);
+  EXPECT_EQ(std::string(command_.object.listener.name), "udp0");
+  EXPECT_EQ(command_.object.listener.family, AF_INET);
+  EXPECT_EQ(command_.object.listener.local_port, 9695);
+  EXPECT_EQ(std::string(command_.object.listener.interface_name), "eth0");
+}
+
+TEST_F(ParserTest, AddListenerSymbolicOverflow) {
+  std::string cmd =
+      "add listener udp super-long-symbolic-name 10.0.0.1 9696 eth0";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), -1);
+}
+
+TEST_F(ParserTest, AddListenerInvalidAddress) {
+  std::string cmd = "add listener udp udp0 10.0.0.0.1 9696 eth0";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), -1);
+}
+
+TEST_F(ParserTest, AddListenerInvalidAddressString) {
+  std::string cmd = "add listener udp udp0 invalid-addr 9696 eth0";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), -1);
+}
+
+TEST_F(ParserTest, AddListenerInvalidPortOutsideRange) {
+  std::string cmd = "add listener udp udp0 10.0.0.1 0 eth0";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), -1);
+}
+
+TEST_F(ParserTest, AddListenerInvalidPortString) {
+  std::string cmd = "add listener udp udp0 10.0.0.1 invalid-port eth0";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), -1);
+}
+
+TEST_F(ParserTest, UnknownCommnad) {
+  std::string cmd = "add face";
+  ASSERT_EQ(parse(cmd.c_str(), &command_), -1);
+}
\ No newline at end of file
diff --git a/hicn-light/src/hicn/test/test-pool.cc b/hicn-light/src/hicn/test/test-pool.cc
new file mode 100644
index 000000000..c631415ca
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-pool.cc
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <netinet/in.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/base/pool.h>
+}
+
+/*
+ * TODO
+ * - test max_size
+ */
+
+#define DEFAULT_SIZE 10
+
+class PoolTest : public ::testing::Test {
+ protected:
+  PoolTest() {}
+  virtual ~PoolTest() {}
+
+  int *pool;
+};
+
+TEST_F(PoolTest, PoolAllocation) {
+  int rc;
+
+  pool_init(pool, DEFAULT_SIZE, 0);
+
+  size_t pool_size = next_pow2(DEFAULT_SIZE);
+
+  EXPECT_EQ(pool_get_alloc_size(pool), pool_size);
+
+  /* Check that free indices and bitmaps are correctly initialize */
+  off_t *fi = pool_get_free_indices(pool);
+  EXPECT_EQ(vector_len(fi), pool_size);
+  EXPECT_EQ(fi[0], (long)(pool_size - 1));
+  EXPECT_EQ(fi[pool_size - 1], 0);
+
+  /* The allocated size of the underlying vector should be the next power of two
+   */
+  EXPECT_EQ(vector_get_alloc_size(fi), pool_size);
+
+  bitmap_t *fb = pool_get_free_bitmap(pool);
+  EXPECT_TRUE(bitmap_is_set(fb, 0));
+  EXPECT_TRUE(bitmap_is_set(fb, pool_size - 2));
+  EXPECT_TRUE(bitmap_is_set(fb, pool_size - 1));
+  EXPECT_TRUE(bitmap_is_unset(fb, pool_size));
+
+  /* Getting elements from the pool should correctly update the free indices
+   * and bitmap */
+  int *elt;
+
+  rc = pool_get(pool, elt);
+  EXPECT_GE(rc, 0);
+  EXPECT_EQ(vector_len(fi), pool_size - 1);
+  EXPECT_TRUE(bitmap_is_unset(fb, 0));
+
+  rc = pool_get(pool, elt);
+  EXPECT_GE(rc, 0);
+  EXPECT_EQ(vector_len(fi), pool_size - 2);
+  EXPECT_TRUE(bitmap_is_unset(fb, 1));
+
+  for (unsigned i = 0; i < pool_size - 4; i++) {
+    rc = pool_get(pool, elt);
+    EXPECT_GE(rc, 0);
+  }
+
+  rc = pool_get(pool, elt);
+  EXPECT_GE(rc, 0);
+  EXPECT_EQ(vector_len(fi), 1UL);
+  EXPECT_TRUE(bitmap_is_unset(fb, pool_size - 2));
+
+  rc = pool_get(pool, elt);
+  EXPECT_GE(rc, 0);
+  EXPECT_EQ(vector_len(fi), 0UL);
+  EXPECT_TRUE(bitmap_is_unset(fb, pool_size - 1));
+
+  /*
+   * Getting elements within the allocated range should not have triggered a
+   * resize
+   */
+  EXPECT_EQ(pool_len(pool), pool_size);
+
+  /*
+   * Getting elements once the allocated range has been exceeded should
+   * trigger a resize
+   */
+  rc = pool_get(pool, elt);
+  EXPECT_GE(rc, 0);
+
+  EXPECT_EQ(pool_get_alloc_size(pool), pool_size * 2);
+
+  EXPECT_EQ(pool_len(pool), pool_size + 1);
+
+  /*
+   * Doubling the size, we should have again pool_size elements free, minus 1
+   */
+  EXPECT_EQ(pool_get_free_indices_size(pool), pool_size - 1);
+
+  /*
+   * NOTE: this is wrong as there has been a realloc and the old fi
+   * pointer is now invalid
+   */
+  // EXPECT_EQ(vector_len(fi), pool_size - 1);
+
+  /* And the bitmap should also be correctly modified */
+  fb = pool_get_free_bitmap(pool);
+  EXPECT_TRUE(bitmap_is_unset(fb, pool_size));
+
+  /* Check that surrounding values are also correct */
+  EXPECT_TRUE(bitmap_is_unset(fb, pool_size - 1));
+  EXPECT_TRUE(bitmap_is_set(fb, pool_size + 1));
+
+  /* Setting elements after should through */
+
+  /* Check that free indices and bitmaps are correctly updated */
+
+  pool_free(pool);
+}
+
+TEST_F(PoolTest, PoolPut) {
+  pool_init(pool, DEFAULT_SIZE, 0);
+
+  int *elt;
+  pool_get(pool, elt);
+  *elt = 10;
+  pool_put(pool, elt);
+
+  pool_free(pool);
+}
+
+TEST_F(PoolTest, PoolGetForceBitmapRealloc) {
+  const int N = 64;
+  int *elts[N];
+  int *elt = NULL;
+  pool_init(pool, N, 0);
+
+  for (int i = 0; i < N; i++) pool_get(pool, elts[i]);
+  pool_get(pool, elt);
+
+  pool_free(pool);
+}
+
+TEST_F(PoolTest, PoolGetAfterReleasing) {
+  int *elt1 = NULL, *elt2 = NULL, *tmp = NULL;
+  pool_init(pool, DEFAULT_SIZE, 0);
+
+  // If two elements are requested...
+  off_t id1 = pool_get(pool, elt1);
+  pool_get(pool, tmp);
+
+  // ...and the first one is released...
+  pool_put(pool, elt1);
+
+  // ...requesting a new one should return
+  // the first one (that was freed)
+  off_t id2 = pool_get(pool, elt2);
+  EXPECT_EQ(id1, id2);
+  EXPECT_EQ(elt1, elt2);
+
+  pool_free(pool);
+}
+
+TEST_F(PoolTest, PoolGetMultipleElementsAfterReleasing) {
+  const int N = 2;
+  int *elts[N];
+  pool_init(pool, N, 0);
+
+  for (int i = 0; i < N; i++) pool_get(pool, elts[i]);
+  for (int i = 0; i < N; i++) pool_put(pool, elts[i]);
+  for (int i = 0; i < N; i++) pool_get(pool, elts[i]);
+
+  pool_free(pool);
+}
diff --git a/hicn-light/src/hicn/test/test-probe_generator.cc b/hicn-light/src/hicn/test/test-probe_generator.cc
new file mode 100644
index 000000000..4d6cfa8f7
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-probe_generator.cc
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/strategies/probe_generator.h>
+}
+
+class ProbeGeneratorTest : public ::testing::Test {
+ protected:
+  ProbeGeneratorTest() {}
+
+  virtual ~ProbeGeneratorTest() {}
+};
+
+TEST_F(ProbeGeneratorTest, ProbeGeneratorRegisterProbe) {
+  probe_generator_t *pg = create_probe_generator();
+  EXPECT_FALSE(pg == nullptr);
+
+  register_probe(pg, 1);
+  register_probe(pg, 2);
+  register_probe(pg, 3);
+  register_probe(pg, 4);
+
+  Ticks t = get_probe_send_time(pg, 1);
+  EXPECT_TRUE(t != 0);
+
+  t = get_probe_send_time(pg, 2);
+  EXPECT_TRUE(t != 0);
+
+  t = get_probe_send_time(pg, 3);
+  EXPECT_TRUE(t != 0);
+
+  t = get_probe_send_time(pg, 4);
+  EXPECT_TRUE(t != 0);
+
+  t = get_probe_send_time(pg, 5);
+  EXPECT_FALSE(t != 0);
+
+  destroy_probe_generator(pg);
+}
+
+TEST_F(ProbeGeneratorTest, ProbeGeneratorTime) {
+  probe_generator_t *pg = create_probe_generator();
+  EXPECT_FALSE(pg == nullptr);
+
+  Ticks t1 = register_probe(pg, 1);
+  Ticks t2 = get_probe_send_time(pg, 1);
+
+  EXPECT_TRUE(t2 != 0);
+  EXPECT_TRUE(t1 == t2);
+
+  destroy_probe_generator(pg);
+}
+
+TEST_F(ProbeGeneratorTest, ProbeGeneratorDeleteProbe) {
+  probe_generator_t *pg = create_probe_generator();
+  EXPECT_FALSE(pg == nullptr);
+
+  register_probe(pg, 1);
+  register_probe(pg, 2);
+  register_probe(pg, 3);
+  register_probe(pg, 4);
+
+  Ticks t = get_probe_send_time(pg, 1);
+  EXPECT_TRUE(t != 0);
+
+  t = get_probe_send_time(pg, 2);
+  EXPECT_TRUE(t != 0);
+
+  t = get_probe_send_time(pg, 3);
+  EXPECT_TRUE(t != 0);
+
+  t = get_probe_send_time(pg, 4);
+  EXPECT_TRUE(t != 0);
+
+  t = get_probe_send_time(pg, 5);
+  EXPECT_FALSE(t != 0);
+
+  delete_probe(pg, 1);
+  delete_probe(pg, 3);
+
+  t = get_probe_send_time(pg, 1);
+  EXPECT_FALSE(t != 0);
+
+  t = get_probe_send_time(pg, 3);
+  EXPECT_FALSE(t != 0);
+
+  destroy_probe_generator(pg);
+}
+
+TEST_F(ProbeGeneratorTest, ProbeGeneratorDeleteAll) {
+  probe_generator_t *pg = create_probe_generator();
+  EXPECT_FALSE(pg == nullptr);
+
+  register_probe(pg, 1);
+  register_probe(pg, 2);
+  register_probe(pg, 3);
+  register_probe(pg, 4);
+
+  Ticks t = get_probe_send_time(pg, 1);
+  EXPECT_TRUE(t != 0);
+
+  t = get_probe_send_time(pg, 2);
+  EXPECT_TRUE(t != 0);
+
+  t = get_probe_send_time(pg, 3);
+  EXPECT_TRUE(t != 0);
+
+  t = get_probe_send_time(pg, 4);
+  EXPECT_TRUE(t != 0);
+
+  t = get_probe_send_time(pg, 5);
+  EXPECT_FALSE(t != 0);
+
+  delete_all_probes(pg);
+
+  t = get_probe_send_time(pg, 1);
+  EXPECT_FALSE(t != 0);
+
+  t = get_probe_send_time(pg, 2);
+  EXPECT_FALSE(t != 0);
+
+  t = get_probe_send_time(pg, 3);
+  EXPECT_FALSE(t != 0);
+
+  t = get_probe_send_time(pg, 4);
+  EXPECT_FALSE(t != 0);
+
+  destroy_probe_generator(pg);
+}
diff --git a/hicn-light/src/hicn/test/test-ring.cc b/hicn-light/src/hicn/test/test-ring.cc
new file mode 100644
index 000000000..51f1f5327
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-ring.cc
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <netinet/in.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/base/ring.h>
+}
+
+#define DEFAULT_SIZE 10UL
+
+class RingTest : public ::testing::Test {
+ protected:
+  RingTest() { ring_init(ring, DEFAULT_SIZE); }
+  virtual ~RingTest() { ring_free(ring); }
+
+  int *ring = NULL;
+};
+
+/* TEST: Ring allocation and initialization */
+TEST_F(RingTest, RingAddOne) {
+  int val = -1;
+  /* Allocated size should be the next power of two */
+  EXPECT_EQ(ring_get_size(ring), 0UL);
+  ring_add_value(ring, 1);
+  EXPECT_EQ(ring_get_size(ring), 1UL);
+  ring_get(ring, 0, &val);
+  EXPECT_EQ(val, 1);
+  EXPECT_EQ(ring_get_size(ring), 1UL);
+  ring_advance(ring, 1);
+  EXPECT_EQ(ring_get_size(ring), 0UL);
+}
+
+TEST_F(RingTest, RingAddMany) {
+  size_t i = 0;
+  int val = -1;
+  size_t count = 0;
+
+  /* Allocated size should be the next power of two */
+  EXPECT_EQ(ring_get_size(ring), 0UL);
+  for (unsigned i = 0; i < DEFAULT_SIZE; i++) ring_add_value(ring, i);
+  EXPECT_EQ(ring_get_size(ring), DEFAULT_SIZE);
+
+  count = 0;
+  ring_enumerate_n(ring, i, &val, 1, {
+    EXPECT_EQ(val, (int)(i));
+    count++;
+  });
+  EXPECT_EQ(count, 1UL);
+
+  count = 0;
+  ring_enumerate_n(ring, i, &val, DEFAULT_SIZE, {
+    EXPECT_EQ(val, (int)(i));
+    count++;
+  });
+  EXPECT_EQ(count, DEFAULT_SIZE);
+
+  count = 0;
+  ring_enumerate_n(ring, i, &val, DEFAULT_SIZE + 1, {
+    EXPECT_EQ(val, (int)(i));
+    count++;
+  });
+  EXPECT_EQ(count, DEFAULT_SIZE);
+
+  // Drop one
+  ring_add_value(ring, DEFAULT_SIZE);
+  EXPECT_EQ(ring_get_size(ring), DEFAULT_SIZE);
+
+  count = 0;
+  ring_enumerate_n(ring, i, &val, DEFAULT_SIZE, {
+    EXPECT_EQ(val, (int)(i + 1));  // all values shoud be shifted
+    count++;
+  });
+  EXPECT_EQ(count, DEFAULT_SIZE);
+
+  ring_advance(ring, DEFAULT_SIZE);
+  EXPECT_EQ(ring_get_size(ring), 0UL);
+}
diff --git a/hicn-light/src/hicn/test/test-strategy-best-path.cc b/hicn-light/src/hicn/test/test-strategy-best-path.cc
new file mode 100644
index 000000000..327c47144
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-strategy-best-path.cc
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/core/strategy.h>
+#include <hicn/strategies/best_path.h>
+}
+
+#define MAX_TESTS 10
+
+#define NEXTHOP_ID1 NEXTHOP(28)
+#define NEXTHOP_ID2 NEXTHOP(29)
+#define UNKNOWN_ID1 NEXTHOP(0)
+#define UNKNOWN_ID2 NEXTHOP(1)
+
+class StrategyBestpathTest : public ::testing::Test {
+ protected:
+  StrategyBestpathTest() {
+    /* Strategy and strategy entry */
+    entry = {
+        .type = STRATEGY_TYPE_BESTPATH,
+        .options =
+            {
+                .bestpath = {},
+            },
+        .state = {.bestpath = {}},
+    };
+
+    strategy_initialize(&entry, nullptr);
+
+    // test init
+    EXPECT_EQ(entry.forwarder, nullptr);
+    EXPECT_EQ(entry.state.bestpath.best_nexthop, (unsigned)~0);
+    EXPECT_EQ(entry.state.bestpath.probing_state, PROBING_OFF);
+
+    /* Available nexthops */
+    available_nexthops_ = NEXTHOPS_EMPTY;
+    EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)0);
+
+    /* Message buffer */
+    msgbuf_ = NULL;
+    ticks_ = ticks_now();
+  }
+
+  virtual ~StrategyBestpathTest() {}
+
+  strategy_entry_t entry;
+  nexthops_t available_nexthops_;
+  msgbuf_t *msgbuf_;
+  Ticks ticks_;
+};
+
+TEST_F(StrategyBestpathTest, emptyNexthop) {
+  nexthops_t *nexthops;
+  nexthops = strategy_lookup_nexthops(&entry, &available_nexthops_, msgbuf_);
+  EXPECT_EQ(nexthops_get_len(nexthops), (size_t)0);
+}
+
+TEST_F(StrategyBestpathTest, faceExists) {
+  nexthops_t *nexthops;
+
+  nexthops_add(&available_nexthops_, NEXTHOP_ID1);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)1);
+
+  nexthops_add(&available_nexthops_, NEXTHOP_ID2);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)2);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)2);
+
+  entry.state.bestpath.probing_state = PROBING_OFF;
+  entry.state.bestpath.best_nexthop = NEXTHOP_ID2;
+
+  nexthops = strategy_lookup_nexthops(&entry, &available_nexthops_, msgbuf_);
+
+  EXPECT_EQ(nexthops_get_len(nexthops), (size_t)2);
+  EXPECT_EQ(nexthops_get_curlen(nexthops), (size_t)1);
+
+  EXPECT_TRUE(nexthops_contains(nexthops, NEXTHOP_ID2));
+  EXPECT_FALSE(nexthops_contains(nexthops, NEXTHOP_ID1));
+
+  EXPECT_TRUE(entry.state.bestpath.probing_state == PROBING_OFF);
+  EXPECT_EQ(entry.state.bestpath.best_nexthop, NEXTHOP_ID2);
+}
diff --git a/hicn-light/src/hicn/test/test-strategy-load-balancing.cc b/hicn-light/src/hicn/test/test-strategy-load-balancing.cc
new file mode 100644
index 000000000..edac5669f
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-strategy-load-balancing.cc
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <netinet/in.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/core/strategy.h>
+#include <hicn/strategies/random.h>
+}
+
+#define MAX_TESTS 10
+
+#define NEXTHOP_ID NEXTHOP(28)
+#define NEXTHOP_ID2 NEXTHOP(29)
+#define UNKNOWN_ID1 NEXTHOP(0)
+#define UNKNOWN_ID2 NEXTHOP(1)
+
+class StrategyLoadBalancing : public ::testing::Test {
+ protected:
+  StrategyLoadBalancing() {
+    /* Strategy and strategy entry */
+    entry = {
+        .type = STRATEGY_TYPE_LOADBALANCER,
+        .options =
+            {
+                .random = {},
+            },
+        .state = {.random = {}},
+    };
+
+    strategy_initialize(&entry, nullptr);
+
+    /* Available nexthops */
+    available_nexthops_ = NEXTHOPS_EMPTY;
+    EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)0);
+
+    /* Message buffer */
+    msgbuf_ = NULL;
+    ticks_ = ticks_now();
+  }
+  virtual ~StrategyLoadBalancing() {}
+
+  strategy_entry_t entry;
+  nexthops_t available_nexthops_;
+  msgbuf_t* msgbuf_;
+  Ticks ticks_;
+};
+
+TEST_F(StrategyLoadBalancing, SingleNexthop) {
+  /* Add a single nexthop */
+  off_t id;
+  id = nexthops_add(&available_nexthops_, NEXTHOP_ID);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)1);
+
+  strategy_add_nexthop(&entry, &available_nexthops_, id);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)1);
+
+  EXPECT_TRUE(nexthops_contains(&available_nexthops_, NEXTHOP_ID));
+  EXPECT_FALSE(nexthops_contains(&available_nexthops_, UNKNOWN_ID1));
+  EXPECT_FALSE(nexthops_contains(&available_nexthops_, UNKNOWN_ID2));
+
+  /* Lookup */
+  nexthops_t* nexthops;
+  nexthops = strategy_lookup_nexthops(&entry, &available_nexthops_, msgbuf_);
+
+  EXPECT_EQ(nexthops_get_len(nexthops), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(nexthops), (size_t)1);
+
+  EXPECT_TRUE(nexthops_contains(nexthops, NEXTHOP_ID));
+  EXPECT_FALSE(nexthops_contains(nexthops, UNKNOWN_ID1));
+  EXPECT_FALSE(nexthops_contains(nexthops, UNKNOWN_ID2));
+
+  /* Retrieve candidate */
+
+  unsigned nexthop;
+  for (unsigned i = 0; i < MAX_TESTS; i++) {
+    nexthop = nexthops_get_one(nexthops);
+    EXPECT_EQ(nexthop, NEXTHOP_ID);
+  }
+
+  /* Disable (move to nexthop unit tests) */
+  nexthops_disable(nexthops, 0);
+
+  EXPECT_EQ(nexthops_get_len(nexthops), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(nexthops), (size_t)0);
+
+  nexthop = nexthops_get_one(nexthops);
+  EXPECT_EQ(nexthop, INVALID_NEXTHOP);
+}
+
+TEST_F(StrategyLoadBalancing, MultipleNexthops) {
+  off_t id, id2;
+  /* Add a single nexthop */
+  id = nexthops_add(&available_nexthops_, NEXTHOP_ID);
+  id2 = nexthops_add(&available_nexthops_, NEXTHOP_ID2);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)2);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)2);
+
+  strategy_add_nexthop(&entry, &available_nexthops_, id);
+  strategy_add_nexthop(&entry, &available_nexthops_, id2);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)2);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)2);
+
+  EXPECT_TRUE(nexthops_contains(&available_nexthops_, NEXTHOP_ID));
+  EXPECT_TRUE(nexthops_contains(&available_nexthops_, NEXTHOP_ID2));
+  EXPECT_FALSE(nexthops_contains(&available_nexthops_, UNKNOWN_ID1));
+  EXPECT_FALSE(nexthops_contains(&available_nexthops_, UNKNOWN_ID2));
+
+  /* Lookup */
+  nexthops_t* nexthops;
+  nexthops = strategy_lookup_nexthops(&entry, &available_nexthops_, msgbuf_);
+
+  EXPECT_EQ(nexthops_get_len(nexthops), (size_t)2);
+  EXPECT_EQ(nexthops_get_curlen(nexthops), (size_t)1);
+
+  EXPECT_TRUE((nexthops_contains(nexthops, NEXTHOP_ID)) ||
+              (nexthops_contains(nexthops, NEXTHOP_ID2)));
+  EXPECT_FALSE(nexthops_contains(nexthops, UNKNOWN_ID1));
+  EXPECT_FALSE(nexthops_contains(nexthops, UNKNOWN_ID2));
+
+  /* Retrieve candidate */
+
+  unsigned nexthop;
+  for (unsigned i = 0; i < MAX_TESTS; i++) {
+    nexthop = nexthops_get_one(nexthops);
+    EXPECT_TRUE((nexthop == NEXTHOP_ID) || (nexthop == NEXTHOP_ID2));
+  }
+}
diff --git a/hicn-light/src/hicn/test/test-strategy-random.cc b/hicn-light/src/hicn/test/test-strategy-random.cc
new file mode 100644
index 000000000..bd9b70120
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-strategy-random.cc
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <netinet/in.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/core/strategy.h>
+#include <hicn/core/strategy_vft.h>
+#include <hicn/strategies/random.h>
+}
+
+#define MAX_TESTS 10
+
+#define NEXTHOP_ID NEXTHOP(28)
+#define UNKNOWN_ID1 NEXTHOP(0)
+#define UNKNOWN_ID2 NEXTHOP(1)
+
+class StrategyRandomTest : public ::testing::Test {
+ protected:
+  StrategyRandomTest() {
+    /* Strategy and strategy entry */
+    entry = {
+        .type = STRATEGY_TYPE_RANDOM,
+        .options =
+            {
+                .random = {},
+            },
+        .state = {.random = {}},
+    };
+
+    strategy_initialize(&entry, nullptr);
+
+    /* Available nexthops */
+    available_nexthops_ = NEXTHOPS_EMPTY;
+    EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)0);
+
+    /* Message buffer */
+    msgbuf_ = NULL;
+    ticks_ = ticks_now();
+  }
+  virtual ~StrategyRandomTest() {}
+
+  strategy_entry_t entry;
+  nexthops_t available_nexthops_;
+  msgbuf_t* msgbuf_;
+  Ticks ticks_;
+};
+
+TEST_F(StrategyRandomTest, SingleNexthop) {
+  off_t id;
+
+  /* Add a single nexthop */
+  id = nexthops_add(&available_nexthops_, NEXTHOP_ID);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)1);
+
+  strategy_add_nexthop(&entry, &available_nexthops_, id);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)1);
+
+  EXPECT_TRUE(nexthops_contains(&available_nexthops_, NEXTHOP_ID));
+  EXPECT_FALSE(nexthops_contains(&available_nexthops_, UNKNOWN_ID1));
+  EXPECT_FALSE(nexthops_contains(&available_nexthops_, UNKNOWN_ID2));
+
+  /* Lookup */
+  nexthops_t* nexthops;
+  nexthops = strategy_lookup_nexthops(&entry, &available_nexthops_, msgbuf_);
+
+  EXPECT_EQ(nexthops_get_len(nexthops), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(nexthops), (size_t)1);
+
+  EXPECT_TRUE(nexthops_contains(nexthops, NEXTHOP_ID));
+  EXPECT_FALSE(nexthops_contains(nexthops, UNKNOWN_ID1));
+  EXPECT_FALSE(nexthops_contains(nexthops, UNKNOWN_ID2));
+
+  /* Retrieve candidate */
+
+  unsigned nexthop;
+  for (unsigned i = 0; i < MAX_TESTS; i++) {
+    nexthop = nexthops_get_one(nexthops);
+    EXPECT_EQ(nexthop, NEXTHOP_ID);
+  }
+
+  /* Disable (move to nexthop unit tests) */
+  nexthops_disable(nexthops, 0);
+
+  EXPECT_EQ(nexthops_get_len(nexthops), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(nexthops), (size_t)0);
+
+  nexthop = nexthops_get_one(nexthops);
+  EXPECT_EQ(nexthop, INVALID_NEXTHOP);
+}
+
+TEST_F(StrategyRandomTest, MultipleNexthops) {
+  off_t id;
+
+  /* Add a single nexthop */
+  id = nexthops_add(&available_nexthops_, NEXTHOP_ID);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)1);
+
+  strategy_add_nexthop(&entry, &available_nexthops_, id);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)1);
+
+  EXPECT_TRUE(nexthops_contains(&available_nexthops_, NEXTHOP_ID));
+  EXPECT_FALSE(nexthops_contains(&available_nexthops_, UNKNOWN_ID1));
+  EXPECT_FALSE(nexthops_contains(&available_nexthops_, UNKNOWN_ID2));
+
+  /* Lookup */
+  nexthops_t* nexthops;
+  nexthops = strategy_lookup_nexthops(&entry, &available_nexthops_, msgbuf_);
+
+  EXPECT_EQ(nexthops_get_len(nexthops), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(nexthops), (size_t)1);
+
+  EXPECT_TRUE(nexthops_contains(nexthops, NEXTHOP_ID));
+  EXPECT_FALSE(nexthops_contains(nexthops, UNKNOWN_ID1));
+  EXPECT_FALSE(nexthops_contains(nexthops, UNKNOWN_ID2));
+
+  /* Retrieve candidate */
+
+  unsigned nexthop;
+  for (unsigned i = 0; i < MAX_TESTS; i++) {
+    nexthop = nexthops_get_one(nexthops);
+    EXPECT_EQ(nexthop, NEXTHOP_ID);
+  }
+}
diff --git a/hicn-light/src/hicn/test/test-strategy-replication.cc b/hicn-light/src/hicn/test/test-strategy-replication.cc
new file mode 100644
index 000000000..ab7dae1f7
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-strategy-replication.cc
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <netinet/in.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/core/strategy.h>
+#include <hicn/strategies/random.h>
+}
+
+#define MAX_TESTS 10
+
+#define NEXTHOP_ID1 NEXTHOP(28)
+#define NEXTHOP_ID2 NEXTHOP(29)
+#define UNKNOWN_ID1 NEXTHOP(0)
+#define UNKNOWN_ID2 NEXTHOP(1)
+
+class StrategyReplicationTest : public ::testing::Test {
+ protected:
+  StrategyReplicationTest() {
+    /* Strategy and strategy entry */
+    entry = {
+        .type = STRATEGY_TYPE_REPLICATION,
+        .options =
+            {
+                .replication = {},
+            },
+        .state = {.replication = {}},
+    };
+
+    strategy_initialize(&entry, nullptr);
+
+    /* Available nexthops */
+    available_nexthops_ = NEXTHOPS_EMPTY;
+    EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)0);
+
+    /* Message buffer */
+    msgbuf_ = NULL;
+    ticks_ = ticks_now();
+  }
+
+  virtual ~StrategyReplicationTest() {}
+
+  strategy_entry_t entry;
+  nexthops_t available_nexthops_;
+  msgbuf_t* msgbuf_;
+  Ticks ticks_;
+};
+
+TEST_F(StrategyReplicationTest, SingleNexthop) {
+  off_t id;
+
+  /* Add a single nexthop */
+  id = nexthops_add(&available_nexthops_, NEXTHOP_ID1);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)1);
+
+  strategy_add_nexthop(&entry, &available_nexthops_, id);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)1);
+
+  EXPECT_TRUE(nexthops_contains(&available_nexthops_, NEXTHOP_ID1));
+  EXPECT_FALSE(nexthops_contains(&available_nexthops_, UNKNOWN_ID1));
+  EXPECT_FALSE(nexthops_contains(&available_nexthops_, UNKNOWN_ID2));
+
+  /* Lookup */
+  nexthops_t* nexthops;
+  nexthops = strategy_lookup_nexthops(&entry, &available_nexthops_, msgbuf_);
+
+  EXPECT_EQ(nexthops_get_len(nexthops), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(nexthops), (size_t)1);
+
+  EXPECT_TRUE(nexthops_contains(nexthops, NEXTHOP_ID1));
+  EXPECT_FALSE(nexthops_contains(nexthops, UNKNOWN_ID1));
+  EXPECT_FALSE(nexthops_contains(nexthops, UNKNOWN_ID2));
+
+  /* Retrieve candidate */
+
+  unsigned nexthop;
+  for (unsigned i = 0; i < MAX_TESTS; i++) {
+    nexthop = nexthops_get_one(nexthops);
+    EXPECT_EQ(nexthop, NEXTHOP_ID1);
+  }
+
+  /* Disable (move to nexthop unit tests) */
+  nexthops_disable(nexthops, 0);
+
+  EXPECT_EQ(nexthops_get_len(nexthops), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(nexthops), (size_t)0);
+
+  nexthop = nexthops_get_one(nexthops);
+  EXPECT_EQ(nexthop, INVALID_NEXTHOP);
+}
+
+TEST_F(StrategyReplicationTest, MultipleNexthops) {
+  off_t id;
+
+  id = nexthops_add(&available_nexthops_, NEXTHOP_ID1);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)1);
+
+  strategy_add_nexthop(&entry, &available_nexthops_, id);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)1);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)1);
+
+  id = nexthops_add(&available_nexthops_, NEXTHOP_ID2);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)2);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)2);
+
+  strategy_add_nexthop(&entry, &available_nexthops_, id);
+  EXPECT_EQ(nexthops_get_len(&available_nexthops_), (size_t)2);
+  EXPECT_EQ(nexthops_get_curlen(&available_nexthops_), (size_t)2);
+
+  EXPECT_TRUE(nexthops_contains(&available_nexthops_, NEXTHOP_ID1));
+  EXPECT_TRUE(nexthops_contains(&available_nexthops_, NEXTHOP_ID2));
+  EXPECT_FALSE(nexthops_contains(&available_nexthops_, UNKNOWN_ID1));
+  EXPECT_FALSE(nexthops_contains(&available_nexthops_, UNKNOWN_ID2));
+
+  /* Lookup */
+  nexthops_t* nexthops;
+  nexthops = strategy_lookup_nexthops(&entry, &available_nexthops_, msgbuf_);
+
+  EXPECT_EQ(nexthops_get_len(nexthops), (size_t)2);
+  EXPECT_EQ(nexthops_get_curlen(nexthops), (size_t)2);
+
+  EXPECT_TRUE(nexthops_contains(nexthops, NEXTHOP_ID1));
+  EXPECT_TRUE(nexthops_contains(nexthops, NEXTHOP_ID2));
+  EXPECT_FALSE(nexthops_contains(nexthops, UNKNOWN_ID1));
+  EXPECT_FALSE(nexthops_contains(nexthops, UNKNOWN_ID2));
+
+  /* Retrieve candidate */
+
+  unsigned nexthop;
+  unsigned tests = 0;
+  nexthops_foreach(nexthops, nexthop, {
+    EXPECT_TRUE(nexthop == NEXTHOP_ID1 || nexthop == NEXTHOP_ID2);
+    tests++;
+  });
+
+  EXPECT_EQ(tests, (unsigned)2);
+}
diff --git a/hicn-light/src/hicn/test/test-subscription.cc b/hicn-light/src/hicn/test/test-subscription.cc
new file mode 100644
index 000000000..18ef60c0d
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-subscription.cc
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ */
+
+#include <gtest/gtest.h>
+
+extern "C" {
+#include <hicn/core/subscription.h>
+#include <hicn/base/vector.h>
+}
+
+static inline unsigned CONN_ID = 1;
+static inline unsigned CONN_ID_2 = 2;
+
+class SubscriptionTest : public ::testing::Test {
+ protected:
+  SubscriptionTest() { subscriptions = subscription_table_create(); }
+  virtual ~SubscriptionTest() { subscription_table_free(subscriptions); }
+
+  subscription_table_t *subscriptions;
+};
+
+TEST_F(SubscriptionTest, CreateSubscriptionTable) {
+  // Check subscription table allocation
+  ASSERT_NE(subscriptions, nullptr);
+}
+
+TEST_F(SubscriptionTest, SetTopic) {
+  hc_topics_t topics = TOPIC_STRATEGY;
+
+  // Check that only the topic desired has been subscribed to
+  for (int topic = TOPIC_UNDEFINED; topic < TOPIC_N; topic <<= 1) {
+    if (topic == TOPIC_STRATEGY) {
+      EXPECT_TRUE(topics_contains(topics, (hc_topic_t)topic));
+      continue;
+    }
+    EXPECT_FALSE(topics_contains(topics, (hc_topic_t)topic));
+  }
+}
+
+TEST_F(SubscriptionTest, GetObjectFromTopic) {
+  hc_object_type_t object_type = object_from_topic(TOPIC_STRATEGY);
+  EXPECT_EQ(object_type, OBJECT_STRATEGY);
+
+  object_type = object_from_topic(TOPIC_FACE);
+  EXPECT_EQ(object_type, OBJECT_FACE);
+}
+
+TEST_F(SubscriptionTest, AddSubscription) {
+  hc_topics_t topics = TOPIC_STRATEGY;
+  int ret = subscription_table_add_topics_for_connection(subscriptions, topics,
+                                                         CONN_ID);
+  EXPECT_EQ(ret, 0);  // 0 = success
+
+  hc_topics_t topics_ret =
+      subscription_table_get_topics_for_connection(subscriptions, CONN_ID);
+  EXPECT_EQ(topics_ret, topics);
+}
+
+TEST_F(SubscriptionTest, AddAndRemoveSubscriptionForAllTopics) {
+  hc_topics_t topics = ALL_TOPICS;
+  int ret = subscription_table_add_topics_for_connection(subscriptions,
+                                                         ALL_TOPICS, CONN_ID);
+  EXPECT_EQ(ret, 0);  // 0 = success
+
+  int num_subscriptions_removed =
+      subscription_table_remove_topics_for_connection(subscriptions, topics,
+                                                      CONN_ID);
+  EXPECT_EQ(num_subscriptions_removed, NUM_TOPICS);
+
+  hc_topics_t topics_ret =
+      subscription_table_get_topics_for_connection(subscriptions, CONN_ID);
+  EXPECT_EQ(topics_ret, 0u);
+}
+
+// Failure while adding subscription cannot be tested since it depends on vector
+// reallocation
+
+TEST_F(SubscriptionTest, AddSubscriptionAlreadyAdded) {
+  hc_topics_t topics = TOPIC_STRATEGY;
+  int ret = subscription_table_add_topics_for_connection(subscriptions, topics,
+                                                         CONN_ID);
+  EXPECT_EQ(ret, 0);  // 0 = success
+
+  // Subscribe again to same topic
+  ret = subscription_table_add_topics_for_connection(subscriptions, topics,
+                                                     CONN_ID);
+  EXPECT_EQ(ret, -2);  // -2 = already-added subscription
+
+  hc_topics_t topics_ret =
+      subscription_table_get_topics_for_connection(subscriptions, CONN_ID);
+  EXPECT_EQ(topics_ret, topics);
+}
+
+TEST_F(SubscriptionTest, GetSubscriptionsForConnectionWithoutSubscriptions) {
+  hc_topics_t topics_ret =
+      subscription_table_get_topics_for_connection(subscriptions, CONN_ID);
+  EXPECT_EQ(topics_ret, (hc_topics_t)0);
+}
+
+TEST_F(SubscriptionTest, GetSubscriptionsForConnectionWithMultipleSubs) {
+  hc_topics_t topics = TOPIC_STRATEGY | TOPIC_FACE;
+  int ret = subscription_table_add_topics_for_connection(subscriptions, topics,
+                                                         CONN_ID);
+  EXPECT_EQ(ret, 0);  // 0 = success
+
+  hc_topics_t topics_ret =
+      subscription_table_get_topics_for_connection(subscriptions, CONN_ID);
+  EXPECT_EQ(topics_ret, topics);
+
+  // Add another subscription
+  ret = subscription_table_add_topics_for_connection(subscriptions, TOPIC_PROBE,
+                                                     CONN_ID);
+  EXPECT_EQ(ret, 0);  // 0 = success
+
+  topics_ret =
+      subscription_table_get_topics_for_connection(subscriptions, CONN_ID);
+  EXPECT_EQ(topics_ret, topics |= TOPIC_PROBE);
+}
+
+TEST_F(SubscriptionTest, RemoveSubscription) {
+  // Add subscriptions
+  hc_topics_t topics = TOPIC_STRATEGY | TOPIC_FACE;
+  int ret = subscription_table_add_topics_for_connection(subscriptions, topics,
+                                                         CONN_ID);
+  EXPECT_EQ(ret, 0);  // 0 = success
+
+  // Remove one of the previously added subscriptions
+  int num_subscriptions_removed =
+      subscription_table_remove_topics_for_connection(subscriptions,
+                                                      TOPIC_STRATEGY, CONN_ID);
+  EXPECT_EQ(num_subscriptions_removed, 1);
+
+  hc_topics_t topics_ret =
+      subscription_table_get_topics_for_connection(subscriptions, CONN_ID);
+  EXPECT_EQ(topics_ret, TOPIC_FACE);
+}
+
+TEST_F(SubscriptionTest, RemoveMultipleSubscriptions) {
+  // Add subscriptions
+  hc_topics_t topics = TOPIC_STRATEGY | TOPIC_FACE | TOPIC_PROBE;
+  int ret = subscription_table_add_topics_for_connection(subscriptions, topics,
+                                                         CONN_ID);
+  EXPECT_EQ(ret, 0);  // 0 = success
+
+  // Remove two of the previously added subscriptions
+  int num_subscriptions_removed =
+      subscription_table_remove_topics_for_connection(
+          subscriptions, TOPIC_STRATEGY | TOPIC_FACE, CONN_ID);
+  EXPECT_EQ(num_subscriptions_removed, 2);
+
+  hc_topics_t topics_ret =
+      subscription_table_get_topics_for_connection(subscriptions, CONN_ID);
+  EXPECT_EQ(topics_ret, TOPIC_PROBE);
+}
+
+TEST_F(SubscriptionTest, RemoveNonRegistredSubscription) {
+  // Remove a subscription that is not present
+  int num_subscriptions_removed =
+      subscription_table_remove_topics_for_connection(subscriptions,
+                                                      TOPIC_PROBE, CONN_ID);
+  EXPECT_EQ(num_subscriptions_removed, 0);
+
+  // Add two new subscriptions
+  hc_topics_t topics = TOPIC_STRATEGY | TOPIC_FACE;
+  int ret = subscription_table_add_topics_for_connection(subscriptions, topics,
+                                                         CONN_ID);
+  EXPECT_EQ(ret, 0);  // 0 = success
+
+  // Remove subscription that was not registred previously
+  num_subscriptions_removed = subscription_table_remove_topics_for_connection(
+      subscriptions, TOPIC_PROBE, CONN_ID);
+  EXPECT_EQ(num_subscriptions_removed, 0);
+
+  hc_topics_t topics_ret =
+      subscription_table_get_topics_for_connection(subscriptions, CONN_ID);
+  EXPECT_EQ(topics_ret, topics);
+}
+
+TEST_F(SubscriptionTest, GetConnectionsForSubscription) {
+  // Add subscriptions for two connections
+  hc_topics_t topics = TOPIC_STRATEGY | TOPIC_FACE;
+  int ret = subscription_table_add_topics_for_connection(subscriptions, topics,
+                                                         CONN_ID);
+  EXPECT_EQ(ret, 0);  // 0 = success
+
+  topics = TOPIC_STRATEGY;
+  ret = subscription_table_add_topics_for_connection(subscriptions, topics,
+                                                     CONN_ID_2);
+  EXPECT_EQ(ret, 0);  // 0 = success
+
+  // Check the connections associated with the strategy topic
+  unsigned *conn_ids = subscription_table_get_connections_for_topic(
+      subscriptions, TOPIC_STRATEGY);
+  EXPECT_EQ(vector_len(conn_ids), 2u);
+  EXPECT_TRUE(conn_ids[0] == CONN_ID || conn_ids[0] == CONN_ID_2);
+  EXPECT_TRUE(conn_ids[1] == CONN_ID || conn_ids[1] == CONN_ID_2);
+
+  // Check the connections associated with the face topic
+  conn_ids =
+      subscription_table_get_connections_for_topic(subscriptions, TOPIC_FACE);
+  EXPECT_EQ(vector_len(conn_ids), 1u);
+  EXPECT_EQ(conn_ids[0], (unsigned)CONN_ID);
+}
\ No newline at end of file
diff --git a/hicn-light/src/hicn/test/test-vector.cc b/hicn-light/src/hicn/test/test-vector.cc
new file mode 100644
index 000000000..fb30a8228
--- /dev/null
+++ b/hicn-light/src/hicn/test/test-vector.cc
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <netinet/in.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/base/vector.h>
+}
+
+/*
+ * TODO
+ * - test max_size
+ */
+
+#define DEFAULT_SIZE 10
+const size_t N_ELEMENTS = 5;
+
+class VectorTest : public ::testing::Test {
+ protected:
+  VectorTest() { vector_init(vector, DEFAULT_SIZE, 0); }
+  virtual ~VectorTest() { vector_free(vector); }
+
+  int *vector = NULL;
+};
+
+/* TEST: Vector allocation and initialization */
+TEST_F(VectorTest, VectorAllocate) {
+  /* Allocated size should be the next power of two */
+  EXPECT_EQ(vector_get_alloc_size(vector), 16UL);
+
+  /* Setting elements within the allocated size should not trigger a resize */
+  vector_ensure_pos(vector, 15);
+  EXPECT_EQ(vector_get_alloc_size(vector), 16UL);
+
+  /* Setting elements after should through */
+  vector_ensure_pos(vector, 16);
+  EXPECT_EQ(vector_get_alloc_size(vector), 32UL);
+
+  /* Check that free indices and bitmaps are correctly updated */
+}
+
+TEST_F(VectorTest, VectorSize) {
+  vector_push(vector, 109);
+  int size = vector_len(vector);
+  EXPECT_EQ(size, 1);
+  vector_push(vector, 109);
+  size = vector_len(vector);
+  EXPECT_EQ(size, 2);
+  vector_push(vector, 109);
+  size = vector_len(vector);
+  EXPECT_EQ(size, 3);
+}
+
+TEST_F(VectorTest, VectorCheckValue) {
+  vector_push(vector, 109);
+  vector_push(vector, 200);
+  EXPECT_EQ(vector[0], 109);
+  EXPECT_EQ(vector[1], 200);
+}
+
+TEST_F(VectorTest, VectorEnsurePos) {
+  printf(" %p\n", vector);
+  vector_ensure_pos(vector, 1025);
+  for (int i = 0; i < 1025; i++) {
+    // printf("i %d\n", i);
+    // printf (" %p\n", vector);
+    vector_push(vector, i);
+  }
+  int size = vector_len(vector);
+  EXPECT_EQ(size, 1025);
+}
+
+TEST_F(VectorTest, RemoveElement) {
+  // Populate vector
+  for (size_t i = 0; i < N_ELEMENTS; i++) vector_push(vector, i);
+  EXPECT_EQ(vector_len(vector), N_ELEMENTS);
+  for (size_t i = 0; i < vector_len(vector); i++) EXPECT_EQ(vector[i], (int)i);
+
+  // Remove element
+  int value_to_remove = 3;
+  int num_removed = vector_remove_unordered(vector, value_to_remove);
+
+  EXPECT_EQ(vector_len(vector), N_ELEMENTS - 1);
+  EXPECT_EQ(num_removed, 1);
+  for (size_t i = 0; i < vector_len(vector); i++)
+    EXPECT_NE(vector[i], value_to_remove);
+}
+
+TEST_F(VectorTest, RemoveDuplicatedElement) {
+  // Populate vector
+  for (size_t i = 0; i < N_ELEMENTS; i++) vector_push(vector, i);
+  EXPECT_EQ(vector_len(vector), N_ELEMENTS);
+  for (size_t i = 0; i < vector_len(vector); i++) EXPECT_EQ(vector[i], (int)i);
+  vector[0] = 3;  // Duplicate element
+
+  // Remove (duplicated) elements
+  int value_to_remove = 3;
+  int num_removed = vector_remove_unordered(vector, value_to_remove);
+
+  EXPECT_EQ(vector_len(vector), N_ELEMENTS - 2);
+  EXPECT_EQ(num_removed, 2);
+  for (size_t i = 0; i < vector_len(vector); i++)
+    EXPECT_NE(vector[i], value_to_remove);
+}
+
+TEST_F(VectorTest, Iterate) {
+  for (size_t i = 0; i < N_ELEMENTS; i++) vector_push(vector, i);
+
+  int count = 0;
+  int *elem;
+  vector_foreach(vector, elem, { EXPECT_EQ(*elem, count++); });
+}
+
+TEST_F(VectorTest, MultipleResize) {
+  // Use small vector (size=1) to force multiple realloc operations
+  int *small_vector;
+  vector_init(small_vector, 1, 0);
+
+  for (size_t i = 0; i < N_ELEMENTS; i++) vector_push(small_vector, i);
+
+  for (size_t i = 0; i < N_ELEMENTS; i++) EXPECT_EQ(small_vector[i], (int)i);
+
+  EXPECT_EQ(vector_len(small_vector), 5UL);
+  EXPECT_EQ(vector_get_alloc_size(small_vector), 8UL);
+
+  vector_free(small_vector);
+}
\ No newline at end of file
diff --git a/hicn-light/src/hicn/utils/CMakeLists.txt b/hicn-light/src/hicn/utils/CMakeLists.txt
index c8c9b8487..72a918cac 100644
--- a/hicn-light/src/hicn/utils/CMakeLists.txt
+++ b/hicn-light/src/hicn/utils/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,30 +11,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# XXX This is installed in hicn/utils...
 list(APPEND HEADER_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/address.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/addressList.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/commands.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/interface.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/interfaceSet.h
+#  ${CMAKE_CURRENT_SOURCE_DIR}/commands.h
+#  ${CMAKE_CURRENT_SOURCE_DIR}/interface.h
+#  ${CMAKE_CURRENT_SOURCE_DIR}/interfaceSet.h
   ${CMAKE_CURRENT_SOURCE_DIR}/punting.h
   ${CMAKE_CURRENT_SOURCE_DIR}/token.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/utils.h
 )
 
 list(APPEND SOURCE_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/address.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/addressList.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/interface.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/interfaceSet.c
+#  ${CMAKE_CURRENT_SOURCE_DIR}/interface.c
+#  ${CMAKE_CURRENT_SOURCE_DIR}/interfaceSet.c
   ${CMAKE_CURRENT_SOURCE_DIR}/punting.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/utils.c
-)
-
-set(TO_INSTALL_HEADER_FILES
-  ${TO_INSTALL_HEADER_FILES}
-  ${HEADER_FILES}
-  PARENT_SCOPE
 )
 
 set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
diff --git a/hicn-light/src/hicn/utils/address.c b/hicn-light/src/hicn/utils/address.c
deleted file mode 100644
index 619097e1d..000000000
--- a/hicn-light/src/hicn/utils/address.c
+++ /dev/null
@@ -1,450 +0,0 @@
-/*
- * 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 _WIN32
-#include <arpa/inet.h>
-#include <unistd.h>
-#endif
-#include <errno.h>
-#include <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <hicn/utils/address.h>
-
-#include <parc/algol/parc_Base64.h>
-#include <parc/algol/parc_BufferComposer.h>
-#include <parc/algol/parc_Hash.h>
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-#include <parc/algol/parc_Object.h>
-
-#include <parc/assert/parc_Assert.h>
-
-struct address {
-  address_type addressType;
-  PARCBuffer *blob;
-};
-
-static struct address_type_str {
-  address_type type;
-  const char *str;
-} addressTypeString[] = {
-    {.type = ADDR_INET, .str = "INET"}, {.type = ADDR_INET6, .str = "INET6"},
-    {.type = ADDR_LINK, .str = "LINK"}, {.type = ADDR_IFACE, .str = "IFACE"},
-    {.type = ADDR_UNIX, .str = "UNIX"}, {.type = 0, .str = NULL}};
-
-void addressDestroy(Address **addressPtr) {
-  parcAssertNotNull(addressPtr, "Parameter must be non-null double pointer");
-  parcAssertNotNull(*addressPtr,
-                    "Parameter must dereference to non-null pointer");
-
-  Address *address = *addressPtr;
-  parcBuffer_Release(&address->blob);
-  parcMemory_Deallocate((void **)&address);
-  *addressPtr = NULL;
-}
-
-void addressAssertValid(const Address *address) {
-  parcAssertNotNull(address, "Parameter must be non-null Address *");
-}
-
-const char *addressTypeToString(address_type type) {
-  for (int i = 0; addressTypeString[i].str != NULL; i++) {
-    if (addressTypeString[i].type == type) {
-      return addressTypeString[i].str;
-    }
-  }
-  parcTrapIllegalValue(type, "Unknown value: %d", type);
-  const char *result = NULL;
-  return result;
-}
-
-address_type addressStringToType(const char *str) {
-  for (int i = 0; addressTypeString[i].str != NULL; i++) {
-    if (strcasecmp(addressTypeString[i].str, str) == 0) {
-      return addressTypeString[i].type;
-    }
-  }
-  parcTrapIllegalValue(str, "Unknown type '%s'", str);
-  return 0;
-}
-
-static Address *_addressCreate(address_type addressType, PARCBuffer *buffer) {
-  Address *result = parcMemory_AllocateAndClear(sizeof(Address));
-
-  parcAssertNotNull(result, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(Address));
-  if (result != NULL) {
-    result->addressType = addressType;
-    result->blob = buffer;
-  }
-  return result;
-}
-
-Address *addressCreateFromInet(struct sockaddr_in *addr_in) {
-  parcAssertNotNull(addr_in, "Parameter must be non-null");
-
-  addr_in->sin_family = AF_INET;
-
-  PARCBuffer *buffer = parcBuffer_Allocate(sizeof(struct sockaddr_in));
-  parcBuffer_PutArray(buffer, sizeof(struct sockaddr_in), (uint8_t *)addr_in);
-  parcBuffer_Flip(buffer);
-
-  Address *result = _addressCreate(ADDR_INET, buffer);
-
-  return result;
-}
-
-Address *addressCreateFromInet6(struct sockaddr_in6 *addr_in6) {
-  parcAssertNotNull(addr_in6, "Parameter must be non-null");
-
-  PARCBuffer *buffer = parcBuffer_Allocate(sizeof(struct sockaddr_in6));
-  parcBuffer_PutArray(buffer, sizeof(struct sockaddr_in6), (uint8_t *)addr_in6);
-  parcBuffer_Flip(buffer);
-
-  Address *result = _addressCreate(ADDR_INET6, buffer);
-
-  return result;
-}
-
-Address *addressFromInaddr4Port(in_addr_t *addr4, in_port_t *port) {
-  struct sockaddr_in addr;
-  memset(&addr, 0, sizeof(addr));
-
-  // We assume address and port are already written in memory in network byte
-  // order
-  addr.sin_family = AF_INET;
-  addr.sin_port = *port;
-  addr.sin_addr.s_addr = *addr4;
-
-  Address *result = addressCreateFromInet(&addr);
-  return result;
-}
-
-Address *addressFromInaddr6Port(struct in6_addr *addr6, in_port_t *port) {
-  struct sockaddr_in6 addr;
-  memset(&addr, 0, sizeof(addr));
-  addr.sin6_family = AF_INET6;
-
-  // We assume address and port are already written in memory in network byte
-  // order
-  addr.sin6_port = *port;
-  addr.sin6_addr = *addr6;
-  addr.sin6_scope_id = 0;
-  // Other 2 fields: scope_id and flowinfo, do not know what to put inside.
-
-  Address *result = addressCreateFromInet6(&addr);
-  return result;
-}
-
-Address *addressCreateFromLink(const uint8_t *linkaddr, size_t length) {
-  parcAssertNotNull(linkaddr, "Parameter must be non-null");
-
-  PARCBuffer *buffer = parcBuffer_Allocate(sizeof(struct sockaddr_in6));
-  parcBuffer_PutArray(buffer, length, linkaddr);
-  parcBuffer_Flip(buffer);
-
-  Address *result = _addressCreate(ADDR_LINK, buffer);
-  return result;
-}
-
-Address *addressCreateFromInterface(unsigned interfaceIndex) {
-  unsigned netbyteorder = htonl(interfaceIndex);
-
-  PARCBuffer *buffer = parcBuffer_Allocate(sizeof(netbyteorder));
-  parcBuffer_PutArray(buffer, sizeof(netbyteorder), (uint8_t *)&netbyteorder);
-  parcBuffer_Flip(buffer);
-
-  Address *result = _addressCreate(ADDR_IFACE, buffer);
-  return result;
-}
-
-Address *addressCreateFromUnix(struct sockaddr_un *addr_un) {
-  parcAssertNotNull(addr_un, "Parameter must be non-null");
-
-  PARCBuffer *buffer = parcBuffer_Allocate(sizeof(struct sockaddr_un));
-  parcBuffer_PutArray(buffer, sizeof(struct sockaddr_un), (uint8_t *)addr_un);
-  parcBuffer_Flip(buffer);
-
-  Address *result = _addressCreate(ADDR_UNIX, buffer);
-  return result;
-}
-
-Address *addressCopy(const Address *original) {
-  addressAssertValid(original);
-
-  Address *result =
-      _addressCreate(original->addressType, parcBuffer_Copy(original->blob));
-  return result;
-}
-
-bool addressEquals(const Address *a, const Address *b) {
-  if (a == b) {
-    return true;
-  }
-
-  if (a == NULL || b == NULL) {
-    return false;
-  }
-
-  if (a->addressType == b->addressType) {
-    if (parcBuffer_Equals(a->blob, b->blob)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-address_type addressGetType(const Address *address) {
-  addressAssertValid(address);
-
-  return address->addressType;
-}
-
-// The Get functions need better names, what they do (Get from what? Put to
-// what?) is not clear from their names.  Case 1028
-bool addressGetInet(const Address *address, struct sockaddr_in *addr_in) {
-  addressAssertValid(address);
-  parcAssertNotNull(addr_in, "Parameter addr_in must be non-null");
-
-  if (address->addressType == ADDR_INET) {
-    parcAssertTrue(
-        parcBuffer_Remaining(address->blob) == sizeof(struct sockaddr_in),
-        "Address corrupted. Expected length %zu, actual length %zu",
-        sizeof(struct sockaddr_in), parcBuffer_Remaining(address->blob));
-
-    memcpy(addr_in, parcBuffer_Overlay(address->blob, 0),
-           sizeof(struct sockaddr_in));
-    return true;
-  }
-  return false;
-}
-
-bool addressGetInet6(const Address *address, struct sockaddr_in6 *addr_in6) {
-  addressAssertValid(address);
-  parcAssertNotNull(addr_in6, "Parameter addr_in6 must be non-null");
-
-  if (address->addressType == ADDR_INET6) {
-    parcAssertTrue(
-        parcBuffer_Remaining(address->blob) == sizeof(struct sockaddr_in6),
-        "Address corrupted. Expected length %zu, actual length %zu",
-        sizeof(struct sockaddr_in6), parcBuffer_Remaining(address->blob));
-
-    memcpy(addr_in6, parcBuffer_Overlay(address->blob, 0),
-           sizeof(struct sockaddr_in6));
-    return true;
-  }
-  return false;
-}
-
-bool addressGetUnix(const Address *address, struct sockaddr_un *addr_un) {
-  addressAssertValid(address);
-  parcAssertNotNull(addr_un, "Parameter addr_in6 must be non-null");
-
-  if (address->addressType == ADDR_UNIX) {
-    parcAssertTrue(
-        parcBuffer_Remaining(address->blob) == sizeof(struct sockaddr_un),
-        "Address corrupted. Expected length %zu, actual length %zu",
-        sizeof(struct sockaddr_un), parcBuffer_Remaining(address->blob));
-
-    memcpy(addr_un, parcBuffer_Overlay(address->blob, 0),
-           sizeof(struct sockaddr_un));
-    return true;
-  }
-  return false;
-}
-
-bool addressGetInterfaceIndex(const Address *address, uint32_t *ifidx) {
-  addressAssertValid(address);
-  parcAssertNotNull(ifidx, "Parameter ifidx must be non-null");
-
-  if (address->addressType == ADDR_IFACE) {
-    parcAssertTrue(parcBuffer_Remaining(address->blob) == sizeof(uint32_t),
-                   "Address corrupted. Expected length %zu, actual length %zu",
-                   sizeof(uint32_t), parcBuffer_Remaining(address->blob));
-
-    uint32_t netbyteorder;
-    memcpy(&netbyteorder, parcBuffer_Overlay(address->blob, 0),
-           sizeof(uint32_t));
-    *ifidx = ntohl(netbyteorder);
-    return true;
-  }
-  return false;
-}
-
-PARCBuffer *addressGetLinkAddress(const Address *address) {
-  addressAssertValid(address);
-  if (address->addressType == ADDR_LINK) {
-    return address->blob;
-  }
-  return NULL;
-}
-
-static PARCBufferComposer *_Inet_BuildString(const Address *address,
-                                             PARCBufferComposer *composer) {
-  addressAssertValid(address);
-
-  struct sockaddr_in *saddr =
-      (struct sockaddr_in *)parcBuffer_Overlay(address->blob, 0);
-  return parcNetwork_SockInet4Address_BuildString(saddr, composer);
-}
-
-static PARCBufferComposer *_Inet6_BuildString(const Address *address,
-                                              PARCBufferComposer *composer) {
-  addressAssertValid(address);
-
-  struct sockaddr_in6 *saddr =
-      (struct sockaddr_in6 *)parcBuffer_Overlay(address->blob, 0);
-  return parcNetwork_SockInet6Address_BuildString(saddr, composer);
-}
-
-static PARCBufferComposer *_Link_BuildString(const Address *address,
-                                             PARCBufferComposer *composer) {
-  addressAssertValid(address);
-
-  const unsigned char *addr = parcBuffer_Overlay(address->blob, 0);
-
-  size_t length = parcBuffer_Remaining(address->blob);
-
-  return parcNetwork_LinkAddress_BuildString(addr, length, composer);
-}
-
-static ssize_t _UnixToString(char *output, size_t remaining_size,
-                             const PARCBuffer *addr) {
-  parcAssertNotNull(output, "parameter output must be non-null");
-  parcBuffer_AssertValid(addr);
-
-  parcAssertTrue(parcBuffer_Remaining(addr) == sizeof(struct sockaddr_un),
-                 "Address corrupted. Expected %zu actual %zu",
-                 sizeof(struct sockaddr_un), parcBuffer_Remaining(addr));
-
-  // sockaddr length for the path, 16 for the ascii stuff, 3 for the length
-  // number
-  struct sockaddr_un *saddr =
-      (struct sockaddr_un *)parcBuffer_Overlay((PARCBuffer *)addr, 0);
-  size_t min_remaining = strlen(saddr->sun_path) + 16 + 3;
-  parcAssertTrue(remaining_size >= min_remaining,
-                 "Remaining size too small, need at least %zu", min_remaining);
-
-  ssize_t output_length = sprintf(output, "{ .path=%s, .len=%zu }",
-                                  saddr->sun_path, strlen(saddr->sun_path));
-  return output_length;
-}
-
-static ssize_t _IfaceToString(char *output, size_t remaining_size,
-                              const PARCBuffer *addr) {
-  parcAssertNotNull(output, "parameter output must be non-null");
-  parcBuffer_AssertValid(addr);
-
-  parcAssertTrue(parcBuffer_Remaining(addr) == sizeof(uint32_t),
-                 "Address corrupted. Expected %zu actual %zu", sizeof(uint32_t),
-                 parcBuffer_Remaining(addr));
-
-  uint32_t *ifidx = (uint32_t *)parcBuffer_Overlay((PARCBuffer *)addr, 0);
-
-  ssize_t output_length = sprintf(output, "{ .ifidx=%u }", ntohl(*ifidx));
-
-  return output_length;
-}
-
-PARCBufferComposer *addressBuildString(const Address *address,
-                                       PARCBufferComposer *composer) {
-  if (address != NULL) {
-    char *str = addressToString(address);
-    parcBufferComposer_PutString(composer, str);
-    parcMemory_Deallocate((void **)&str);
-  }
-  return composer;
-}
-
-char *addressToString(const Address *address) {
-  addressAssertValid(address);
-
-  char addrstr[256];
-
-  switch (address->addressType) {
-    case ADDR_INET: {
-      PARCBufferComposer *composer = parcBufferComposer_Create();
-      PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(
-          _Inet_BuildString(address, composer));
-      char *result = parcBuffer_ToString(tempBuffer);
-      parcBuffer_Release(&tempBuffer);
-      parcBufferComposer_Release(&composer);
-      return result;
-    } break;
-
-    case ADDR_INET6: {
-      PARCBufferComposer *composer = parcBufferComposer_Create();
-
-      PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(
-          _Inet6_BuildString(address, composer));
-      char *result = parcBuffer_ToString(tempBuffer);
-      parcBuffer_Release(&tempBuffer);
-
-      parcBufferComposer_Release(&composer);
-      return result;
-    } break;
-
-    case ADDR_LINK:
-      _UnixToString(addrstr, 256, address->blob);
-      break;
-
-    case ADDR_IFACE: {
-      PARCBufferComposer *composer = parcBufferComposer_Create();
-
-      PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(
-          _Link_BuildString(address, composer));
-      char *result = parcBuffer_ToString(tempBuffer);
-      parcBuffer_Release(&tempBuffer);
-
-      parcBufferComposer_Release(&composer);
-      return result;
-    } break;
-
-    case ADDR_UNIX:
-      _IfaceToString(addrstr, 256, address->blob);
-      break;
-
-    default:
-      sprintf(addrstr, "UNKNOWN type = %d", address->addressType);
-      break;
-  }
-
-  ssize_t alloc_size = 1024;
-  char *output = parcMemory_Allocate(alloc_size);
-  parcAssertNotNull(output, "parcMemory_Allocate(%zu) returned NULL",
-                    alloc_size);
-  ssize_t output_length =
-      snprintf(output, alloc_size, "{ .type=%s, .data=%s }",
-               addressTypeToString(address->addressType), addrstr);
-
-  parcAssertTrue(output_length < alloc_size,
-                 "allocated size too small, needed %zd", output_length);
-  parcAssertFalse(output_length < 0, "snprintf error: (%d) %s", errno,
-                  strerror(errno));
-
-  return output;
-}
-
-PARCHashCode addressHashCode(const Address *address) {
-  addressAssertValid(address);
-
-  PARCHashCode hash = parcBuffer_HashCode(address->blob);
-  hash = parcHashCode_HashImpl((uint8_t *)&address->addressType,
-                               sizeof(address->addressType), hash);
-
-  return hash;
-}
diff --git a/hicn-light/src/hicn/utils/address.h b/hicn-light/src/hicn/utils/address.h
deleted file mode 100644
index 6ca98347a..000000000
--- a/hicn-light/src/hicn/utils/address.h
+++ /dev/null
@@ -1,524 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * @brief Represents an endpoint address.
- *
- * Represents an endpoint address.  May be INET, INET6, or a multi-byte LINK,
- * or an Interface Index.
- *
- * INET and INET6 must contain the .sa_addr member, and other members as needed
- * by the use of the address.
- *
- * The Interface Index address is essentially a pointer to a device.
- *
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-#ifndef address_h
-#define address_h
-
-#ifndef _WIN32
-#include <netinet/in.h>
-#include <sys/un.h>
-#endif
-#include <stdbool.h>
-
-#include <parc/algol/parc_Buffer.h>
-#include <parc/algol/parc_BufferComposer.h>
-#include <hicn/utils/commands.h>
-
-/**
- * Return a string representation of the given `address_type`
- *
- * @param [in] type A valid address_type value.
- *
- * @return NULL An error occurred
- * @return non-NULL A pointer to a static string representation of the
- * `address_type`.
- *
- * Example:
- * @code
- * {
- *     const char *typeAsString = addressTypeToString(commandAddrType_INET);
- * }
- * @endcode
- *
- * @see addressStringToType
- */
-const char *addressTypeToString(address_type type);
-
-/**
- * Return a `address_type` from the given nul-terminated C string.
- *
- * @param [in] typeAsString A nul-terminated, C string representation of a
- * `address_type`.
- *
- * @return A address_type
- *
- * Example:
- * @code
- * {
- *     address_type type = addressTypeToString("INET");
- * }
- * @endcode
- *
- * @see addressTypeToString
- */
-address_type addressStringToType(const char *typeAsString);
-
-struct address;
-typedef struct address Address;
-
-/**
- * Create a new `Address` instance from an IPv4 IP address, the port is
- * optional.
- *
- * The sockaddr_in should be filled in network byte order. The newly created
- * instance must eventually be destroyed by calling {@link addressDestroy}().
- *
- * @param [in] addr_in The `sockaddr_in` representing the IPv4 IP address with
- * which to initialize the new `Address` instance.
- * @return A new instance of `Address` that must eventually be destroyed by
- * calling {@link addressDestroy}().
- *
- * Example:
- * @code
- * {
- *     Address *dest = addressCreateFromInet(
- *                                                  &(struct sockaddr_in) {
- *                                                      .sa_addr =
- * inet_addr("foo.bar.com"), .sa_port = htons(9695) } ); addressDestroy(&dest);
- * }
- * @endcode
- * @see addressDestroy
- */
-Address *addressCreateFromInet(struct sockaddr_in *addr_in);
-
-/**
- * Create a new `Address` instance from an IPv6 IP address, the port is
- * optional.
- *
- *
- * The sockaddr_in should be filled in network byte order. The newly created
- * instance must eventually be destroyed by calling {@link addressDestroy}().
- *
- * @param [in] addr_in6 A `sockaddr_in6` from which to initialize a new instance
- * of Address
- * @return A new instance of `Address` that must eventually be destroyed by
- * calling {@link addressDestroy}()
- *
- * Example:
- * @code
- * {
- *     struct sockaddr_in6 addr_in6;
- *     memset(&addr_in6, 0, sizeof(struct sockaddr_in6));
- *
- *     inet_pton(AF_INET6, "2001:720:1500:1::a100", &(addr_in6.sin6_addr));
- *     addr_in6.sin6_family = AF_INET6;
- *     addr_in6.sin6_port = 0x0A0B;
- *     addr_in6.sin6_flowinfo = 0x01020304;
- *
- *     Address *address = addressCreateFromInet6(&addr_in6);
- *
- *     addressDestroy(&address);
- * }
- * @endcode
- * @see addressDestroy
- */
-Address *addressCreateFromInet6(struct sockaddr_in6 *addr_in6);
-
-/**
- * Convert an internet address family (IPv4) to the address format used by the
- * Fwd.
- *
- * @param [in] addr4    IPV4 address in *Network byte order*
- * @param [in] port     Port number in *Network byte order*
- *
- * @return  A new instance of `Address` that must eventually be destroyed by
- * calling {@link addressDestroy}()
- */
-Address *addressFromInaddr4Port(in_addr_t *addr4, in_port_t *port);
-
-/**
- * Convert an internet address family (IPv6) to the address format used by the
- * Fwd
- *
- * @param [in] addr6    IPV4 address in *Network byte order*
- * @param [in] port     Port number in *Network byte order*
- *
- * @return  A new instance of `Address` that must eventually be destroyed by
- * calling {@link addressDestroy}()
- */
-Address *addressFromInaddr6Port(struct in6_addr *addr6, in_port_t *port);
-
-/**
- * Create a new `Address` instance, initialized from a Link address.
- *
- * User must know the link address format (i.e. token ring vs ethernet) and have
- * the address in a byte array. The array is encoded in left-to-right order. The
- * newly created instance must eventually be destroyed by calling {@link
- * addressDestroy}().
- *
- * @param [in] linkaddr A byte array containing the link address
- * @param [in] length The length of the link address byte array
- * @return A new instance of `Address` that must eventually be destroyed by
- * calling {@link addressDestroy}()
- *
- * Example:
- * @code
- * {
- *     uint8_t mac[] = { 0x14, 0x10, 0x9f, 0xd7, 0x0b, 0x89 };
- *     Address *address = addressCreateFromLink(mac, sizeof(mac));
- *
- *     addressDestroy(&address);
- * }
- * @endcode
- * @see addressDestroy
- */
-Address *addressCreateFromLink(const uint8_t *linkaddr, size_t length);
-
-/**
- * Create a new `Address` instance from a network interface index.
- *
- * The interfaceIndex should be in host byte order. The newly created instance
- * must eventually be destroyed by calling {@link addressDestroy}().
- *
- * @param [in] interfaceIndex The index of the interface to encode
- * @return A new instance of `Address` that must eventually be destroyed by
- * calling {@link addressDestroy}()
- *
- * Example:
- * @code
- * {
- *     Address *address = addressCreateFromInterface(2);
- *
- *     addressDestroy(&address);
- * }
- * @endcode
- * @see addressDestroy
- */
-Address *addressCreateFromInterface(uint32_t interfaceIndex);
-
-/**
- * Create a new Address instance from a PF_UNIX address domain.
- *
- * The newly created instance must eventually be destroyed by calling {@link
- * addressDestroy}().
- *
- * @param [in] addr_un The `struct sockaddr_un` specifying the local PF_UNIX
- * socket address
- * @return A new instance of `Address` that must eventually be destroyed by
- * calling {@link addressDestroy}()
- *
- * Example:
- * @code
- * {
- *     struct sockaddr_un addr_unix;
- *     memset(&addr_unix, 0, sizeof(struct sockaddr_un));
- *     char path[] = "/Hello/Cruel/World";
- *     strcpy(addr_un.sun_path, path);
- *     addr_un.sun_family = AF_UNIX;
- *
- *     Address *address = addressCreateFromUnix(&addr_un);
- *
- *     addressDestroy(&address);
- * }
- * @endcode
- * @see addressDestroy
- */
-Address *addressCreateFromUnix(struct sockaddr_un *addr_un);
-
-/**
- * Create a deep copy of an instance of a `Address`. A completely new,
- * indedependent instance is created.
- *
- * The newly created instance must eventually be destroyed by calling {@link
- * addressDestroy}().
- *
- * @param [in] original A pointer to a `Address` instance to be copied.
- * @return A new instance of a Address, deep copied from the `original`
- * instance.
- *
- * Example:
- * @code
- * {
- *     Address *address = addressCreateFromInterface(2);
- *
- *     Address *copy = addressCopy(address);
- *
- *     addressDestroy(&address);
- *     addressDestroy(&copy);
- * }
- * @endcode
- * @see addressDestroy
- */
-Address *addressCopy(const Address *original);
-
-/**
- * Deallocate an instance of a Address.
- *
- * The Address instance is deallocated, and any referenced data is also
- * deallocated. The referenced pointer is set to NULL upon return.
- *
- * @param [in] addressPtr A pointer to a pointer to an instance of Address.
- *
- * Example:
- * @code
- * {
- *     Address *address = addressCreateFromInterface(2);
- *
- *     addressDestroy(&address);
- * }
- * @endcode
- */
-void addressDestroy(Address **addressPtr);
-
-/**
- * Determine if two Address instances are equal.
- *
- *
- * The following equivalence relations on non-null `Address` instances are
- * maintained:
- *
- *  * It is reflexive: for any non-null reference value x, `addressEquals(x, x)`
- *      must return true.
- *
- *  * It is symmetric: for any non-null reference values x and y,
- *    `addressEquals(x, y)` must return true if and only if
- *        `addressEquals(y, x)` returns true.
- *
- *  * It is transitive: for any non-null reference values x, y, and z, if
- *        `addressEquals(x, y)` returns true and
- *        `addressEquals(y, z)` returns true,
- *        then  `addressEquals(x, z)` must return true.
- *
- *  * It is consistent: for any non-null reference values x and y, multiple
- *      invocations of `addressEquals(x, y)` consistently return true or
- *      consistently return false.
- *
- *  * For any non-null reference value x, `addressEquals(x, NULL)` must
- *      return false.
- *
- * If one address specifies more information than other,
- * e.g. a is INET with a port and b is not, they are not equal.
- *
- * `a` and `b` may be NULL, and NULL == NULL.
- *
- * @param a A pointer to a Address instance
- * @param b A pointer to a Address instance
- * @return true if the two instances are equal
- * @return false if the two instances are not equal
- *
- * Example:
- * @code
- * {
- *     Address *address = addressCreateFromInterface(2);
- *     Address *copy = addressCopy(address);
- *
- *     if (addressEquals(address, copy)) {
- *         // true
- *     }  else {
- *         // false
- *     }
- *
- *     addressDestroy(&address);
- *     addressDestroy(&copy);
- * }
- * @endcode
- */
-bool addressEquals(const Address *a, const Address *b);
-
-/**
- * Return the {@link address_type} from a specified Address.
- *
- * @param [in] A pointer to a Address instance
- *
- * @return the {@link address_type} of the specified Address instance
- *
- * Example:
- * @code
- * {
- *     Address *address = addressCreateFromInterface(2);
- *
- *     address_type type = addressGetType(address);
- *
- *     addressDestroy(&address);
- * }
- * @endcode
- *
- * @see address_type
- */
-address_type addressGetType(const Address *address);
-
-/**
- * Fills in the output parameter with an INET address.
- *
- * @param addr_in must be non-NULL
- * @return true if INET address and output filled in, false otherwise.
- *
- */
-bool addressGetInet(const Address *address, struct sockaddr_in *addr_in);
-
-/**
- * Retrieve the INET6 address associated with a `Address` instance.
- *
- * If the specified Address instance is of type {@link commandAddrType_INET6},
- * then populate the supplied `struct sockaddr_in6` from the Address and return
- * true. If the Address is not of type `commandAddrType_INET6`, this function
- * returns false.
- *
- * @param [in] address A pointer to a `Address` instance of type {@link
- * commandAddrType_INET6}.
- * @param [in] addr_in6 A pointer to a `struct sockaddr_in6`. Must be non-NULL.
- * @return true If the Address instance is of type `commandAddrType_INET6` and
- * `addr_in6` was filled in
- * @return false If the Address instance was not of type `commandAddrType_INET6`
- * or `addr_in6` could not be filled in.
- *
- * @see addressGetType
- */
-bool addressGetInet6(const Address *address, struct sockaddr_in6 *addr_in6);
-
-/**
- * Retrieve the interface index associated with a `Address` instance.
- *
- * If the specified `Address` instance is of type {@link commandAddrType_IFACE},
- * then populate the supplied `uint32_t` from the Address and return true. If
- * the `Address` is not of type `commandAddrType_INET6`, this function returns
- * false.
- *
- * @param [in] address A pointer to a `Address` instance of type {@link
- * commandAddrType_IFACE}.
- * @param [in] interfaceIndex A pointer to a `uint32_t` to fill in. Must be
- * non-NULL.
- * @return true If the Address instance is of type `commandAddrType_IFACE` and
- * `interfaceIndex` was filled in.
- * @return false If the Address instance was not of type `commandAddrType_IFACE`
- * or `interfaceIndex` could not be filled in.
- *
- * @see addressGetType
- */
-bool addressGetInterfaceIndex(const Address *address, uint32_t *interfaceIndex);
-
-/**
- * Retrieve the link address associated with a `Address` instance.
- *
- * If the specified `Address` instance is of type {@link commandAddrType_LINK},
- * then return a pointer to the {@link PARCBuffer} containing the link address.
- * If the `Address` is not of type {@link commandAddrType_LINK}, then return
- * NULL. The returned PARCBuffer pointer points to memory managed by the Address
- * instance, and does not need to be destroyed or released on its own.
- *
- * @param [in] address A pointer to a `Address` instance of type {@link
- * commandAddrType_LINK}.
- * @return A pointer to the {@link PARCBuffer} containing the link address.
- *
- * Example:
- * @code
- * {
- *     uint8_t mac[] = { 0x14, 0x10, 0x9f, 0xd7, 0x0b, 0x89 };
- *     Address *address = addressCreateFromLink(mac, sizeof(mac));
- *
- *     PARCBuffer *macBuffer = addressGetLinkAddress(address);
- *
- *     addressDestroy(&address);
- * }
- * @endcode
- * @see addressGetType
- */
-PARCBuffer *addressGetLinkAddress(const Address *address);
-
-/**
- * Append the string representation of a `Address` to a specified
- * `PARCBufferComposer`.
- *
- * @param [in] address A pointer to a `Address` instance.
- * @param [in] composer A pointer to a `PARCBufferComposer` instance to which to
- * append the string.
- *
- * @return The `PARCBufferComposer` instance that was passed in.
- *
- * Example:
- * @code
- * {
- *     Address *address = addressCreateFromInterface(1);
- *     PARCBufferComposer *composer = addressBuildString(address,
- * parcBufferComposer_Create()); parcBufferComposer_Release(&composer);
- *     addressDestroy(&address);
- * }
- * @endcode
- *
- * @see PARCBufferComposer
- */
-PARCBufferComposer *addressBuildString(const Address *address,
-                                       PARCBufferComposer *composer);
-
-/**
- * Produce a nil-terminated string representation of the specified instance.
- *
- * The result must be freed by the caller via {@link parcMemory_Deallocate}.
- *
- * @param [in] interest A pointer to the instance.
- *
- * @return NULL Cannot allocate memory.
- * @return non-NULL A pointer to an allocated, nul-terminated C string that must
- * be deallocated via {@link parcMemory_Deallocate}().
- *
- * Example:
- * @code
- * {
- *     Address *address = addressCreateFromInterface(1);
- *
- *     char *string = addressToString(address);
- *
- *     if (string != NULL) {
- *         printf("Address looks like: %s\n", string);
- *         parcMemory_Deallocate(string);
- *     } else {
- *         printf("Cannot allocate memory\n");
- *     }
- *
- *     addressDestroy(&address);
- * }
- * @endcode
- * @see parcMemory_Deallocate
- * @see addressBuildString
- */
-char *addressToString(const Address *address);
-
-/**
- * Return a non-cryptographic hash code consistent with Equals
- *
- * If commandAddrA == commandAddrB, then addressHashCode(commandAddrA) ==
- * addressHashCode(commandAddrB)
- *
- * @param [in] address A pointer to a Address instance.
- * @return A 32-bit hashcode for the specified Address instance.
- *
- * Example:
- * @code
- *     Address *address = addressCreateFromInterface(1);
- *
- *     uint32_t hashCode = addressHashCode(address);
- *
- *     addressDestroy(&address);
- * @endcode
- */
-PARCHashCode addressHashCode(const Address *address);
-#endif  // address_h
diff --git a/hicn-light/src/hicn/utils/addressList.c b/hicn-light/src/hicn/utils/addressList.c
deleted file mode 100644
index a64fd6f9e..000000000
--- a/hicn-light/src/hicn/utils/addressList.c
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * 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 <hicn/hicn-light/config.h>
-#include <stdio.h>
-
-#include <parc/assert/parc_Assert.h>
-
-#include <hicn/utils/addressList.h>
-
-#include <parc/algol/parc_ArrayList.h>
-#include <parc/algol/parc_Buffer.h>
-#include <parc/algol/parc_Memory.h>
-
-struct address_list {
-  PARCArrayList *listOfAddress;
-};
-
-static void _addressListFreeAddress(void **addressVoidPtr) {
-  Address **addressPtr = (Address **)addressVoidPtr;
-  addressDestroy(addressPtr);
-}
-
-AddressList *addressListCreate() {
-  AddressList *list = parcMemory_AllocateAndClear(sizeof(AddressList));
-  parcAssertNotNull(list, "parcMemory_AllocateAndClear(%zu) returned NULL",
-                    sizeof(AddressList));
-  list->listOfAddress = parcArrayList_Create(_addressListFreeAddress);
-  parcAssertNotNull(list->listOfAddress, "Got null from parcArrayList_Create");
-
-  return list;
-}
-
-void addressListDestroy(AddressList **addressListPtr) {
-  parcAssertNotNull(addressListPtr,
-                    "Parameter must be non-null double pointer");
-  parcAssertNotNull(*addressListPtr,
-                    "Parameter must dereference to non-null pointer");
-  AddressList *list = *addressListPtr;
-
-  parcArrayList_Destroy(&list->listOfAddress);
-  parcMemory_Deallocate((void **)&list);
-  *addressListPtr = NULL;
-}
-
-AddressList *addressListAppend(AddressList *list, Address *address) {
-  parcAssertNotNull(list, "Parameter list must be non-null");
-  parcAssertNotNull(address, "Parameter address must be non-null");
-
-  parcArrayList_Add(list->listOfAddress, (PARCObject *)address);
-  return list;
-}
-
-AddressList *addressListCopy(const AddressList *original) {
-  parcAssertNotNull(original, "Parameter must be non-null");
-
-  AddressList *copy = addressListCreate();
-  for (int i = 0; i < parcArrayList_Size(original->listOfAddress); i++) {
-    Address *address = (Address *)parcArrayList_Get(original->listOfAddress, i);
-    parcArrayList_Add(copy->listOfAddress, (PARCObject *)addressCopy(address));
-  }
-
-  return copy;
-}
-
-bool addressListEquals(const AddressList *a, const AddressList *b) {
-  parcAssertNotNull(a, "Parameter a must be non-null");
-  parcAssertNotNull(b, "Parameter b must be non-null");
-
-  if (a == b) {
-    return true;
-  }
-
-  if (parcArrayList_Size(a->listOfAddress) !=
-      parcArrayList_Size(b->listOfAddress)) {
-    return false;
-  }
-
-  for (size_t i = 0; i < parcArrayList_Size(a->listOfAddress); i++) {
-    const Address *addr_a = (Address *)parcArrayList_Get(a->listOfAddress, i);
-    const Address *addr_b = (Address *)parcArrayList_Get(b->listOfAddress, i);
-    if (!addressEquals(addr_a, addr_b)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-size_t addressListLength(const AddressList *list) {
-  parcAssertNotNull(list, "Parameter must be non-null");
-  return parcArrayList_Size(list->listOfAddress);
-}
-
-const Address *addressListGetItem(const AddressList *list, size_t item) {
-  parcAssertNotNull(list, "Parameter must be non-null");
-  parcAssertTrue(item < addressListLength(list),
-                 "Asked for item %zu beyond end of list %zu", item,
-                 addressListLength(list));
-
-  return (Address *)parcArrayList_Get(list->listOfAddress, item);
-}
-
-char *addressListToString(const AddressList *list) {
-  PARCBufferComposer *composer = parcBufferComposer_Create();
-
-  for (size_t i = 0; i < addressListLength(list); i++) {
-    char *addressString = addressToString(addressListGetItem(list, i));
-    parcBufferComposer_PutString(composer, addressString);
-    if (i < (addressListLength(list) - 1)) {
-      parcBufferComposer_PutString(composer, " ");
-    }
-    parcMemory_Deallocate((void **)&addressString);
-  }
-
-  PARCBuffer *buffer = parcBufferComposer_ProduceBuffer(composer);
-  char *result = parcBuffer_ToString(buffer);
-  parcBuffer_Release(&buffer);
-  parcBufferComposer_Release(&composer);
-
-  return result;
-}
diff --git a/hicn-light/src/hicn/utils/addressList.h b/hicn-light/src/hicn/utils/addressList.h
deleted file mode 100644
index 823b0c8cb..000000000
--- a/hicn-light/src/hicn/utils/addressList.h
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * @brief A list of Address instances.
- *
- * An AddressList is a list of addresses.
- * It wraps a PARCLinkedList for type saftey with Address.
- *
- */
-#ifndef address_list_h
-#define address_list_h
-
-#include <hicn/utils/address.h>
-
-struct address_list;
-/**
- * @typedef AddressList
- * @abstract A list of Address instance pointers.
- */
-typedef struct address_list AddressList;
-
-/**
- * Create an instance of {@link AddressList}
- *
- * @return NULL An error occurred
- * @return non-NULL A pointer to a valid AddressList instance.
- *
- * Example:
- * @code
- * {
- *     AddressList *list = addressListCreate();
- *
- * }
- * @endcode
- *
- * @see addressListDestroy
- */
-AddressList *addressListCreate(void);
-
-/**
- * Dellocate and destroy a AddressList instance.
- *
- * @param [in] addressListPtr A pointer to a pointer to a valid {@link
- * AddressList}.
- *
- *
- * Example:
- * @code
- * {
- *     AddressList *list = addressListCreate(void);
- *     addressListDestroy(&list);
- * }
- * @endcode
- *
- * @see addressListCreate
- */
-void addressListDestroy(AddressList **addressListPtr);
-
-/**
- * Appends the address, taking ownership of the memory
- *
- * @param list A pointer to a AddressList.
- * @param address must be non-null
- * @return The input list
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-AddressList *addressListAppend(AddressList *list, Address *address);
-
-/**
- * Creates a reference counted copy
- *
- * @param list A pointer to a valid {@link AddressList}.
- *
- * @return An allocated list, you must destroy it.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-AddressList *addressListCopy(const AddressList *list);
-
-/**
- * Determine if two AddressList instances are equal.
- *
- * Two AddressList instances are equal if, and only if, they have the same
- * length, with the same elements in the same order.
- *
- *
- * The following equivalence relations on non-null `AddressList` instances are
- * maintained:
- *
- *  * It is reflexive: for any non-null reference value x,
- * `AddressList_Equals(x, x)` must return true.
- *
- *  * It is symmetric: for any non-null reference values x and y,
- *    `AddressList_Equals(x, y)` must return true if and only if
- *        `addressListEquals(y, x)` returns true.
- *
- *  * It is transitive: for any non-null reference values x, y, and z, if
- *        `addressListEquals(x, y)` returns true and
- *        `addressListEquals(y, z)` returns true,
- *        then  `addressListEquals(x, z)` must return true.
- *
- *  * It is consistent: for any non-null reference values x and y, multiple
- *      invocations of `addressListEquals(x, y)` consistently return true or
- *      consistently return false.
- *
- *  * For any non-null reference value x, `addressListEquals(x, NULL)` must
- *      return false.
- *
- * @param a A pointer to a `AddressList` instance.
- * @param b A pointer to a `AddressList` instance.
- * @return true if the two `AddressList` instances are equal.
- *
- * Example:
- * @code
- * {
- *    AddressList *a = addressListCreate();
- *    AddressList *b = addressListCreate();
- *
- *    if (addressListEquals(a, b)) {
- *        // true
- *    } else {
- *        // false
- *    }
- * }
- * @endcode
- */
-bool addressListEquals(const AddressList *a, const AddressList *b);
-
-/**
- * Get the number of items in the list
- *
- * @param list A pointer to a {@link AddressList}.
- * @return The number of items in the list.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-size_t addressListLength(const AddressList *list);
-
-/**
- * Returns a const reference to an item.
- * Use addressCopy if needed.
- *
- * Do not free or modify the returned value.
- * Use addressCopy if you   need a mutable instance.
- *
- * @param list A pointer to a AddressList.
- * @param item A value less than the number of items in the given {@link
- * AddressList}.
- * @return Asserts if item off end of list.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-const Address *addressListGetItem(const AddressList *list, size_t item);
-
-/**
- * Get a nul-terminated, C-string representation of the given {@link
- * AddressList}.
- *
- * @param list A pointer to a valid {@link AddressList} instance.
- *
- * @return An allocate string representation of the {@link AddressList} that
- * must be freed via `parcMemory_Deallocate()`.
- *
- * Example:
- * @code
- * <#example#>
- * @endcode
- */
-char *addressListToString(const AddressList *list);
-#endif  // address_list_h
diff --git a/hicn-light/src/hicn/utils/interface.c b/hicn-light/src/hicn/utils/interface.c
index d8597f3ed..c3f8793a4 100644
--- a/hicn-light/src/hicn/utils/interface.c
+++ b/hicn-light/src/hicn/utils/interface.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -22,12 +22,14 @@
 #include <parc/algol/parc_BufferComposer.h>
 #include <parc/algol/parc_Memory.h>
 #include <parc/algol/parc_Object.h>
-#include <hicn/utils/addressList.h>
+//#include <hicn/utils/addressList.h>
 #include <hicn/utils/interface.h>
 
 #include <parc/assert/parc_Assert.h>
 #include <hicn/utils/commands.h>
 
+#if 0
+
 struct interface {
   char *name;
   unsigned interfaceIndex;
@@ -166,3 +168,5 @@ unsigned interfaceGetMTU(const Interface *iface) {
   parcAssertNotNull(iface, "Parameter iface must be non-null");
   return iface->mtu;
 }
+
+#endif
diff --git a/hicn-light/src/hicn/utils/interface.h b/hicn-light/src/hicn/utils/interface.h
index fd91edb1d..365624e4a 100644
--- a/hicn-light/src/hicn/utils/interface.h
+++ b/hicn-light/src/hicn/utils/interface.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -22,8 +22,7 @@
 #ifndef interface_h
 #define interface_h
 
-#include <hicn/utils/address.h>
-#include <hicn/utils/addressList.h>
+#include <hicn/core/address.h>
 
 struct interface;
 typedef struct interface Interface;
@@ -59,7 +58,7 @@ void interfaceDestroy(Interface **interfacePtr);
  * <#example#>
  * @endcode
  */
-void interfaceAddAddress(Interface *iface, Address *address);
+void interfaceAddAddress(Interface *iface, address_t *address);
 
 /**
  * Retrieves a list of interface addresses
@@ -74,7 +73,7 @@ void interfaceAddAddress(Interface *iface, Address *address);
  * <#example#>
  * @endcode
  */
-const AddressList *interfaceGetAddresses(const Interface *iface);
+const address_t **interfaceGetAddresses(const Interface *iface);
 
 /**
  * The interface index
diff --git a/hicn-light/src/hicn/utils/interfaceSet.c b/hicn-light/src/hicn/utils/interfaceSet.c
index 3ae52bb80..e06643fc7 100644
--- a/hicn-light/src/hicn/utils/interfaceSet.c
+++ b/hicn-light/src/hicn/utils/interfaceSet.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-light/src/hicn/utils/interfaceSet.h b/hicn-light/src/hicn/utils/interfaceSet.h
index e43f985fe..6723bc493 100644
--- a/hicn-light/src/hicn/utils/interfaceSet.h
+++ b/hicn-light/src/hicn/utils/interfaceSet.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-light/src/hicn/utils/punting.c b/hicn-light/src/hicn/utils/punting.c
index 8f33cf763..60a8d2355 100644
--- a/hicn-light/src/hicn/utils/punting.c
+++ b/hicn-light/src/hicn/utils/punting.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+#if 0
 #include <hicn/hicn-light/config.h>
 #include <stdio.h>
 
@@ -23,11 +24,11 @@
 
 struct punting {
   char *symbolic;
-  Address *prefix;
+  address_t *prefix;
   uint32_t len;
 };
 
-Punting *puntingCreate(const char *listenerName, Address *prefix,
+Punting *puntingCreate(const char *listenerName, address_t *prefix,
                        uint32_t len) {
   parcAssertNotNull(listenerName, "Parameter listenerName must be non-null");
   parcAssertNotNull(prefix, "Parameter prefix must be non-null");
@@ -87,7 +88,7 @@ const char *puntingGetSymbolicName(const Punting *punting) {
   return punting->symbolic;
 }
 
-Address *puntingGetAddress(const Punting *punting) {
+address_t * puntingGetAddress(const Punting *punting) {
   parcAssertNotNull(punting, "Parameter listener must be non-null");
   return punting->prefix;
 }
@@ -96,3 +97,4 @@ uint32_t puntingPrefixLen(const Punting *punting) {
   parcAssertNotNull(punting, "Parameter listener must be non-null");
   return punting->len;
 }
+#endif
diff --git a/hicn-light/src/hicn/utils/punting.h b/hicn-light/src/hicn/utils/punting.h
index 9be1baed4..46cec8a91 100644
--- a/hicn-light/src/hicn/utils/punting.h
+++ b/hicn-light/src/hicn/utils/punting.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,10 +16,21 @@
 #ifndef punting_h
 #define punting_h
 
+#include <hicn/core/address.h>
+
+typedef struct {
+  char *symbolic;
+  address_t prefix;
+  uint32_t len;
+} punting_t;
+
+#define punting_address(punting) (&((punting)->prefix))
+#define punting_len(punting) ((punting)->len)
+
+#if 0
 struct punting;
 typedef struct punting Punting;
 
-#include <hicn/utils/address.h>
 
 /**
  * Creates a Punting object
@@ -36,7 +47,7 @@ typedef struct punting Punting;
  * @return null An error
  *
  */
-Punting *puntingCreate(const char *symbolic, Address *prefix, uint32_t len);
+Punting *puntingCreate(const char *symbolic, address_t *prefix, uint32_t len);
 
 /**
  * Releases a reference count to the object
@@ -66,7 +77,9 @@ const char *puntingGetSymbolicName(const Punting *punting);
  * Returns the address (INET or INET6 ip address)
  *
  */
-Address *puntingGetAddress(const Punting *punting);
+address_t * puntingGetAddress(const Punting *punting);
 
 uint32_t puntingPrefixLen(const Punting *punting);
+#endif
+
 #endif  // punting_h
diff --git a/hicn-light/src/hicn/utils/token.h b/hicn-light/src/hicn/utils/token.h
index 43e0a77b2..138916f31 100644
--- a/hicn-light/src/hicn/utils/token.h
+++ b/hicn-light/src/hicn/utils/token.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -19,7 +19,7 @@
  * 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
+#define PPCAT_NX(A, B) A##B
 
 /*
  * Concatenate preprocessor tokens A and B after macro-expanding them.
diff --git a/hicn-light/src/hicn/utils/utils.c b/hicn-light/src/hicn/utils/utils.c
deleted file mode 100644
index 36596f943..000000000
--- a/hicn-light/src/hicn/utils/utils.c
+++ /dev/null
@@ -1,235 +0,0 @@
-// Utility function for commands
-
-#ifndef _WIN32
-#include <netinet/in.h>
-#endif
-
-#include <ctype.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <parc/algol/parc_Memory.h>
-#include <parc/algol/parc_Network.h>
-#include <parc/assert/parc_Assert.h>
-#include <pthread.h>
-#include <hicn/utils/utils.h>
-
-// This is the unique sequence number used by all messages and its thread locks
-static pthread_mutex_t nextSequenceNumberMutex = PTHREAD_MUTEX_INITIALIZER;
-static uint32_t nextSequenceNumber = 1;
-
-uint32_t utils_GetNextSequenceNumber(void) {
-  uint32_t seqnum;
-
-  int result = pthread_mutex_lock(&nextSequenceNumberMutex);
-  parcAssertTrue(result == 0, "Got error from pthread_mutex_lock: %d", result);
-
-  seqnum = nextSequenceNumber++;
-
-  result = pthread_mutex_unlock(&nextSequenceNumberMutex);
-  parcAssertTrue(result == 0, "Got error from pthread_mutex_unlock: %d",
-                 result);
-
-  return seqnum;
-}
-
-/**
- * Return true if string is purely an integer
- */
-bool utils_IsNumber(const char *string) {
-  size_t len = strlen(string);
-  for (size_t i = 0; i < len; i++) {
-    if (!isdigit(string[i])) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/**
- * A symbolic name must be at least 1 character and must begin with an alpha.
- * The remainder must be an alphanum.
- */
-bool utils_ValidateSymbolicName(const char *symbolic) {
-  bool success = false;
-  size_t len = strlen(symbolic);
-  if (len > 0) {
-    if (isalpha(symbolic[0])) {
-      success = true;
-      for (size_t i = 1; i < len; i++) {
-        if (!isalnum(symbolic[i])) {
-          success = false;
-          break;
-        }
-      }
-    }
-  }
-  return success;
-}
-
-struct iovec *utils_CreateAck(header_control_message *header, void *payload,
-                              size_t payloadLen) {
-  struct iovec *response =
-      parcMemory_AllocateAndClear(sizeof(struct iovec) * 2);
-
-  header->messageType = ACK_LIGHT;
-
-  response[0].iov_base = header;
-  response[0].iov_len = sizeof(header_control_message);
-  response[1].iov_base = payload;
-  response[1].iov_len = payloadLen;
-
-  return response;
-}
-
-struct iovec *utils_CreateNack(header_control_message *header, void *payload,
-                               size_t payloadLen) {
-  struct iovec *response =
-      parcMemory_AllocateAndClear(sizeof(struct iovec) * 2);
-
-  header->messageType = NACK_LIGHT;
-  response[0].iov_base = header;
-  response[0].iov_len = sizeof(header_control_message);
-  response[1].iov_base = payload;
-  response[1].iov_len = payloadLen;
-
-  return response;
-}
-
-char *utils_BuildStringFromInet(in_addr_t *addr4, in_port_t *port) {
-  struct sockaddr_in addr;
-  memset(&addr, 0, sizeof(addr));
-  addr.sin_family = AF_INET;
-  addr.sin_port = *port;
-  addr.sin_addr.s_addr = *addr4;
-
-  PARCBufferComposer *composer = parcBufferComposer_Create();
-  PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(
-      parcNetwork_SockInet4Address_BuildString(&addr, composer));
-  char *result = parcBuffer_ToString(tempBuffer);
-  parcBuffer_Release(&tempBuffer);
-  parcBufferComposer_Release(&composer);
-  return result;
-}
-
-char *utils_BuildStringFromInet6(struct in6_addr *addr6, in_port_t *port) {
-  struct sockaddr_in6 addr;
-  memset(&addr, 0, sizeof(addr));
-  addr.sin6_family = AF_INET6;
-  addr.sin6_port = *port;
-  addr.sin6_addr = *addr6;
-
-  PARCBufferComposer *composer = parcBufferComposer_Create();
-  PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(
-      parcNetwork_SockInet6Address_BuildString(&addr, composer));
-  char *result = parcBuffer_ToString(tempBuffer);
-  parcBuffer_Release(&tempBuffer);
-  parcBufferComposer_Release(&composer);
-  return result;
-}
-
-char *utils_CommandAddressToString(address_type addressType,
-                                   ip_address_t *address,
-                                   in_port_t *port) {
-  char *result;
-
-  switch (addressType) {
-    case ADDR_INET: {
-      result = utils_BuildStringFromInet(&address->v4.as_u32, port);
-      break;
-    }
-
-    case ADDR_INET6: {
-      result = utils_BuildStringFromInet6(&address->v6.as_in6addr, port);
-      break;
-    }
-
-    default: {
-      char *addrStr = (char *)parcMemory_Allocate(sizeof(char) * 32);
-      sprintf(addrStr, "Error: UNKNOWN address type = %d", addressType);
-      result = addrStr;
-      break;
-    }
-  }
-  return result;
-}
-
-struct iovec *utils_SendRequest(ControlState *state, command_id command,
-                                void *payload, size_t payloadLen) {
-  bool success = false;
-
-  // get sequence number for the header
-  uint32_t currentSeqNum = utils_GetNextSequenceNumber();
-
-  // Allocate and fill the header
-  header_control_message *headerControlMessage =
-      parcMemory_AllocateAndClear(sizeof(header_control_message));
-  headerControlMessage->messageType = REQUEST_LIGHT;
-  headerControlMessage->commandID = command;
-  headerControlMessage->seqNum = currentSeqNum;
-  if (payloadLen > 0) {
-    headerControlMessage->length = 1;
-  }
-
-  struct iovec msg[2];
-  msg[0].iov_base = headerControlMessage;
-  msg[0].iov_len = sizeof(header_control_message);
-  msg[1].iov_base = payload;
-  msg[1].iov_len = payloadLen;
-
-  struct iovec *response = controlState_WriteRead(state, msg);
-
-  header_control_message *receivedHeader =
-      (header_control_message *)response[0].iov_base;
-  if (receivedHeader->seqNum != currentSeqNum) {
-    printf("Seq number is NOT correct: expected %d got %d  \n", currentSeqNum,
-           receivedHeader->seqNum);
-    // failure
-  } else {
-    if (receivedHeader->messageType == RESPONSE_LIGHT) {
-      return response;  // command needs both payload and header
-    } else {
-      if (receivedHeader->messageType == ACK_LIGHT) {
-        success = true;
-      } else if (receivedHeader->messageType == NACK_LIGHT) {
-        success = true;
-      } else {
-        printf("Error: unrecognized message type");  // failure
-      }
-    }
-  }
-
-  // deallocate when payload & header of the response are not needed
-  if (receivedHeader->length > 0) {
-    parcMemory_Deallocate(&response[1].iov_base);  // free received payload
-  }
-  parcMemory_Deallocate(&response[0].iov_base);  // free receivedHeader
-
-  // return response
-  if (success) {
-    return response;
-  } else {
-    parcMemory_Deallocate(&response);  // free iovec pointer
-    return NULL;                       // will generate a failure
-  }
-}
-
-const char *utils_PrefixLenToString(address_type addressType,
-                                    ip_address_t *address,
-                                    uint8_t *prefixLen) {
-  char len[4];  // max size + 1
-  sprintf(len, "%u", (unsigned)*prefixLen);
-  in_port_t port = htons(1234);  // this is a random port number that is ignored
-
-  char *prefix = utils_CommandAddressToString(addressType, address, &port);
-  char *prefixStr = malloc(strlen(prefix) + strlen(len) + 2);
-  strcpy(prefixStr, prefix);
-  strcat(prefixStr, "/");
-  strcat(prefixStr, len);
-
-  free(prefix);
-
-  return prefixStr;
-}
diff --git a/hicn-light/src/hicn/utils/utils.h b/hicn-light/src/hicn/utils/utils.h
deleted file mode 100644
index 1fe88e62c..000000000
--- a/hicn-light/src/hicn/utils/utils.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * 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 utils_h
-#define utils_h
-
-#include <hicn/config/controlState.h>
-#include <hicn/utils/address.h>
-#include <hicn/utils/commands.h>
-
-/**
- * Return true if string is purely an integer
- */
-bool utils_IsNumber(const char *string);
-
-/**
- * A symbolic name must be at least 1 character and must begin with an alpha.
- * The remainder must be an alphanum.
- */
-bool utils_ValidateSymbolicName(const char *symbolic);
-
-/**
- *Create an Ack message instance as a response of a control successfully
- *completed.
- */
-struct iovec *utils_CreateAck(header_control_message *header, void *payload,
-                              size_t payloadLen);
-
-/**
- *Create a Nack message instance as a response of a control unsuccessfully
- *completed.
- */
-struct iovec *utils_CreateNack(header_control_message *header, void *payload,
-                               size_t payloadLen);
-
-/**
- *Convert IPv4/IPv6 address from binary to text string. `uint8_t *ipAddress` has
- *to be a `in_addr_t * or `a struct in6_addr *.
- */
-char *utils_CommandAddressToString(address_type addressType,
-                                   ip_address_t *address, in_port_t *port);
-
-/**
- *Given a command payload, it generates the header and send the request to the
- *deamon.
- */
-struct iovec *utils_SendRequest(ControlState *state, command_id command,
-                                void *payload, size_t payloadLen);
-
-/**
- *Convert a IPv4/IPv6 address plus Netmask len from binary to text string in the
- *form [add]:[port]/[len].
- */
-const char *utils_PrefixLenToString(address_type addressType,
-                                    ip_address_t *address,
-                                    uint8_t *prefixLen);
-
-#endif
diff --git a/hicn-plugin/CMakeLists.txt b/hicn-plugin/CMakeLists.txt
index 9f5553857..965fa5263 100644
--- a/hicn-plugin/CMakeLists.txt
+++ b/hicn-plugin/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,32 +11,51 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+##############################################################
+# Project and cmake version
+##############################################################
 cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
-
 project(hicn-plugin)
 
-include(GNUInstallDirs)
 
+##############################################################
+# Cmake modules
+##############################################################
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
-    "${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Modules/"
-    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/"
+  ${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Modules/
 )
-include(BuildMacros)
-
-set (CMAKE_CXX_STANDARD 11)
-set (CMAKE_C_STANDARD 11)
 
-# Check for memfd_create syscall
-include(CheckSymbolExists)
-CHECK_SYMBOL_EXISTS ( "__NR_memfd_create" "sys/syscall.h" HAVE_MEMFD_CREATE )
-if ( HAVE_MEMFD_CREATE )
-    add_definitions ( -DHAVE_MEMFD_CREATE )
+if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+  include(CommonSetup)
 endif()
 
+
+##############################################################
+# Libs and Bins names
+##############################################################
 set(HICN_PLUGIN hicn-plugin CACHE INTERNAL "" FORCE)
+set(HICNPLUGIN hicn_plugin CACHE INTERNAL "" FORCE)
+set(HICN_API_TEST_PLUGIN hicn_api_test_plugin CACHE INTERNAL "" FORCE)
+set(HICNPLUGIN_SHARED ${HICNPLUGIN}.shared CACHE INTERNAL "" FORCE)
+set(HICN_API_TEST_PLUGIN_SHARED ${HICN_API_TEST_PLUGIN}.shared CACHE INTERNAL "" FORCE)
 
-include (Packaging)
 
-add_subdirectory(src)
+##############################################################
+# Packaging and versioning
+##############################################################
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/packaging.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/../versions.cmake)
 
+
+##############################################################
+# C Standard
+##############################################################
+set (CMAKE_C_STANDARD 11)
+
+
+##############################################################
+# Subdirectories
+##############################################################
+add_subdirectory(includes/vpp_plugins/hicn)
+add_subdirectory(src)
 add_subdirectory(vapi)
diff --git a/hicn-plugin/cmake/Modules/Packaging.cmake b/hicn-plugin/cmake/Modules/Packaging.cmake
deleted file mode 100644
index c0176e78f..000000000
--- a/hicn-plugin/cmake/Modules/Packaging.cmake
+++ /dev/null
@@ -1,56 +0,0 @@
-# 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.
-
-######################
-# Packages section
-######################
-
-set(${HICN_PLUGIN}_DESCRIPTION
-  "A high-performance Hybrid ICN forwarder as a plugin to VPP."
-  CACHE STRING "Description for deb/rpm package."
-)
-
-set(${HICN_PLUGIN}_DEB_DEPENDENCIES
-  "vpp (>= stable_version-release), vpp (<< next_version-release), vpp-plugin-core (>= stable_version-release), vpp-plugin-core (<< next_version-release)"
-  CACHE STRING "Dependencies for deb/rpm package."
-)
-
-set(${HICN_PLUGIN}-dev_DEB_DEPENDENCIES
-  "vpp-dev (>= stable_version-release), vpp-dev (<< next_version-release), libvppinfra-dev (>= stable_version-release), libvppinfra-dev (<< next_version-release)"
-  CACHE STRING "Dependencies for deb/rpm package."
-)
-
-set(${HICN_PLUGIN}_RPM_DEPENDENCIES
-  "vpp >= stable_version-release, vpp < next_version-release, vpp-plugins >= stable_version-release, vpp-plugins < next_version-release"
-  CACHE STRING "Dependencies for deb/rpm package."
-)
-
-set(${HICN_PLUGIN}-dev_RPM_DEPENDENCIES
-  "vpp-devel >= stable_version-release, vpp-devel < next_version-release"
-  CACHE STRING "Dependencies for deb/rpm package."
-)
-
-set(${HICN_PLUGIN}_DEB_PACKAGE_CONTROL_EXTRA
-  "${CMAKE_CURRENT_SOURCE_DIR}/scripts/postinst"
-  CACHE STRING "Control scripts conffiles, postinst, postrm, prerm."
-)
-
-set(${HICN_PLUGIN}_RPM_POST_INSTALL_SCRIPT_FILE
-  "${CMAKE_CURRENT_SOURCE_DIR}/scripts/post"
-  CACHE STRING "Install script that will be copied in the %post section"
-)
-
-set(${HICN_PLUGIN}_RPM_POST_UNINSTALL_SCRIPT_FILE
-  "${CMAKE_CURRENT_SOURCE_DIR}/scripts/postun"
-  CACHE STRING "Uninstall script that will be copied in the %postun section"
-)
\ No newline at end of file
diff --git a/hicn-plugin/cmake/packaging.cmake b/hicn-plugin/cmake/packaging.cmake
new file mode 100644
index 000000000..276fc0b95
--- /dev/null
+++ b/hicn-plugin/cmake/packaging.cmake
@@ -0,0 +1,69 @@
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+######################
+# Packages section
+######################
+
+##############################################################
+# Get VPP version
+##############################################################
+list(GET VPP_DEFAULT_VERSION 0 VPP_VERSION)
+
+set(${HICN_PLUGIN}_DESCRIPTION
+  "A high-performance Hybrid ICN forwarder as a plugin to VPP."
+  CACHE STRING "Description for deb/rpm package."
+)
+
+string(REGEX REPLACE "([0-9]+).([0-9]+)(.[0-9]+)?" "\\1\\2" VER_NO_DOTS ${VPP_DEFAULT_VERSION})
+
+file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/scripts/postinst
+"#!/bin/bash
+
+#########################################################
+# Complete VPP config file with hicn configuration
+#########################################################
+
+if [ -e /etc/vpp/startup.conf ]; then
+    RESULTS=$(sed -n '/hicn[ ]*{/p' /etc/vpp/startup.conf | wc -l)
+    if [[ $RESULTS = 0 ]]; then
+        printf '\n hicn {
+            ## Set PIT size. Default is 131072 entries
+            # pit-size 500000
+            #
+            ## Set CS size. Default is 4096
+            # cs-size 50000
+            #
+            ## Set maximum PIT entries lifetime in milliseconds. Assigned to a PIT entry in case an interest carries a bigger lifetime
+            # pit-lifetime-max 20
+            #
+            ## Percentage of CS to reserve for application producer faces
+            # cs-reserved-app 20\n}' >> /etc/vpp/startup.conf
+    fi;
+fi;
+")
+
+set(${HICN_PLUGIN}_DEB_DEPENDENCIES
+  "${LIBHICN_COMPONENT} (= stable_version), vpp (>= ${VPP_VERSION}), vpp-plugin-core (>= ${VPP_VERSION})"
+  CACHE STRING "Dependencies for deb/rpm package."
+)
+
+set(${HICN_PLUGIN}-dev_DEB_DEPENDENCIES
+  "${LIBHICN_COMPONENT}-dev (= stable_version), vpp-dev (>= ${VPP_VERSION}), libvppinfra-dev (>= ${VPP_VERSION})"
+  CACHE STRING "Dependencies for deb/rpm package."
+)
+
+set(${HICN_PLUGIN}_DEB_PACKAGE_CONTROL_EXTRA
+  "${CMAKE_CURRENT_BINARY_DIR}/scripts/postinst"
+  CACHE STRING "Control scripts conffiles, postinst, postrm, prerm."
+)
diff --git a/cmake/Modules/IosMacros.cmake b/hicn-plugin/includes/vpp_plugins/hicn/CMakeLists.txt
index b1e5cc438..9b463e525 100644
--- a/cmake/Modules/IosMacros.cmake
+++ b/hicn-plugin/includes/vpp_plugins/hicn/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,14 +11,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-if(COMPILE_FOR_IOS)
-  include_directories(iOS)
-endif()
+include(GNUInstallDirs)
 
-macro(find_package_wrapper)
-  if(COMPILE_FOR_IOS)
-    find_host_package(${ARGN})
-  else()
-    find_package(${ARGN})
-  endif()
-endmacro()
\ No newline at end of file
+set(HICNPLUGIN_INCLUDE_DIRS
+  ${CMAKE_CURRENT_SOURCE_DIR}/../..
+  CACHE INTERNAL
+  "" FORCE
+)
+
+set(HICNPLUGIN_TO_INSTALL_HEADER_FILES
+  ${CMAKE_CURRENT_SOURCE_DIR}/error.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_all_api_h.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_api.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_msg_enum.h ""
+  CACHE INTERNAL
+  "" FORCE
+)
\ No newline at end of file
diff --git a/hicn-plugin/src/error.h b/hicn-plugin/includes/vpp_plugins/hicn/error.h
index b33a1b50d..a8a941a79 100644
--- a/hicn-plugin/src/error.h
+++ b/hicn-plugin/includes/vpp_plugins/hicn/error.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -83,7 +83,9 @@
   _ (STRATEGY_NOT_FOUND, -179, "Strategy not found")                          \
   _ (UDP_TUNNEL_NOT_FOUND, -180, "Udp tunnel not found")                      \
   _ (UDP_TUNNEL_SRC_DST_TYPE, -181,                                           \
-     "Src and dst addresses have different type (ipv4 and ipv6)")
+     "Src and dst addresses have different type (ipv4 and ipv6)")             \
+  _ (MAPME_NEXT_HOP_ADDED, -182, "Next hop added to mapme")                   \
+  _ (MAPME_NEXT_HOP_NOT_ADDED, -183, "Next hop added to mapme")
 
 typedef enum
 {
@@ -97,7 +99,7 @@ extern const char *HICN_ERROR_STRING[];
 
 #define get_error_string(errno)                                               \
   (char *) (errno ? HICN_ERROR_STRING[(-errno) - 127] :                       \
-		    HICN_ERROR_STRING[errno])
+			  HICN_ERROR_STRING[errno])
 
 #endif /* //__HICN_ERROR_H__ */
 
diff --git a/hicn-plugin/src/hicn_all_api_h.h b/hicn-plugin/includes/vpp_plugins/hicn/hicn_all_api_h.h
index 1263ea4a2..13769dd58 100644
--- a/hicn-plugin/src/hicn_all_api_h.h
+++ b/hicn-plugin/includes/vpp_plugins/hicn/hicn_all_api_h.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-#include <hicn/hicn.api.h>
+#include <vpp_plugins/hicn/hicn.api.h>
 
 /*
  * fd.io coding-style-patch-verification: ON
diff --git a/hicn-plugin/src/hicn_api.h b/hicn-plugin/includes/vpp_plugins/hicn/hicn_api.h
index e32b785b6..ac45fbf17 100644
--- a/hicn-plugin/src/hicn_api.h
+++ b/hicn-plugin/includes/vpp_plugins/hicn/hicn_api.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,7 +25,7 @@
 
 /* define message structures */
 #define vl_typedefs
-#include <hicn/hicn_all_api_h.h>
+#include <vpp_plugins/hicn/hicn_all_api_h.h>
 #undef vl_typedefs
 
 #endif /* // __HICN_API_H___ */
diff --git a/hicn-plugin/src/hicn_msg_enum.h b/hicn-plugin/includes/vpp_plugins/hicn/hicn_msg_enum.h
index fcf2a1e87..903fbf8c0 100644
--- a/hicn-plugin/src/hicn_msg_enum.h
+++ b/hicn-plugin/includes/vpp_plugins/hicn/hicn_msg_enum.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -24,7 +24,7 @@
 #define vl_msg_id(n, h) n,
 typedef enum
 {
-#include <hicn/hicn_all_api_h.h>
+#include <vpp_plugins/hicn/hicn_all_api_h.h>
   /* We'll want to know how many messages IDs we need... */
   VL_MSG_FIRST_AVAILABLE,
 } vl_msg_id_t;
diff --git a/hicn-plugin/scripts/post b/hicn-plugin/scripts/post
deleted file mode 100644
index dd0a9fbf5..000000000
--- a/hicn-plugin/scripts/post
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/bash
-
-if [ -e /etc/vpp/startup.conf ]; then
-    RESULTS=$(sed -n '/hicn[ ]*{/p' /etc/vpp/startup.conf | wc -l)
-    if [[ $RESULTS = 0 ]]; then
-        printf '\n hicn {
-            ## Set PIT size. Default is 131 072 entries
-            # pit-size 500000
-            #
-            ## Set CS size. Default is 4096
-            # cs-size 50000
-            #
-            ## Set maximum PIT entries lifetime in milliseconds. Assigned to a PIT entry in case an interest carries a bigger lifetime
-            # pit-lifetime-max 20
-            #
-            ## Percentage of CS to reserve for application producer faces
-            # cs-reserved-app 20\n}' >> /etc/vpp/startup.conf
-    fi;
-fi;
-ln -s /usr/lib64/vpp_plugins/hicn_plugin.so /usr/lib/vpp_plugins/hicn_plugin.so
\ No newline at end of file
diff --git a/hicn-plugin/scripts/postinst b/hicn-plugin/scripts/postinst
deleted file mode 100644
index d6d48509c..000000000
--- a/hicn-plugin/scripts/postinst
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/bash
-
-if [ -e /etc/vpp/startup.conf ]; then
-    RESULTS=$(sed -n '/hicn[ ]*{/p' /etc/vpp/startup.conf | wc -l)
-    if [[ $RESULTS = 0 ]]; then
-        printf '\n hicn {
-            ## Set PIT size. Default is 131 072 entries
-            # pit-size 500000
-            #
-            ## Set CS size. Default is 4096
-            # cs-size 50000
-            #
-            ## Set maximum PIT entries lifetime in milliseconds. Assigned to a PIT entry in case an interest carries a bigger lifetime
-            # pit-lifetime-max 20
-            #
-            ## Percentage of CS to reserve for application producer faces
-            # cs-reserved-app 20\n}' >> /etc/vpp/startup.conf
-    fi;
-fi;
\ No newline at end of file
diff --git a/hicn-plugin/scripts/postun b/hicn-plugin/scripts/postun
deleted file mode 100644
index c319f014e..000000000
--- a/hicn-plugin/scripts/postun
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash
-
-if [ -L /usr/lib/vpp_plugins/hicn_plugin.so ]; then
-    rm /usr/lib/vpp_plugins/hicn_plugin.so
-fi;
\ No newline at end of file
diff --git a/hicn-plugin/src/CMakeLists.txt b/hicn-plugin/src/CMakeLists.txt
index 124d9b5cb..2141ec596 100644
--- a/hicn-plugin/src/CMakeLists.txt
+++ b/hicn-plugin/src/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2020 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,290 +11,234 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Dependencies
-find_package(Vpp REQUIRED)
-
-include_directories(${HICN_INCLUDE_DIRS} ${VPP_INCLUDE_DIR})
-
-set(LIBHICN_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/src/mapme.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/src/name.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/src/ops.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/src/protocol/ah.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/src/protocol/icmp.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/src/protocol/ipv4.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/src/protocol/ipv6.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/src/protocol/tcp.c
-)
-
-set(LIBHICN_HEADER_FILES_SRC
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/hicn.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/base.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/common.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/error.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/header.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/name.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/protocol.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/ops.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/mapme.h
-)
-
-set(LIBHICN_HEADER_FILES_PROTOCOL
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/protocol/ah.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/protocol/icmp.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/protocol/icmprd.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/protocol/ipv4.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/protocol/ipv6.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/protocol/tcp.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/protocol/udp.h
-)
+##############################################################
+# Dependencies and third party libs
+##############################################################
+find_package(Vpp ${VPP_DEFAULT_VERSION} EXACT REQUIRED)
+
+if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+  find_package(Libhicn ${CURRENT_VERSION} REQUIRED NO_MODULE)
+  list(APPEND HICN_LIBRARIES hicn::hicn.${LIBTYPE})
+else()
+  set(LIBHICN_LIBRARIES ${LIBHICN_SHARED})
+  list(APPEND DEPENDENCIES
+    ${LIBHICN_LIBRARIES}
+  )
+endif()
 
-set(LIBHICN_HEADER_FILES_UTIL
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/util/ip_address.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/util/token.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/../../lib/includes/hicn/util/types.h
-)
 
+##############################################################
+# Source/Header files
+##############################################################
 set(HICN_PLUGIN_SOURCE_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/hicn.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_api.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/cli.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/hashtb.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/mgmt.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/pcs.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/route.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategy_dpo_ctx.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategy_dpo_manager.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategy_node.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/interest_pcslookup_node.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/interest_hitpit_node.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/interest_hitcs_node.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/data_input_node.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/data_pcslookup_node.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/data_fwd_node.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/error.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/face_cli.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/face.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/face_node.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/iface_node.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/address_mgr.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/face_cons.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/face_prod.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/face_prod_node.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/face_app_cli.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/pg.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_mw.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_mw.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_mw_cli.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_rr.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_rr.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/cache_policies/cs_lru.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/mapme_ack_node.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/mapme_ctrl_node.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/mapme_eventmgr.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/udp_tunnels/udp_decap_node.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/udp_tunnels/udp_tunnel.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_api.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/cli.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/hashtb.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/infra.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/mgmt.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/pcs.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/route.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategy_dpo_ctx.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategy_dpo_manager.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategy_node.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/interest_pcslookup_node.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/interest_hitpit_node.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/interest_hitcs_node.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/data_input_node.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/data_pcslookup_node.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/data_fwd_node.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/error.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/face_cli.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/face.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/face_node.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/iface_node.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/address_mgr.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/face_cons.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/face_prod.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/face_prod_node.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/face_app_cli.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/pg.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_mw.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_mw.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_mw_cli.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_rr.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_rr.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_rp.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_rp.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/cache_policies/cs_lru.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/mapme_ack_node.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/mapme_ctrl_node.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/mapme_eventmgr.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/udp_tunnels/udp_decap_node.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/udp_tunnels/udp_tunnel.c
 )
 
 set(HICN_PLUGIN_HEADER_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_all_api_h.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/hashtb.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/mgmt.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/params.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/pcs.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_api.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/hicn.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/state.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/infra.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_msg_enum.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/parser.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/route.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategy_dpo_ctx.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategy_dpo_manager.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategy.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/interest_pcslookup.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/interest_hitpit.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/interest_hitcs.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/data_pcslookup.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/data_fwd.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/error.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/face_db.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/face.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/face_node.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/iface_node.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/inlines.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/face_dpo.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/address_mgr.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/face_cons.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/face_prod.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/pg.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_mw.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_mw.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_rr.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_rr.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/cache_policies/cs_policy.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/cache_policies/cs_lru.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/mapme.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/mapme_ack.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/mapme_ctrl.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/mapme_eventmgr.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/udp_tunnels/udp_tunnel.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_all_api_h.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_logging.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hashtb.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/mgmt.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/params.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/pcs.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_api.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/state.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/infra.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_msg_enum.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/parser.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/route.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategy_dpo_ctx.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategy_dpo_manager.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategy.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/interest_pcslookup.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/interest_hitpit.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/interest_hitcs.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/data_pcslookup.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/data_fwd.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/error.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/face_db.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/face.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/face_node.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/iface_node.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/inlines.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/face_dpo.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/address_mgr.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/face_cons.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/faces/app/face_prod.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/pg.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_mw.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_mw.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_rr.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_rr.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategies/dpo_rp.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/strategies/strategy_rp.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/cache_policies/cs_policy.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/cache_policies/cs_lru.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/mapme.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/mapme_ack.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/mapme_ctrl.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/mapme_eventmgr.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/udp_tunnels/udp_tunnel.h
 )
 
 set(HICN_API_TEST_SOURCE_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_api_test.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/error.c)
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_api_test.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/error.c
+)
 
 set(HICN_API_HEADER_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_msg_enum.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_all_api_h.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_api.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/error.h)
+  ${HICNPLUGIN_TO_INSTALL_HEADER_FILES}
+)
 
 set(HICN_API_GENERATED_FILES
-    ${CMAKE_CURRENT_BINARY_DIR}/vpp_plugins/hicn/hicn.api.h
-    ${CMAKE_CURRENT_BINARY_DIR}/vpp_plugins/hicn/hicn.api_types.h
-    ${CMAKE_CURRENT_BINARY_DIR}/vpp_plugins/hicn/hicn.api_enum.h
+  ${PROJECT_BINARY_DIR}/vpp_plugins/hicn/hicn.api.h
+  ${PROJECT_BINARY_DIR}/vpp_plugins/hicn/hicn.api_types.h
+  ${PROJECT_BINARY_DIR}/vpp_plugins/hicn/hicn.api_enum.h
 )
 
 set(HICN_VAPI_GENERATED_FILES
-    ${CMAKE_CURRENT_BINARY_DIR}/vapi/hicn.api.vapi.h
-    ${CMAKE_CURRENT_BINARY_DIR}/vapi/hicn.api.vapi.hpp)
+  ${PROJECT_BINARY_DIR}/vapi/hicn.api.vapi.h
+  ${PROJECT_BINARY_DIR}/vapi/hicn.api.vapi.hpp
+)
 
-set(HICN_VPP_STARTUP_CONF_FILE
-    ${CMAKE_BINARY_DIR}/startup.conf)
 
+##############################################################
+# Assume VPP is installed in standard location
+##############################################################
 if (NOT VPP_HOME)
-    set(VPP_HOME /usr)
+  set(VPP_HOME /usr)
 endif()
 
-if (NOT CMAKE_BUILD_TYPE)
-    set (CMAKE_BUILD_TYPE "Release")
-endif (NOT CMAKE_BUILD_TYPE)
-
-SET(HICN_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR} CACHE STRING "hicn_install_prefix")
-
-file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/hicn)
-file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/vapi)
-file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/vnet/ip)
-file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/vnet/fib)
-file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/vnet/udp)
-file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/vpp_plugins)
-file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/vpp_plugins/hicn)
 
-include(Packager)
-extract_version()
-
-# These files are missing from vpp binary distribution
-execute_process(
-    COMMAND
-    bash -c
-    "if [ ! -e ${CMAKE_CURRENT_BINARY_DIR}/vapi_json_parser.py ]; then
-        curl https://raw.githubusercontent.com/FDio/vpp/stable/2106/src/vpp-api/vapi/vapi_json_parser.py -o ${CMAKE_CURRENT_BINARY_DIR}/vapi_json_parser.py;
-    fi;
-    if [ ! -e ${CMAKE_CURRENT_BINARY_DIR}/vapi_c_gen.py ]; then
-        curl https://raw.githubusercontent.com/FDio/vpp/stable/2106/src/vpp-api/vapi/vapi_c_gen.py -o ${CMAKE_CURRENT_BINARY_DIR}/vapi_c_gen.py;
-    fi;
-    if [ ! -e ${CMAKE_CURRENT_BINARY_DIR}/vapi_cpp_gen.py ]; then
-        curl https://raw.githubusercontent.com/FDio/vpp/stable/2106/src/vpp-api/vapi/vapi_cpp_gen.py -o ${CMAKE_CURRENT_BINARY_DIR}/vapi_cpp_gen.py;
-    fi;
-    if [ ! -e ${CMAKE_CURRENT_BINARY_DIR}/vnet/ip/ip_types.api ]; then
-        curl https://raw.githubusercontent.com/FDio/vpp/stable/2106/src/vnet/ip/ip_types.api -o ${CMAKE_CURRENT_BINARY_DIR}/vnet/ip/ip_types.api;
-    fi;
-    if [ ! -e ${CMAKE_CURRENT_BINARY_DIR}/vnet/fib/fib_entry_track.h ]; then
-        curl https://raw.githubusercontent.com/FDio/vpp/stable/2106/src/vnet/fib/fib_entry_track.h -o ${CMAKE_CURRENT_BINARY_DIR}/vnet/fib/fib_entry_track.h;
-    fi;
-    if [ ! -e ${CMAKE_CURRENT_BINARY_DIR}/vnet/udp/udp_encap.h ]; then
-        curl https://raw.githubusercontent.com/FDio/vpp/stable/2106/src/vnet/udp/udp_encap.h -o ${CMAKE_CURRENT_BINARY_DIR}/vnet/udp/udp_encap.h;
-    fi;
-
-    chmod +x ${CMAKE_CURRENT_BINARY_DIR}/vapi_json_parser.py ${CMAKE_CURRENT_BINARY_DIR}/vapi_c_gen.py ${CMAKE_CURRENT_BINARY_DIR}/vapi_cpp_gen.py"
+##############################################################
+# RPath
+##############################################################
+SET(HICN_INSTALL_PREFIX
+  ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}
 )
 
-execute_process(
-    COMMAND ${VPP_HOME}/bin/vppapigen --includedir ${CMAKE_CURRENT_BINARY_DIR} --input ${CMAKE_CURRENT_SOURCE_DIR}/hicn.api --output ${CMAKE_CURRENT_BINARY_DIR}/vpp_plugins/hicn/hicn.api.h --outputdir ${CMAKE_CURRENT_BINARY_DIR}/vpp_plugins/hicn/
-    COMMAND ${VPP_HOME}/bin/vppapigen JSON --includedir ${CMAKE_CURRENT_BINARY_DIR} --input ${CMAKE_CURRENT_SOURCE_DIR}/hicn.api --output ${CMAKE_CURRENT_BINARY_DIR}/vapi/hicn.api.json --outputdir ${CMAKE_CURRENT_BINARY_DIR}/vapi/
-)
-execute_process(
-    COMMAND ${CMAKE_CURRENT_BINARY_DIR}/vapi_c_gen.py ${CMAKE_CURRENT_BINARY_DIR}/vapi/hicn.api.json
-    COMMAND ${CMAKE_CURRENT_BINARY_DIR}/vapi_cpp_gen.py ${CMAKE_CURRENT_BINARY_DIR}/vapi/hicn.api.json
-)
-
-include_directories(SYSTEM)
-include_directories(${CMAKE_CURRENT_BINARY_DIR})
-
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DHICN_VPP_PLUGIN=1")
-add_library(hicn_plugin SHARED
-    ${LIBHICN_FILES}
-    ${HICN_PLUGIN_SOURCE_FILES}
-    ${HICN_API_GENERATED_FILES}
-    ${HICN_VAPI_GENERATED_FILES})
 
-file(COPY ${HICN_API_HEADER_FILES} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/vpp_plugins/hicn)
-include_directories(${CMAKE_CURRENT_BINARY_DIR}/vpp_plugins)
-
-file(COPY ${LIBHICN_HEADER_FILES_SRC} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/hicn)
-file(COPY ${LIBHICN_HEADER_FILES_PROTOCOL} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/hicn/protocol)
-file(COPY ${LIBHICN_HEADER_FILES_UTIL} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/hicn/util)
-
-add_library(hicn_api_test_plugin SHARED
-	${HICN_API_TEST_SOURCE_FILES}
-        ${HICN_API_GENERATED_FILES})
+##############################################################
+# Compiler Options
+##############################################################
+set(COMPILER_OPTIONS
+  ${DEFAULT_COMPILER_OPTIONS}
+  ${MARCH_COMPILER_OPTIONS}
+  PRIVATE "-Wno-address-of-packed-member"
+)
 
-set(VPP_INSTALL_PLUGIN ${HICN_INSTALL_PREFIX}/vpp_plugins)
-set(VPP_INSTALL_API_TEST_PLUGIN ${HICN_INSTALL_PREFIX}/vpp_api_test_plugins CACHE STRING "vpp_install_api_test_plugin")
-set(VPP_STARTUP_CONF /etc/vpp/)
 
-set_target_properties(hicn_plugin
-        PROPERTIES
-        LINKER_LANGUAGE C
-        INSTALL_RPATH ${VPP_INSTALL_PLUGIN}
-        COMPILE_FLAGS "-march=native -Wno-address-of-packed-member"
-        PREFIX "")
-set_target_properties(hicn_api_test_plugin
-        PROPERTIES
-        LINKER_LANGUAGE C
-        COMPILE_FLAGS "-march=native -Wno-address-of-packed-member"
-        PREFIX "")
+##############################################################
+# Compiler Definitions
+##############################################################
+set(COMPILE_DEFINITIONS
+  "-DHICN_VPP_PLUGIN=1"
+)
 
 if (${CMAKE_BUILD_TYPE} MATCHES "Debug")
-    target_compile_definitions(hicn_plugin PRIVATE "CLIB_DEBUG")
-    target_compile_definitions(hicn_api_test_plugin PRIVATE "CLIB_DEBUG")
+  list(APPEND COMPILE_DEFINITIONS
+    "-DHICN_DDEBUG"
+    "-DCLIB_DEBUG"
+  )
 endif()
 
-message (STATUS "hicn-plugin variable ${HICN_PLUGIN}")
 
-install(DIRECTORY
-        DESTINATION ${VPP_INSTALL_PLUGIN}
-        COMPONENT ${HICN_PLUGIN})
-install(TARGETS hicn_plugin
-        DESTINATION
-        ${VPP_INSTALL_PLUGIN}
-        COMPONENT ${HICN_PLUGIN})
+##############################################################
+# VPP API Generation
+##############################################################
+file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/vapi)
+file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/vpp_plugins/hicn)
 
-install(DIRECTORY
-        DESTINATION ${VPP_INSTALL_API_TEST_PLUGIN}
-        COMPONENT ${HICN_PLUGIN})
-install(TARGETS hicn_api_test_plugin
-        DESTINATION ${VPP_INSTALL_API_TEST_PLUGIN}
-        COMPONENT ${HICN_PLUGIN})
+execute_process(
+  COMMAND ${VPP_HOME}/bin/vppapigen --includedir ${VPP_HOME}/include --input ${CMAKE_CURRENT_SOURCE_DIR}/hicn.api --output ${PROJECT_BINARY_DIR}/vpp_plugins/hicn/hicn.api.h --outputdir ${PROJECT_BINARY_DIR}/vpp_plugins/hicn/
+  COMMAND ${VPP_HOME}/bin/vppapigen JSON --includedir ${VPP_HOME}/include --input ${CMAKE_CURRENT_SOURCE_DIR}/hicn.api --output ${PROJECT_BINARY_DIR}/vapi/hicn.api.json --outputdir ${PROJECT_BINARY_DIR}/vapi/
+)
+execute_process(
+  COMMAND ${VPP_HOME}/bin/vapi_c_gen.py ${PROJECT_BINARY_DIR}/vapi/hicn.api.json
+  COMMAND ${VPP_HOME}/bin/vapi_cpp_gen.py ${PROJECT_BINARY_DIR}/vapi/hicn.api.json
+)
 
-install(FILES ${HICN_API_HEADER_FILES} ${HICN_API_GENERATED_FILES}
-        DESTINATION ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/vpp_plugins/hicn
-        COMPONENT ${HICN_PLUGIN}-dev)
 
-install(FILES ${HICN_API_GENERATED_FILES}
-        DESTINATION ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/vpp_plugins/hicn
-        COMPONENT ${HICN_PLUGIN}-dev)
+##############################################################
+# Include directories
+##############################################################
+set(HICN_PLUGIN_INCLUDE_DIRS_INTERNAL
+  PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${VPP_INCLUDE_DIR}
+  PUBLIC
+    $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>
+    $<BUILD_INTERFACE:${HICNPLUGIN_INCLUDE_DIRS}>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+
 
-install(FILES ${HICN_VAPI_GENERATED_FILES}
-        DESTINATION ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/vapi
-        COMPONENT ${HICN_PLUGIN}-dev)
+##############################################################
+# Build hicn plugins for VPP
+##############################################################
+build_module(${HICNPLUGIN}
+  SOURCES ${HICN_PLUGIN_SOURCE_FILES}
+  INSTALL_HEADERS ${HICN_API_HEADER_FILES} ${HICN_API_GENERATED_FILES}
+  LINK_LIBRARIES PRIVATE ${LIBHICN_LIBRARIES}
+  DEPENDS ${DEPENDENCIES}
+  COMPONENT ${HICN_PLUGIN}
+  INCLUDE_DIRS ${HICN_PLUGIN_INCLUDE_DIRS_INTERNAL}
+  HEADER_ROOT_DIR "vpp_plugins"
+  LIBRARY_ROOT_DIR "vpp_plugins"
+  DEFINITIONS PUBLIC ${COMPILE_DEFINITIONS}
+  COMPILE_OPTIONS ${COMPILER_OPTIONS}
+  INSTALL_RPATH "${VPP_INSTALL_PLUGIN}:${HICN_INSTALL_PREFIX}:${VPP_HOME}/lib"
+)
 
-#Set variables for other project depending on hicn-plugin
-set(HICNPLUGIN_INCLUDE_DIRS
-    ${CMAKE_CURRENT_BINARY_DIR}
-    ${CMAKE_CURRENT_BINARY_DIR}/vpp_plugins
-    ${VPP_INCLUDE_DIRS}
-    CACHE INTERNAL "" FORCE)
-set(HICNPLUGIN_LIBRARIES ${VPP_LIBRARIES} CACHE INTERNAL "" FORCE)
+build_module(${HICN_API_TEST_PLUGIN}
+  SOURCES ${HICN_API_TEST_SOURCE_FILES}
+  INSTALL_HEADERS ${HICN_VAPI_GENERATED_FILES}
+  COMPONENT ${HICN_PLUGIN}
+  INCLUDE_DIRS ${HICN_PLUGIN_INCLUDE_DIRS_INTERNAL}
+  HEADER_ROOT_DIR "vapi"
+  LIBRARY_ROOT_DIR "vpp_api_test_plugins"
+  DEFINITIONS PUBLIC ${COMPILE_DEFINITIONS}
+  COMPILE_OPTIONS ${COMPILER_OPTIONS}
+  INSTALL_RPATH "${VPP_INSTALL_PLUGIN}:${HICN_INSTALL_PREFIX}:${VPP_HOME}/lib"
+)
diff --git a/hicn-plugin/src/cache_policies/cs_lru.c b/hicn-plugin/src/cache_policies/cs_lru.c
index 408a6cb49..e65f487e1 100644
--- a/hicn-plugin/src/cache_policies/cs_lru.c
+++ b/hicn-plugin/src/cache_policies/cs_lru.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/cache_policies/cs_lru.h b/hicn-plugin/src/cache_policies/cs_lru.h
index c939b45df..35b82ff2c 100644
--- a/hicn-plugin/src/cache_policies/cs_lru.h
+++ b/hicn-plugin/src/cache_policies/cs_lru.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/cache_policies/cs_policy.h b/hicn-plugin/src/cache_policies/cs_policy.h
index 505138943..73f3de107 100644
--- a/hicn-plugin/src/cache_policies/cs_policy.h
+++ b/hicn-plugin/src/cache_policies/cs_policy.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/cli.c b/hicn-plugin/src/cli.c
index 8ecbf7a95..cd45607ca 100644
--- a/hicn-plugin/src/cli.c
+++ b/hicn-plugin/src/cli.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -22,6 +22,9 @@
 #include <vnet/ip/ip6_packet.h> // ip46_address_t
 #include <vnet/ip/format.h>
 #include <vnet/fib/fib_types.h>
+#include <vnet/pg/pg.h>
+
+#include <vpp_plugins/hicn/hicn_api.h>
 
 #include "hicn.h"
 #include "infra.h"
@@ -33,7 +36,6 @@
 #include "error.h"
 #include "faces/face.h"
 #include "route.h"
-#include "hicn_api.h"
 
 static vl_api_hicn_api_node_params_set_t node_ctl_params = {
   .pit_max_size = -1,
@@ -65,8 +67,8 @@ hicn_cli_node_ctl_start_set_command_fn (vlib_main_t *vm,
 		   get_error_string (ret));
 
   return (ret == HICN_ERROR_NONE) ?
-	   0 :
-	   clib_error_return (0, get_error_string (ret));
+		 0 :
+		 clib_error_return (0, get_error_string (ret));
 }
 
 /*
@@ -91,7 +93,7 @@ hicn_cli_node_ctl_stop_set_command_fn (vlib_main_t *vm,
 	{
 	  return (0);
 	}
-      while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+      if (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 	{
 	  return clib_error_return (0, "%s '%U'",
 				    get_error_string (HICN_ERROR_CLI_INVAL),
@@ -103,8 +105,8 @@ hicn_cli_node_ctl_stop_set_command_fn (vlib_main_t *vm,
     node_ctl_params.pit_max_lifetime_sec, node_ctl_params.cs_max_size, ~0);
 
   return (ret == HICN_ERROR_NONE) ?
-	   0 :
-	   clib_error_return (0, get_error_string (ret));
+		 0 :
+		 clib_error_return (0, get_error_string (ret));
 }
 
 #define DFLTD_RANGE_OK(val, min, max)                                         \
@@ -201,8 +203,8 @@ hicn_cli_node_ctl_param_set_command_fn (vlib_main_t *vm,
 			 "compilation time for better performances\n");
 
   return (rv == HICN_ERROR_NONE) ?
-	   0 :
-	   clib_error_return (0, "%s '%U'", get_error_string (rv),
+		 0 :
+		 clib_error_return (0, "%s '%U'", get_error_string (rv),
 			      format_unformat_error, line_input);
 }
 
@@ -213,7 +215,7 @@ static clib_error_t *
 hicn_cli_show_command_fn (vlib_main_t *vm, unformat_input_t *main_input,
 			  vlib_cli_command_t *cmd)
 {
-  int face_p = 0, fib_p = 0, all_p, internal_p = 0, strategies_p = 0,
+  int face_p = 0, fib_p = 0, all_p = 0, internal_p = 0, strategies_p = 0,
       ret = HICN_ERROR_NONE;
 
   /* Get a line of input. */
@@ -348,8 +350,8 @@ done:
 		       hicn_main.pitcs.pcs_table->ht_overflow_buckets_used);
     }
   return (ret == HICN_ERROR_NONE) ?
-	   0 :
-	   clib_error_return (0, "%s\n", get_error_string (ret));
+		 0 :
+		 clib_error_return (0, "%s\n", get_error_string (ret));
 }
 
 /*
@@ -408,8 +410,8 @@ hicn_cli_strategy_set_command_fn (vlib_main_t *vm,
 
   rv = hicn_route_set_strategy (&prefix, strategy_id);
   cl_err = (rv == HICN_ERROR_NONE) ?
-	     NULL :
-	     clib_error_return (0, get_error_string (rv));
+		   NULL :
+		   clib_error_return (0, get_error_string (rv));
 done:
 
   return (cl_err);
@@ -727,12 +729,25 @@ hicn_enable_command_fn (vlib_main_t *vm, unformat_input_t *main_input,
 	  goto done;
 	}
     }
-  rv = hicn_route_enable (&pfx);
+  hicn_face_id_t *vec_faces = NULL;
+  rv = hicn_route_enable (&pfx, &vec_faces);
+
+  if (vec_faces != NULL)
+    {
+      hicn_face_id_t *face_id;
+      u8 *str = 0;
+      vec_foreach (face_id, vec_faces)
+	{
+	  str = format (str, " %d", *face_id);
+	}
+      vec_free (vec_faces);
+      vlib_cli_output (vm, "Faces for this prefix: %s", str);
+    }
 done:
 
   cl_err = (rv == HICN_ERROR_NONE) ?
-	     NULL :
-	     clib_error_return (0, get_error_string (rv));
+		   NULL :
+		   clib_error_return (0, get_error_string (rv));
   return cl_err;
 }
 
@@ -776,8 +791,8 @@ hicn_disable_command_fn (vlib_main_t *vm, unformat_input_t *main_input,
 
 done:
   cl_err = (rv == HICN_ERROR_NONE) ?
-	     NULL :
-	     clib_error_return (0, get_error_string (rv));
+		   NULL :
+		   clib_error_return (0, get_error_string (rv));
   return cl_err;
 }
 
diff --git a/hicn-plugin/src/data_fwd.h b/hicn-plugin/src/data_fwd.h
index 96d8399e4..b21fa0a2f 100644
--- a/hicn-plugin/src/data_fwd.h
+++ b/hicn-plugin/src/data_fwd.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/data_fwd_node.c b/hicn-plugin/src/data_fwd_node.c
index fe79b33fa..6acb5915b 100644
--- a/hicn-plugin/src/data_fwd_node.c
+++ b/hicn-plugin/src/data_fwd_node.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -428,9 +428,9 @@ hicn_satisfy_faces (vlib_main_t *vm, u32 bi0, hicn_pcs_entry_t *pitp,
 	  clones += 2;
 
 	  next0 = isv6 ? HICN_DATA_FWD_NEXT_IFACE6_OUT :
-			 HICN_DATA_FWD_NEXT_IFACE4_OUT;
+			       HICN_DATA_FWD_NEXT_IFACE4_OUT;
 	  next1 = isv6 ? HICN_DATA_FWD_NEXT_IFACE6_OUT :
-			 HICN_DATA_FWD_NEXT_IFACE4_OUT;
+			       HICN_DATA_FWD_NEXT_IFACE4_OUT;
 
 	  vnet_buffer (h0)->ip.adj_index[VLIB_TX] = face0;
 	  vnet_buffer (h1)->ip.adj_index[VLIB_TX] = face1;
@@ -481,7 +481,7 @@ hicn_satisfy_faces (vlib_main_t *vm, u32 bi0, hicn_pcs_entry_t *pitp,
 	  clones += 1;
 
 	  next0 = isv6 ? HICN_DATA_FWD_NEXT_IFACE6_OUT :
-			 HICN_DATA_FWD_NEXT_IFACE4_OUT;
+			       HICN_DATA_FWD_NEXT_IFACE4_OUT;
 	  vnet_buffer (h0)->ip.adj_index[VLIB_TX] = face0;
 
 	  stats->pkts_data_count++;
@@ -548,10 +548,7 @@ clone_data_to_cs (vlib_main_t *vm, hicn_pit_cs_t *pitcs,
    * the PIT part of the union as we update the CS part, so don't
    * expect the PIT part to be valid after this point.
    */
-  hicn_buffer_t *hicnb0 = hicn_get_buffer (b0);
-  hicn_pit_to_cs (vm, pitcs, pitp, hash_entry, nodep, dpo_vft, hicn_dpo_id,
-		  hicnb->face_id,
-		  hicnb0->flags & HICN_BUFFER_FLAGS_FACE_IS_APP);
+  hicn_pit_to_cs (vm, pitcs, pitp, hash_entry, nodep, dpo_vft, hicn_dpo_id);
 
   pitp->shared.create_time = tnow;
 
diff --git a/hicn-plugin/src/data_input_node.c b/hicn-plugin/src/data_input_node.c
index c94443a6b..46fda1080 100644
--- a/hicn-plugin/src/data_input_node.c
+++ b/hicn-plugin/src/data_input_node.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -75,6 +75,23 @@ format_hicn_data_input_trace (u8 *s, va_list *args)
   return s;
 }
 
+static void
+hicn_data_input_set_adj_index (vlib_buffer_t *b,
+			       const ip46_address_t *dst_addr,
+			       const hicn_dpo_ctx_t *dpo_ctx)
+{
+  for (u8 pos = 0; pos < dpo_ctx->entry_count; pos++)
+    {
+      hicn_face_t *face = hicn_dpoi_get_from_idx (dpo_ctx->next_hops[pos]);
+      assert (face);
+      if (ip46_address_cmp (&(face->nat_addr), dst_addr) == 0)
+	{
+	  vnet_buffer (b)->ip.adj_index[VLIB_RX] = face->dpo.dpoi_index;
+	  break;
+	}
+    }
+}
+
 static uword
 hicn_data_input_ip6_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 			vlib_frame_t *frame)
@@ -100,6 +117,7 @@ hicn_data_input_ip6_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  ip_lookup_next_t next0, next1;
 	  ip6_header_t *ip0, *ip1;
 	  ip6_address_t *src_addr0, *src_addr1;
+	  ip46_address_t dst_addr0, dst_addr1;
 	  const dpo_id_t *dpo0, *dpo1;
 	  const load_balance_t *lb0, *lb1;
 
@@ -128,6 +146,9 @@ hicn_data_input_ip6_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  src_addr0 = &ip0->src_address;
 	  src_addr1 = &ip1->src_address;
 
+	  ip46_address_set_ip6 (&dst_addr0, &ip0->dst_address);
+	  ip46_address_set_ip6 (&dst_addr0, &ip1->dst_address);
+
 	  ip_lookup_set_buffer_fib_index (im->fib_index_by_sw_if_index, p0);
 	  ip_lookup_set_buffer_fib_index (im->fib_index_by_sw_if_index, p1);
 
@@ -150,14 +171,22 @@ hicn_data_input_ip6_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  dpo1 = load_balance_get_bucket_i (lb1, 0);
 
 	  if (dpo_is_hicn (dpo0))
-	    next0 = HICN_DATA_INPUT_IP6_NEXT_FACE;
+	    {
+	      next0 = (ip_lookup_next_t) HICN_DATA_INPUT_IP6_NEXT_FACE;
+	      hicn_data_input_set_adj_index (
+		p0, &dst_addr0, hicn_strategy_dpo_ctx_get (dpo0->dpoi_index));
+	    }
 	  else
-	    next0 = HICN_DATA_INPUT_IP6_NEXT_IP6_LOCAL;
+	    next0 = (ip_lookup_next_t) HICN_DATA_INPUT_IP6_NEXT_IP6_LOCAL;
 
 	  if (dpo_is_hicn (dpo1))
-	    next1 = HICN_DATA_INPUT_IP6_NEXT_FACE;
+	    {
+	      next1 = (ip_lookup_next_t) HICN_DATA_INPUT_IP6_NEXT_FACE;
+	      hicn_data_input_set_adj_index (
+		p1, &dst_addr1, hicn_strategy_dpo_ctx_get (dpo1->dpoi_index));
+	    }
 	  else
-	    next1 = HICN_DATA_INPUT_IP6_NEXT_IP6_LOCAL;
+	    next1 = (ip_lookup_next_t) HICN_DATA_INPUT_IP6_NEXT_IP6_LOCAL;
 
 	  if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
 	      (p0->flags & VLIB_BUFFER_IS_TRACED))
@@ -235,6 +264,7 @@ hicn_data_input_ip6_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  ip_lookup_next_t next0;
 	  load_balance_t *lb0;
 	  ip6_address_t *src_addr0;
+	  ip46_address_t dst_addr0;
 	  const dpo_id_t *dpo0;
 
 	  pi0 = from[0];
@@ -243,6 +273,7 @@ hicn_data_input_ip6_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  p0 = vlib_get_buffer (vm, pi0);
 	  ip0 = vlib_buffer_get_current (p0);
 	  src_addr0 = &ip0->src_address;
+	  ip46_address_set_ip6 (&dst_addr0, &ip0->dst_address);
 	  ip_lookup_set_buffer_fib_index (im->fib_index_by_sw_if_index, p0);
 	  lbi0 = ip6_fib_table_fwding_lookup (vnet_buffer (p0)->ip.fib_index,
 					      src_addr0);
@@ -255,9 +286,13 @@ hicn_data_input_ip6_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  dpo0 = load_balance_get_bucket_i (lb0, 0);
 
 	  if (dpo_is_hicn (dpo0))
-	    next0 = HICN_DATA_INPUT_IP6_NEXT_FACE;
+	    {
+	      next0 = (ip_lookup_next_t) HICN_DATA_INPUT_IP6_NEXT_FACE;
+	      hicn_data_input_set_adj_index (
+		p0, &dst_addr0, hicn_strategy_dpo_ctx_get (dpo0->dpoi_index));
+	    }
 	  else
-	    next0 = HICN_DATA_INPUT_IP6_NEXT_IP6_LOCAL;
+	    next0 = (ip_lookup_next_t) HICN_DATA_INPUT_IP6_NEXT_IP6_LOCAL;
 
 	  if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
 	      (p0->flags & VLIB_BUFFER_IS_TRACED))
@@ -312,7 +347,7 @@ VLIB_REGISTER_NODE (hicn_data_input_ip6) = {
 VNET_FEATURE_INIT (hicn_data_input_ip6_arc, static) = {
   .arc_name = "ip6-local",
   .node_name = "hicn-data-input-ip6",
-  .runs_before = VNET_FEATURES ("ip6-local-end-of-arc"),
+  .runs_before = VNET_FEATURES ("ip6-local-end-of-arc")
 };
 
 always_inline uword
@@ -337,9 +372,8 @@ hicn_data_input_ip4_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
     {
       ip4_header_t *ip0, *ip1, *ip2, *ip3;
       const load_balance_t *lb0, *lb1, *lb2, *lb3;
-      ip4_fib_mtrie_t *mtrie0, *mtrie1, *mtrie2, *mtrie3;
-      ip4_fib_mtrie_leaf_t leaf0, leaf1, leaf2, leaf3;
       ip4_address_t *src_addr0, *src_addr1, *src_addr2, *src_addr3;
+      ip46_address_t dst_addr0, dst_addr1, dst_addr2, dst_addr3;
       u32 lb_index0, lb_index1, lb_index2, lb_index3;
       const dpo_id_t *dpo0, *dpo1, *dpo2, *dpo3;
 
@@ -367,35 +401,21 @@ hicn_data_input_ip4_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
       src_addr2 = &ip2->src_address;
       src_addr3 = &ip3->src_address;
 
+      ip46_address_set_ip4 (&dst_addr0, &ip0->dst_address);
+      ip46_address_set_ip4 (&dst_addr1, &ip1->dst_address);
+      ip46_address_set_ip4 (&dst_addr2, &ip2->dst_address);
+      ip46_address_set_ip4 (&dst_addr3, &ip3->dst_address);
+
       ip_lookup_set_buffer_fib_index (im->fib_index_by_sw_if_index, b[0]);
       ip_lookup_set_buffer_fib_index (im->fib_index_by_sw_if_index, b[1]);
       ip_lookup_set_buffer_fib_index (im->fib_index_by_sw_if_index, b[2]);
       ip_lookup_set_buffer_fib_index (im->fib_index_by_sw_if_index, b[3]);
 
-      mtrie0 = &ip4_fib_get (vnet_buffer (b[0])->ip.fib_index)->mtrie;
-      mtrie1 = &ip4_fib_get (vnet_buffer (b[1])->ip.fib_index)->mtrie;
-      mtrie2 = &ip4_fib_get (vnet_buffer (b[2])->ip.fib_index)->mtrie;
-      mtrie3 = &ip4_fib_get (vnet_buffer (b[3])->ip.fib_index)->mtrie;
-
-      leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, src_addr0);
-      leaf1 = ip4_fib_mtrie_lookup_step_one (mtrie1, src_addr1);
-      leaf2 = ip4_fib_mtrie_lookup_step_one (mtrie2, src_addr2);
-      leaf3 = ip4_fib_mtrie_lookup_step_one (mtrie3, src_addr3);
-
-      leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, src_addr0, 2);
-      leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, src_addr1, 2);
-      leaf2 = ip4_fib_mtrie_lookup_step (mtrie2, leaf2, src_addr2, 2);
-      leaf3 = ip4_fib_mtrie_lookup_step (mtrie3, leaf3, src_addr3, 2);
-
-      leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, src_addr0, 3);
-      leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, src_addr1, 3);
-      leaf2 = ip4_fib_mtrie_lookup_step (mtrie2, leaf2, src_addr2, 3);
-      leaf3 = ip4_fib_mtrie_lookup_step (mtrie3, leaf3, src_addr3, 3);
-
-      lb_index0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
-      lb_index1 = ip4_fib_mtrie_leaf_get_adj_index (leaf1);
-      lb_index2 = ip4_fib_mtrie_leaf_get_adj_index (leaf2);
-      lb_index3 = ip4_fib_mtrie_leaf_get_adj_index (leaf3);
+      ip4_fib_forwarding_lookup_x4 (
+	vnet_buffer (b[0])->ip.fib_index, vnet_buffer (b[1])->ip.fib_index,
+	vnet_buffer (b[2])->ip.fib_index, vnet_buffer (b[3])->ip.fib_index,
+	src_addr0, src_addr1, src_addr2, src_addr3, &lb_index0, &lb_index1,
+	&lb_index2, &lb_index3);
 
       ASSERT (lb_index0 && lb_index1 && lb_index2 && lb_index3);
       lb0 = load_balance_get (lb_index0);
@@ -418,22 +438,38 @@ hicn_data_input_ip4_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
       dpo3 = load_balance_get_bucket_i (lb3, 0);
 
       if (dpo_is_hicn (dpo0))
-	next[0] = HICN_DATA_INPUT_IP4_NEXT_FACE;
+	{
+	  next[0] = (ip_lookup_next_t) HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
+	  hicn_data_input_set_adj_index (
+	    b[0], &dst_addr0, hicn_strategy_dpo_ctx_get (dpo0->dpoi_index));
+	}
       else
 	next[0] = HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
 
       if (dpo_is_hicn (dpo1))
-	next[1] = HICN_DATA_INPUT_IP4_NEXT_FACE;
+	{
+	  next[1] = (ip_lookup_next_t) HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
+	  hicn_data_input_set_adj_index (
+	    b[1], &dst_addr1, hicn_strategy_dpo_ctx_get (dpo1->dpoi_index));
+	}
       else
 	next[1] = HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
 
       if (dpo_is_hicn (dpo2))
-	next[2] = HICN_DATA_INPUT_IP4_NEXT_FACE;
+	{
+	  next[2] = (ip_lookup_next_t) HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
+	  hicn_data_input_set_adj_index (
+	    b[2], &dst_addr2, hicn_strategy_dpo_ctx_get (dpo2->dpoi_index));
+	}
       else
 	next[2] = HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
 
       if (dpo_is_hicn (dpo3))
-	next[3] = HICN_DATA_INPUT_IP4_NEXT_FACE;
+	{
+	  next[3] = (ip_lookup_next_t) HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
+	  hicn_data_input_set_adj_index (
+	    b[3], &dst_addr3, hicn_strategy_dpo_ctx_get (dpo3->dpoi_index));
+	}
       else
 	next[3] = HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
 
@@ -495,9 +531,8 @@ hicn_data_input_ip4_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
     {
       ip4_header_t *ip0, *ip1;
       const load_balance_t *lb0, *lb1;
-      ip4_fib_mtrie_t *mtrie0, *mtrie1;
-      ip4_fib_mtrie_leaf_t leaf0, leaf1;
       ip4_address_t *src_addr0, *src_addr1;
+      ip46_address_t dst_addr0, dst_addr1;
       u32 lb_index0, lb_index1;
       flow_hash_config_t flow_hash_config0, flow_hash_config1;
       u32 hash_c0, hash_c1;
@@ -518,23 +553,15 @@ hicn_data_input_ip4_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
       src_addr0 = &ip0->src_address;
       src_addr1 = &ip1->src_address;
 
+      ip46_address_set_ip4 (&dst_addr0, &ip0->dst_address);
+      ip46_address_set_ip4 (&dst_addr1, &ip1->dst_address);
+
       ip_lookup_set_buffer_fib_index (im->fib_index_by_sw_if_index, b[0]);
       ip_lookup_set_buffer_fib_index (im->fib_index_by_sw_if_index, b[1]);
 
-      mtrie0 = &ip4_fib_get (vnet_buffer (b[0])->ip.fib_index)->mtrie;
-      mtrie1 = &ip4_fib_get (vnet_buffer (b[1])->ip.fib_index)->mtrie;
-
-      leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, src_addr0);
-      leaf1 = ip4_fib_mtrie_lookup_step_one (mtrie1, src_addr1);
-
-      leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, src_addr0, 2);
-      leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, src_addr1, 2);
-
-      leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, src_addr0, 3);
-      leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, src_addr1, 3);
-
-      lb_index0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
-      lb_index1 = ip4_fib_mtrie_leaf_get_adj_index (leaf1);
+      ip4_fib_forwarding_lookup_x2 (
+	vnet_buffer (b[0])->ip.fib_index, vnet_buffer (b[1])->ip.fib_index,
+	src_addr0, src_addr1, &lb_index0, &lb_index1);
 
       ASSERT (lb_index0 && lb_index1);
       lb0 = load_balance_get (lb_index0);
@@ -549,12 +576,20 @@ hicn_data_input_ip4_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
       dpo1 = load_balance_get_bucket_i (lb1, 0);
 
       if (dpo_is_hicn (dpo0))
-	next[0] = HICN_DATA_INPUT_IP4_NEXT_FACE;
+	{
+	  next[0] = (ip_lookup_next_t) HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
+	  hicn_data_input_set_adj_index (
+	    b[0], &dst_addr0, hicn_strategy_dpo_ctx_get (dpo0->dpoi_index));
+	}
       else
 	next[0] = HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
 
       if (dpo_is_hicn (dpo1))
-	next[1] = HICN_DATA_INPUT_IP4_NEXT_FACE;
+	{
+	  next[1] = (ip_lookup_next_t) HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
+	  hicn_data_input_set_adj_index (
+	    b[1], &dst_addr1, hicn_strategy_dpo_ctx_get (dpo1->dpoi_index));
+	}
       else
 	next[1] = HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
 
@@ -592,21 +627,18 @@ hicn_data_input_ip4_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
     {
       ip4_header_t *ip0;
       const load_balance_t *lb0;
-      ip4_fib_mtrie_t *mtrie0;
-      ip4_fib_mtrie_leaf_t leaf0;
       ip4_address_t *src_addr0;
+      ip46_address_t dst_addr0;
       u32 lbi0;
       const dpo_id_t *dpo0;
 
       ip0 = vlib_buffer_get_current (b[0]);
       src_addr0 = &ip0->src_address;
+      ip46_address_set_ip4 (&dst_addr0, &ip0->dst_address);
       ip_lookup_set_buffer_fib_index (im->fib_index_by_sw_if_index, b[0]);
 
-      mtrie0 = &ip4_fib_get (vnet_buffer (b[0])->ip.fib_index)->mtrie;
-      leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, src_addr0);
-      leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, src_addr0, 2);
-      leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, src_addr0, 3);
-      lbi0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
+      lbi0 = ip4_fib_forwarding_lookup (vnet_buffer (b[0])->ip.fib_index,
+					src_addr0);
 
       ASSERT (lbi0);
       lb0 = load_balance_get (lbi0);
@@ -617,7 +649,11 @@ hicn_data_input_ip4_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
       dpo0 = load_balance_get_bucket_i (lb0, 0);
 
       if (dpo_is_hicn (dpo0))
-	next[0] = HICN_DATA_INPUT_IP4_NEXT_FACE;
+	{
+	  next[0] = (ip_lookup_next_t) HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
+	  hicn_data_input_set_adj_index (
+	    b[0], &dst_addr0, hicn_strategy_dpo_ctx_get (dpo0->dpoi_index));
+	}
       else
 	next[0] = HICN_DATA_INPUT_IP4_NEXT_IP4_LOCAL;
 
diff --git a/hicn-plugin/src/data_pcslookup.h b/hicn-plugin/src/data_pcslookup.h
index b548497b6..32fca952a 100644
--- a/hicn-plugin/src/data_pcslookup.h
+++ b/hicn-plugin/src/data_pcslookup.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/data_pcslookup_node.c b/hicn-plugin/src/data_pcslookup_node.c
index 073d06c96..69278c306 100644
--- a/hicn-plugin/src/data_pcslookup_node.c
+++ b/hicn-plugin/src/data_pcslookup_node.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -74,7 +74,7 @@ hicn_data_pcslookup_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  u32 node_id0 = 0;
 	  index_t dpo_ctx_id0 = 0;
 	  int ret0;
-	  u8 vft_id0;
+	  u8 vft_id0 = 0;
 	  u8 is_cs0;
 	  u8 hash_entry_id = 0;
 	  u8 bucket_is_overflown = 0;
diff --git a/hicn-plugin/src/error.c b/hicn-plugin/src/error.c
index 4c6986999..a64066d67 100644
--- a/hicn-plugin/src/error.c
+++ b/hicn-plugin/src/error.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-#include "error.h"
+#include <vpp_plugins/hicn/error.h>
 
 const char *HICN_ERROR_STRING[] = {
 #define _(a, b, c) c,
diff --git a/hicn-plugin/src/face_db.h b/hicn-plugin/src/face_db.h
index 1bc061721..37a2af9ca 100644
--- a/hicn-plugin/src/face_db.h
+++ b/hicn-plugin/src/face_db.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -78,8 +78,8 @@ hicn_face_db_get_dpo_face (u32 index, hicn_face_db_t *face_db)
   ASSERT (index < face_db->n_faces);
 
   return index < HICN_FACE_DB_INLINE_FACES ?
-	   (face_db->inline_faces[index]) :
-	   (pool_elt_at_index (hicn_face_bucket_pool, face_db->next_bucket)
+		 (face_db->inline_faces[index]) :
+		 (pool_elt_at_index (hicn_face_bucket_pool, face_db->next_bucket)
 	      ->faces[(index - HICN_FACE_DB_INLINE_FACES) &
 		      (HICN_PIT_N_HOP_BUCKET - 1)]);
 }
@@ -106,8 +106,8 @@ hicn_face_db_add_face (hicn_face_id_t face_id, hicn_face_db_t *face_db)
 
   hicn_face_id_t *element =
     face_db->n_faces < HICN_FACE_DB_INLINE_FACES ?
-      &(face_db->inline_faces[face_db->n_faces]) :
-      &(faces_bkt->faces[(face_db->n_faces - HICN_FACE_DB_INLINE_FACES) &
+	    &(face_db->inline_faces[face_db->n_faces]) :
+	    &(faces_bkt->faces[(face_db->n_faces - HICN_FACE_DB_INLINE_FACES) &
 			 (HICN_PIT_N_HOP_BUCKET - 1)]);
 
   *element = face_id;
diff --git a/hicn-plugin/src/faces/app/address_mgr.c b/hicn-plugin/src/faces/app/address_mgr.c
index b5d8ce7cb..44729fd69 100644
--- a/hicn-plugin/src/faces/app/address_mgr.c
+++ b/hicn-plugin/src/faces/app/address_mgr.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,7 +14,7 @@
  */
 
 /*
- * Copyright (c) 2017-2019 by cisco systems inc. All rights reserved.
+ * Copyright (c) 2021 by cisco systems inc. All rights reserved.
  *
  */
 
@@ -31,10 +31,11 @@
 #include <vnet/interface.h>	  //appif_flags
 #include <vnet/interface_funcs.h> //vnet_sw_interface_set_flags
 
+#include <vpp_plugins/hicn/error.h>
+
 #include "address_mgr.h"
 #include "../../hicn.h"
 #include "../../infra.h"
-#include "../../error.h"
 #include "../face.h"
 #include "../../strategy_dpo_ctx.h"
 #include "../../route.h"
diff --git a/hicn-plugin/src/faces/app/address_mgr.h b/hicn-plugin/src/faces/app/address_mgr.h
index bd834f063..32545f8ca 100644
--- a/hicn-plugin/src/faces/app/address_mgr.h
+++ b/hicn-plugin/src/faces/app/address_mgr.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/faces/app/face_app_cli.c b/hicn-plugin/src/faces/app/face_app_cli.c
index ccdee4450..b3488c462 100644
--- a/hicn-plugin/src/faces/app/face_app_cli.c
+++ b/hicn-plugin/src/faces/app/face_app_cli.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -114,8 +114,8 @@ hicn_face_app_cli_set_command_fn (vlib_main_t *vm,
 	if (prod)
 	  {
 	    prefix.fp_proto = ip46_address_is_ip4 (&prefix.fp_addr) ?
-				FIB_PROTOCOL_IP4 :
-				FIB_PROTOCOL_IP6;
+				      FIB_PROTOCOL_IP4 :
+				      FIB_PROTOCOL_IP6;
 	    rv = hicn_face_prod_add (&prefix, sw_if, &cs_reserved, &prod_addr,
 				     &face_id1);
 	    if (rv == HICN_ERROR_NONE)
@@ -175,8 +175,8 @@ hicn_face_app_cli_set_command_fn (vlib_main_t *vm,
       break;
     }
   return (rv == HICN_ERROR_NONE) ?
-	   0 :
-	   clib_error_return (0, "%s\n", get_error_string (rv));
+		 0 :
+		 clib_error_return (0, "%s\n", get_error_string (rv));
 }
 
 /* cli declaration for 'cfg face' */
diff --git a/hicn-plugin/src/faces/app/face_cons.c b/hicn-plugin/src/faces/app/face_cons.c
index 53b955775..edb03387d 100644
--- a/hicn-plugin/src/faces/app/face_cons.c
+++ b/hicn-plugin/src/faces/app/face_cons.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -69,10 +69,10 @@ hicn_face_cons_add (ip4_address_t *nh_addr4, ip6_address_t *nh_addr6, u32 swif,
 				 0 /* is_del */);
 
   ip46_address_t nh_addr = to_ip46 (0, (u8 *) nh_addr6);
-  index_t adj_index = adj_nbr_find (FIB_PROTOCOL_IP6, VNET_LINK_IP6, &nh_addr, swif);
+  index_t adj_index =
+    adj_nbr_find (FIB_PROTOCOL_IP6, VNET_LINK_IP6, &nh_addr, swif);
 
-  hicn_iface_add ((ip46_address_t *) nh_addr6, swif, faceid2, DPO_PROTO_IP6,
-		  adj_index);
+  hicn_iface_add ((ip46_address_t *) nh_addr6, swif, faceid2, adj_index, 0);
 
   hicn_face_t *face = hicn_dpoi_get_from_idx (*faceid2);
   face->flags |= HICN_FACE_FLAGS_APPFACE_CONS;
@@ -90,7 +90,7 @@ hicn_face_cons_del (hicn_face_id_t face_id)
 
   if (face->flags & HICN_FACE_FLAGS_APPFACE_CONS)
     {
-      return hicn_face_del (face_id);
+      return hicn_face_unlock_with_id (face_id);
     }
   else
     {
diff --git a/hicn-plugin/src/faces/app/face_cons.h b/hicn-plugin/src/faces/app/face_cons.h
index 3ff246f4f..9df6f773f 100644
--- a/hicn-plugin/src/faces/app/face_cons.h
+++ b/hicn-plugin/src/faces/app/face_cons.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/faces/app/face_prod.c b/hicn-plugin/src/faces/app/face_prod.c
index 16b6e6158..1e569b82b 100644
--- a/hicn-plugin/src/faces/app/face_prod.c
+++ b/hicn-plugin/src/faces/app/face_prod.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -30,7 +30,7 @@ hicn_face_prod_state_t *face_state_vec;
 u32 *face_state_pool;
 
 static int
-hicn_app_state_create (u32 swif, fib_prefix_t *prefix)
+hicn_app_state_create (u32 swif, index_t adj_index, fib_prefix_t *prefix)
 {
   /* Make sure that the pool is not empty */
   pool_validate_index (face_state_pool, 0);
@@ -49,6 +49,7 @@ hicn_app_state_create (u32 swif, fib_prefix_t *prefix)
 
   /* Create the appif and store in the vector */
   vec_validate (face_state_vec, swif);
+  face_state_vec[swif].adj_index = adj_index;
   clib_memcpy (&(face_state_vec[swif].prefix), prefix, sizeof (fib_prefix_t));
 
   /* Set as busy the element in the vector */
@@ -119,7 +120,7 @@ hicn_face_prod_add (fib_prefix_t *prefix, u32 sw_if, u32 *cs_reserved,
 
   hicn_main_t *hm = &hicn_main;
 
-  ip46_address_t local_app_ip;
+  ip46_address_t local_app_ip = { .as_u64 = { 0, 0 } };
   CLIB_UNUSED (ip46_address_t remote_app_ip);
   u32 if_flags = 0;
 
@@ -139,10 +140,11 @@ hicn_face_prod_add (fib_prefix_t *prefix, u32 sw_if, u32 *cs_reserved,
   if_flags |= VNET_SW_INTERFACE_FLAG_ADMIN_UP;
   vnet_sw_interface_set_flags (vnm, sw_if, if_flags);
 
+#ifdef HICN_DDEBUG
   u8 *s0;
   s0 = format (0, "Prefix %U", format_fib_prefix, prefix);
-
-  vlib_cli_output (vm, "Received request for %s, swif %d\n", s0, sw_if);
+  HICN_DEBUG ("Received request for %s, swif %d\n", s0, sw_if);
+#endif
 
   if (ip46_address_is_zero (&prefix->fp_addr))
     {
@@ -268,15 +270,21 @@ hicn_face_prod_add (fib_prefix_t *prefix, u32 sw_if, u32 *cs_reserved,
       fib_table_entry_path_add2 (fib_index, prefix, FIB_SOURCE_CLI,
 				 FIB_ENTRY_FLAG_NONE, rpaths);
 
-      hicn_route_enable (prefix);
-      hicn_app_state_create (sw_if, prefix);
+      HICN_DEBUG ("Calling hicn enable for producer face");
+
+      hicn_face_id_t *vec_faces = NULL;
+      hicn_route_enable (prefix, &vec_faces);
+      if (vec_faces != NULL)
+	vec_free (vec_faces);
+
+      adj_index =
+	adj_nbr_find (isv6 ? FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4,
+		      isv6 ? VNET_LINK_IP6 : VNET_LINK_IP4, prod_addr, sw_if);
+
+      hicn_app_state_create (sw_if, adj_index, prefix);
     }
 
-  adj_index =
-    adj_nbr_find (isv6 ? FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4,
-		  isv6 ? VNET_LINK_IP6 : VNET_LINK_IP4, prod_addr, sw_if);
-  face = hicn_face_get (&local_app_ip, sw_if, &hicn_face_hashtb,
-			adj_index); // HICN_FACE_FLAGS_APPFACE_PROD);
+  face = hicn_face_get (&local_app_ip, sw_if, &hicn_face_hashtb, adj_index);
 
   *faceid = hicn_dpoi_get_index (face);
 
@@ -289,6 +297,7 @@ hicn_face_prod_add (fib_prefix_t *prefix, u32 sw_if, u32 *cs_reserved,
   /* Cleanup in case of something went wrong. */
   if (ret)
     {
+      HICN_ERROR ("Somethig went wrong while adding producer face. Cleanup.");
       hicn_app_state_del (sw_if);
     }
   return ret;
@@ -304,17 +313,32 @@ hicn_face_prod_del (hicn_face_id_t face_id)
 
   if (face->flags & HICN_FACE_FLAGS_APPFACE_PROD)
     {
-      /* Remove the face from the fib */
-      hicn_route_disable (&(face_state_vec[face->sw_if].prefix));
-      // hicn_route_del_nhop (&(face_state_vec[face->sw_if].prefix),
-      //                           face_id);
-
-      // int ret = hicn_face_del (face_id);
-      return hicn_app_state_del (face->sw_if);
-      // ret == HICN_ERROR_NONE ? hicn_app_state_del (face->sw_if) : ret;
+      /* Remove the face from the hicn fib */
+      fib_prefix_t *prefix = &(face_state_vec[face->sw_if].prefix);
+      HICN_DEBUG ("Calling hicn_route_disable from hicn_face_prod_del");
+      int ret = hicn_route_disable (prefix);
+      if (ret)
+	{
+	  vlib_main_t *vm = vlib_get_main ();
+	  vlib_cli_output (vm, "Error disabling route: %s",
+			   get_error_string (ret));
+	}
+      /* Also remove it from main fib, as we sre the owners of this prefix */
+      u32 fib_index = fib_table_find (prefix->fp_proto, 0);
+      fib_table_entry_special_remove (fib_index, prefix, FIB_SOURCE_CLI);
+      ret = hicn_app_state_del (face->sw_if);
+      if (ret)
+	{
+	  vlib_main_t *vm = vlib_get_main ();
+	  vlib_cli_output (vm, "Error deelting app state: %s",
+			   get_error_string (ret));
+	}
     }
   else
     {
+      vlib_main_t *vm = vlib_get_main ();
+      vlib_cli_output (vm, "APPFACE not found.",
+		       get_error_string (HICN_ERROR_APPFACE_NOT_FOUND));
       return HICN_ERROR_APPFACE_NOT_FOUND;
     }
 
diff --git a/hicn-plugin/src/faces/app/face_prod.h b/hicn-plugin/src/faces/app/face_prod.h
index 4acf89dfc..51373d541 100644
--- a/hicn-plugin/src/faces/app/face_prod.h
+++ b/hicn-plugin/src/faces/app/face_prod.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -50,6 +50,7 @@
 typedef struct
 {
   fib_prefix_t prefix;
+  index_t adj_index;
 } hicn_face_prod_state_t;
 
 extern hicn_face_prod_state_t *face_state_vec;
diff --git a/hicn-plugin/src/faces/app/face_prod_node.c b/hicn-plugin/src/faces/app/face_prod_node.c
index c4c9edc32..5d2b54040 100644
--- a/hicn-plugin/src/faces/app/face_prod_node.c
+++ b/hicn-plugin/src/faces/app/face_prod_node.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -24,7 +24,6 @@
  */
 
 #include "face_prod.h"
-#include "../../hicn_api.h"
 #include "../../mgmt.h"
 
 static __clib_unused char *face_prod_input_error_strings[] = {
@@ -114,7 +113,7 @@ hicn_face_prod_next_from_data_hdr (vlib_node_runtime_t *node, vlib_buffer_t *b,
     }
 
   return match_res ? HICN_FACE_PROD_NEXT_DATA_IP4 + (v == 0x60) :
-		     HICN_FACE_PROD_NEXT_ERROR_DROP;
+			   HICN_FACE_PROD_NEXT_ERROR_DROP;
 }
 
 static_always_inline void
@@ -151,6 +150,7 @@ hicn_face_prod_input_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
       while (n_left_from >= 8 && n_left_to_next >= 4)
 	{
 	  vlib_buffer_t *b0, *b1, *b2, *b3;
+	  hicn_buffer_t *hicnb0, *hicnb1, *hicnb2, *hicnb3;
 	  u32 bi0, bi1, bi2, bi3;
 	  hicn_face_prod_state_t *prod_face0 = NULL;
 	  hicn_face_prod_state_t *prod_face1 = NULL;
@@ -190,11 +190,30 @@ hicn_face_prod_input_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  b2 = vlib_get_buffer (vm, bi2);
 	  b3 = vlib_get_buffer (vm, bi3);
 
+	  hicnb0 = hicn_get_buffer (b0);
+	  hicnb1 = hicn_get_buffer (b1);
+	  hicnb2 = hicn_get_buffer (b2);
+	  hicnb3 = hicn_get_buffer (b3);
+
+	  hicnb0->flags = HICN_FACE_FLAGS_DEFAULT;
+	  hicnb1->flags = HICN_FACE_FLAGS_DEFAULT;
+	  hicnb2->flags = HICN_FACE_FLAGS_DEFAULT;
+	  hicnb3->flags = HICN_FACE_FLAGS_DEFAULT;
+
 	  prod_face0 = &face_state_vec[vnet_buffer (b0)->sw_if_index[VLIB_RX]];
 	  prod_face1 = &face_state_vec[vnet_buffer (b1)->sw_if_index[VLIB_RX]];
 	  prod_face2 = &face_state_vec[vnet_buffer (b2)->sw_if_index[VLIB_RX]];
 	  prod_face3 = &face_state_vec[vnet_buffer (b3)->sw_if_index[VLIB_RX]];
 
+	  vnet_buffer (b0)->ip.adj_index[VLIB_RX] =
+	    face_state_vec[vnet_buffer (b0)->sw_if_index[VLIB_RX]].adj_index;
+	  vnet_buffer (b1)->ip.adj_index[VLIB_RX] =
+	    face_state_vec[vnet_buffer (b1)->sw_if_index[VLIB_RX]].adj_index;
+	  vnet_buffer (b2)->ip.adj_index[VLIB_RX] =
+	    face_state_vec[vnet_buffer (b2)->sw_if_index[VLIB_RX]].adj_index;
+	  vnet_buffer (b3)->ip.adj_index[VLIB_RX] =
+	    face_state_vec[vnet_buffer (b3)->sw_if_index[VLIB_RX]].adj_index;
+
 	  next0 =
 	    hicn_face_prod_next_from_data_hdr (node, b0, &prod_face0->prefix);
 	  next1 =
@@ -226,6 +245,7 @@ hicn_face_prod_input_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
       while (n_left_from > 0 && n_left_to_next > 0)
 	{
 	  vlib_buffer_t *b0;
+	  hicn_buffer_t *hicnb0;
 	  u32 bi0, swif;
 	  hicn_face_prod_state_t *prod_face = NULL;
 	  u32 next0;
@@ -245,11 +265,15 @@ hicn_face_prod_input_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  n_left_to_next -= 1;
 
 	  b0 = vlib_get_buffer (vm, bi0);
+	  hicnb0 = hicn_get_buffer (b0);
+	  hicnb0->flags = HICN_FACE_FLAGS_DEFAULT;
 	  swif = vnet_buffer (b0)->sw_if_index[VLIB_RX];
 	  prod_face = &face_state_vec[swif];
 
 	  next0 =
 	    hicn_face_prod_next_from_data_hdr (node, b0, &prod_face->prefix);
+	  vnet_buffer (b0)->ip.adj_index[VLIB_RX] =
+	    face_state_vec[swif].adj_index;
 	  stats.pkts_data_count++;
 
 	  /* trace */
diff --git a/hicn-plugin/src/faces/face.c b/hicn-plugin/src/faces/face.c
index d62054365..854fd81d3 100644
--- a/hicn-plugin/src/faces/face.c
+++ b/hicn-plugin/src/faces/face.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -57,11 +57,8 @@ face_show (u8 *s, int face_id, u32 indent)
   return (s);
 }
 
-mhash_t hicn_face_vec_hashtb;
 mhash_t hicn_face_hashtb;
 
-hicn_face_vec_t *hicn_vec_pool;
-
 const static char *const hicn_face6_nodes[] = {
   "hicn6-face-output",	// this is the name you give your node in
 			// VLIB_REGISTER_NODE
@@ -163,14 +160,9 @@ hicn_face_module_init (vlib_main_t *vm)
   counters = vec_new (vlib_combined_counter_main_t,
 		      HICN_PARAM_FACES_MAX * HICN_N_COUNTER);
 
-  mhash_init (&hicn_face_vec_hashtb,
-	      sizeof (hicn_face_input_faces_t) /* value */,
-	      sizeof (hicn_face_key_t) /* key */);
   mhash_init (&hicn_face_hashtb, sizeof (hicn_face_id_t) /* value */,
 	      sizeof (hicn_face_key_t) /* key */);
 
-  pool_alloc (hicn_vec_pool, 100);
-
   /*
    * How much useful is the following registration?
    * So far it seems that we need it only for setting the dpo_type.
@@ -182,7 +174,7 @@ hicn_face_module_init (vlib_main_t *vm)
    * corresponding to a face is updated
    */
   hicn_face_fib_node_type =
-    fib_node_register_new_type (&hicn_face_fib_node_vft);
+    fib_node_register_new_type ("hicn_face_fib_node", &hicn_face_fib_node_vft);
 }
 
 u8 *
@@ -256,46 +248,11 @@ format_hicn_face_all (u8 *s, int n, ...)
 int
 hicn_face_del (hicn_face_id_t face_id)
 {
-  hicn_face_t *face = hicn_dpoi_get_from_idx (face_id);
-  hicn_face_key_t key;
-  hicn_face_key_t old_key;
-  hicn_face_key_t old_key2;
-
-  hicn_face_get_key (&(face->nat_addr), face->sw_if, &(face->dpo), &key);
-  hicn_face_input_faces_t *in_faces_vec =
-    hicn_face_get_vec (&(face->nat_addr), &hicn_face_vec_hashtb);
-  if (in_faces_vec != NULL)
-    {
-      hicn_face_vec_t *vec =
-	pool_elt_at_index (hicn_vec_pool, in_faces_vec->vec_id);
-      u32 index_face = vec_search (*vec, face_id);
-      vec_del1 (*vec, index_face);
-
-      if (vec_len (*vec) == 0)
-	{
-	  pool_put_index (hicn_vec_pool, in_faces_vec->vec_id);
-	  mhash_unset (&hicn_face_vec_hashtb, &key, (uword *) &old_key);
-	  vec_free (*vec);
-	}
-      else
-	{
-	  /* Check if the face we are deleting is the preferred one. */
-	  /* If so, repleace with another. */
-	  if (in_faces_vec->face_id == face_id)
-	    {
-	      in_faces_vec->face_id = (*vec)[0];
-	    }
-	}
-
-      mhash_unset (&hicn_face_hashtb, &key, (uword *) &old_key2);
-    }
-
   int ret = HICN_ERROR_NONE;
 
   if (hicn_dpoi_idx_is_valid (face_id))
     {
       hicn_face_t *face = hicn_dpoi_get_from_idx (face_id);
-      face->locks--;
       if (face->locks == 0)
 	pool_put_index (hicn_dpoi_face_pool, face_id);
       else
@@ -320,7 +277,7 @@ hicn_iface_to_face (hicn_face_t *face, const dpo_id_t *dpo)
       fib_node_init (&face->fib_node, hicn_face_fib_node_type);
       fib_node_lock (&face->fib_node);
 
-      if (dpo->dpoi_type != DPO_ADJACENCY_MIDCHAIN ||
+      if (dpo->dpoi_type != DPO_ADJACENCY_MIDCHAIN &&
 	  dpo->dpoi_type != DPO_ADJACENCY_MCAST_MIDCHAIN)
 	{
 	  ip_adjacency_t *adj = adj_get (dpo->dpoi_index);
@@ -375,8 +332,7 @@ hicn_face_add (const dpo_id_t *dpo_nh, ip46_address_t *nat_address, int sw_if,
   if (face == NULL)
     {
 
-      hicn_iface_add (nat_address, sw_if, pfaceid, dpo_nh->dpoi_proto,
-		      dpo_nh->dpoi_index);
+      hicn_iface_add (nat_address, sw_if, pfaceid, dpo_nh->dpoi_index, 0);
       face = hicn_dpoi_get_from_idx (*pfaceid);
 
       mhash_set_mem (&hicn_face_hashtb, &key, (uword *) pfaceid, 0);
@@ -395,52 +351,6 @@ hicn_face_add (const dpo_id_t *dpo_nh, ip46_address_t *nat_address, int sw_if,
 
   temp_dpo.dpoi_index = ~0;
 
-  hicn_face_input_faces_t *in_faces =
-    hicn_face_get_vec (nat_address, &hicn_face_vec_hashtb);
-
-  if (in_faces == NULL)
-    {
-      hicn_face_input_faces_t in_faces_temp;
-      hicn_face_vec_t *vec;
-      pool_get (hicn_vec_pool, vec);
-      *vec = vec_new (hicn_face_id_t, 0);
-      u32 index = vec - hicn_vec_pool;
-      in_faces_temp.vec_id = index;
-      vec_add1 (*vec, *pfaceid);
-
-      in_faces_temp.face_id = *pfaceid;
-
-      hicn_face_get_key (nat_address, 0, &temp_dpo, &key);
-
-      mhash_set_mem (&hicn_face_vec_hashtb, &key, (uword *) &in_faces_temp, 0);
-    }
-  else
-    {
-      hicn_face_vec_t *vec =
-	pool_elt_at_index (hicn_vec_pool, in_faces->vec_id);
-
-      /* */
-      if (vec_search (*vec, *pfaceid) != ~0)
-	return HICN_ERROR_FACE_ALREADY_CREATED;
-
-      vec_add1 (*vec, *pfaceid);
-
-      hicn_iface_to_face (face, dpo_nh);
-
-      hicn_face_get_key (nat_address, 0, &temp_dpo, &key);
-
-      mhash_set_mem (&hicn_face_vec_hashtb, &key, (uword *) in_faces, 0);
-
-      /* If the face is an application producer face, we set it as the
-       * preferred incoming face. */
-      /* This is required to handle the CS separation, and the push api in a
-       * lightway */
-      if (is_app_prod)
-	{
-	  in_faces->face_id = *pfaceid;
-	}
-    }
-
   retx_t *retx = vlib_process_signal_event_data (
     vlib_get_main (), hicn_mapme_eventmgr_process_node.index,
     HICN_MAPME_EVENT_FACE_ADD, 1, sizeof (retx_t));
diff --git a/hicn-plugin/src/faces/face.h b/hicn-plugin/src/faces/face.h
index cb706eeca..39505c942 100644
--- a/hicn-plugin/src/faces/face.h
+++ b/hicn-plugin/src/faces/face.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,7 +25,11 @@
 #include <vppinfra/bihash_8_8.h>
 #include <vnet/adj/adj_midchain.h>
 
-#include "../error.h"
+#include <vpp_plugins/hicn/error.h>
+
+#include "../udp_tunnels/udp_tunnel.h"
+#include "../hicn_logging.h"
+
 typedef u8 hicn_face_flags_t;
 typedef index_t hicn_face_id_t;
 
@@ -66,12 +70,8 @@ typedef index_t hicn_face_id_t;
  * - fib_node, fib_entry_index and fib_sibling are information used to be
  * notified of changes in the adjacency pointed by the dpo.
  *
- * We maintain two hash tables to retrieve faces and ifaces. In particular one
- * hash table which index faces and ifaces for nat_address, sw_if and dpo. This
- * is used to retrieve existing faces or ifaces when an interest is received
- * and when an new face is created. A second hash table that indexes vectors of
- * faces for nat_address and sw_if. This is used to retrieve a list of possible
- * incoming faces when a data is received.
+ * We maintain one hash tables to retrieve faces and ifaces, which indexes
+ * faces and ifaces for nat_address, sw_if and dpo.
  */
 
 /**
@@ -129,14 +129,17 @@ extern hicn_face_t *hicn_dpoi_face_pool;
 #define HICN_FACE_FLAGS_APPFACE_CONS                                          \
   0x08 /* Currently only IP face can be appface */
 #define HICN_FACE_FLAGS_DELETED 0x10
+#define HICN_FACE_FLAGS_UDP	0x20
 
 #define HICN_FACE_NULL (hicn_face_id_t) ~0
 
 #define HICN_FACE_FLAGS_APPFACE_PROD_BIT 2
 #define HICN_FACE_FLAGS_APPFACE_CONS_BIT 3
 
-#define HICN_BUFFER_FLAGS_DEFAULT     0x00
-#define HICN_BUFFER_FLAGS_FACE_IS_APP 0x01
+#define HICN_BUFFER_FLAGS_DEFAULT	   0x00
+#define HICN_BUFFER_FLAGS_NEW_FACE	   0x02
+#define HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL 0x04
+#define HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL 0x08
 
 STATIC_ASSERT ((1 << HICN_FACE_FLAGS_APPFACE_PROD_BIT) ==
 		 HICN_FACE_FLAGS_APPFACE_PROD,
@@ -148,16 +151,6 @@ STATIC_ASSERT ((1 << HICN_FACE_FLAGS_APPFACE_CONS_BIT) ==
 	       "HICN_FACE_FLAGS_APPFACE_CONS_BIT and  "
 	       "HICN_FACE_FLAGS_APPFACE_CONS must correspond");
 
-STATIC_ASSERT (
-  (HICN_FACE_FLAGS_APPFACE_PROD >> HICN_FACE_FLAGS_APPFACE_PROD_BIT) ==
-    HICN_BUFFER_FLAGS_FACE_IS_APP,
-  "hicn buffer app flag does not correspond to HICN_FACE_FLAGS_APPFACE_PROD");
-
-STATIC_ASSERT (
-  (HICN_FACE_FLAGS_APPFACE_CONS >> HICN_FACE_FLAGS_APPFACE_CONS_BIT) ==
-    HICN_BUFFER_FLAGS_FACE_IS_APP,
-  "hicn buffer app flag does not correspond to HICN_FACE_FLAGS_APPFACE_PROD");
-
 /**
  * @brief Definition of the virtual functin table for an hICN FACE DPO.
  */
@@ -257,6 +250,15 @@ hicn_dpoi_idx_is_valid (hicn_face_id_t face_id)
 }
 
 /**
+ * @brief Delete a face
+ *
+ * @param face_id Id of the face to delete
+ * @return HICN_ERROR_FACE_NOT_FOUND if the face does not exist, otherwise
+ * HICN_ERROR_NONE
+ */
+int hicn_face_del (hicn_face_id_t face_id);
+
+/**
  * @brief Add a lock to the face dpo
  *
  * @param dpo Pointer to the face dpo
@@ -274,12 +276,24 @@ hicn_face_lock_with_id (hicn_face_id_t face_id)
  *
  * @param dpo Pointer to the face dpo
  */
-always_inline void
+always_inline int
 hicn_face_unlock_with_id (hicn_face_id_t face_id)
 {
   hicn_face_t *face;
   face = hicn_dpoi_get_from_idx (face_id);
-  face->locks--;
+
+  if (face->locks > 0)
+    {
+      face->locks--;
+
+      if (face->locks == 0)
+	{
+	  HICN_DEBUG ("Deleting face %d", face_id);
+	  return hicn_face_del (face_id);
+	}
+    }
+
+  return HICN_ERROR_NONE;
 }
 
 /**
@@ -324,15 +338,6 @@ u8 *format_hicn_face (u8 *s, va_list *args);
 u8 *format_hicn_face_all (u8 *s, int n, ...);
 
 /**
- * @brief Delete a face
- *
- * @param face_id Id of the face to delete
- * @return HICN_ERROR_FACE_NOT_FOUND if the face does not exist, otherwise
- * HICN_ERROR_NONE
- */
-int hicn_face_del (hicn_face_id_t face_id);
-
-/**
  * @bried vector of faces used to collect faces having the same local address
  *
  */
@@ -355,17 +360,6 @@ typedef struct hicn_input_faces_s_
 } hicn_face_input_faces_t;
 
 /**
- * Pool containing the vector of possible incoming faces.
- */
-extern hicn_face_vec_t *hicn_vec_pool;
-
-/**
- * Hash tables that indexes a face by remote address. For fast lookup when an
- * interest arrives.
- */
-extern mhash_t hicn_face_vec_hashtb;
-
-/**
  * Key definition for the mhash table. An face is uniquely identified by ip
  * address, the interface id and a dpo pointing to the next node in the vlib
  * graph. The ip address can correspond to the remote ip address of the next
@@ -437,7 +431,7 @@ hicn_face_get (const ip46_address_t *addr, u32 sw_if, mhash_t *hashtb,
 
   hicn_face_id_t *dpoi_index = (hicn_face_id_t *) mhash_get (hashtb, &key);
 
-  if (dpoi_index != NULL)
+  if (dpoi_index != NULL && hicn_dpoi_idx_is_valid (*dpoi_index))
     {
       hicn_face_lock_with_id (*dpoi_index);
       return hicn_dpoi_get_from_idx (*dpoi_index);
@@ -467,7 +461,7 @@ hicn_face_get_with_dpo (const ip46_address_t *addr, u32 sw_if,
 
   hicn_face_id_t *dpoi_index = (hicn_face_id_t *) mhash_get (hashtb, &key);
 
-  if (dpoi_index != NULL)
+  if (dpoi_index != NULL && hicn_dpoi_idx_is_valid (*dpoi_index))
     {
       hicn_face_lock_with_id (*dpoi_index);
       return hicn_dpoi_get_from_idx (*dpoi_index);
@@ -477,28 +471,6 @@ hicn_face_get_with_dpo (const ip46_address_t *addr, u32 sw_if,
 }
 
 /**
- * @brief Get the vector of faces from the ip v4 address. Does not add any
- * lock.
- *
- * @param addr Ip v4 address used to create the key for the hash table.
- * @param sw_if Software interface id used to create the key for the hash
- * table.
- * @param hashtb Hash table (remote or local) where to perform the lookup.
- *
- * @result Pointer to the face.
- */
-always_inline hicn_face_input_faces_t *
-hicn_face_get_vec (const ip46_address_t *addr, mhash_t *hashtb)
-{
-  hicn_face_key_t key;
-
-  dpo_id_t dpo = DPO_INVALID;
-
-  hicn_face_get_key (addr, 0, &dpo, &key);
-  return (hicn_face_input_faces_t *) mhash_get (hashtb, &key);
-}
-
-/**
  * @brief Create a new face ip. API for other modules (e.g., routing)
  *
  * @param dpo_nh dpo contained in the face that points to the next node in
@@ -526,7 +498,7 @@ int hicn_face_add (const dpo_id_t *dpo_nh, ip46_address_t *nat_address,
  */
 always_inline void
 hicn_iface_add (ip46_address_t *nat_address, int sw_if,
-		hicn_face_id_t *pfaceid, dpo_proto_t proto, u32 adj_index)
+		hicn_face_id_t *pfaceid, u32 adj_index, u8 flags)
 {
   hicn_face_t *face;
   pool_get (hicn_dpoi_face_pool, face);
@@ -534,16 +506,19 @@ hicn_iface_add (ip46_address_t *nat_address, int sw_if,
   clib_memcpy (&(face->nat_addr), nat_address, sizeof (ip46_address_t));
   face->sw_if = sw_if;
 
-  face->dpo.dpoi_type = DPO_FIRST;
-  face->dpo.dpoi_proto = DPO_PROTO_NONE;
+  face->dpo = (dpo_id_t) DPO_INVALID;
   face->dpo.dpoi_index = adj_index;
-  face->dpo.dpoi_next_node = 0;
+
+  hicn_face_key_t key;
+  hicn_face_get_key (nat_address, sw_if, &face->dpo, &key);
+
+  face->dpo.dpoi_next_node = 1;
+
   face->pl_id = pl_index++;
   face->flags = HICN_FACE_FLAGS_IFACE;
+  face->flags |= flags;
   face->locks = 1;
 
-  hicn_face_key_t key;
-  hicn_face_get_key (nat_address, sw_if, &face->dpo, &key);
   *pfaceid = hicn_dpoi_get_index (face);
 
   mhash_set_mem (&hicn_face_hashtb, &key, (uword *) pfaceid, 0);
@@ -560,79 +535,6 @@ hicn_iface_add (ip46_address_t *nat_address, int sw_if,
  * ****/
 
 /**
- * @brief Retrieve a vector of faces from the ip4 local address and returns its
- * index.
- *
- * @param vec: Result of the lookup. If no face exists for the local address
- * vec = NULL
- * @param hicnb_flags: Flags that indicate whether the face is an application
- * face or not
- * @param local_addr: Ip v4 nat address of the face
- * @param sw_if: software interface id of the face
- *
- * @result HICN_ERROR_FACE_NOT_FOUND if the face does not exist, otherwise
- * HICN_ERROR_NONE.
- */
-always_inline int
-hicn_face_ip4_lock (hicn_face_id_t *face_id, u32 *in_faces_vec_id,
-		    u8 *hicnb_flags, const ip4_address_t *nat_addr)
-{
-  ip46_address_t ip_address = { 0 };
-  ip46_address_set_ip4 (&ip_address, nat_addr);
-  hicn_face_input_faces_t *in_faces_vec =
-    hicn_face_get_vec (&ip_address, &hicn_face_vec_hashtb);
-
-  if (PREDICT_FALSE (in_faces_vec == NULL))
-    return HICN_ERROR_FACE_NOT_FOUND;
-
-  *in_faces_vec_id = in_faces_vec->vec_id;
-  hicn_face_t *face = hicn_dpoi_get_from_idx (in_faces_vec->face_id);
-
-  *hicnb_flags = HICN_BUFFER_FLAGS_DEFAULT;
-  *hicnb_flags |= (face->flags & HICN_FACE_FLAGS_APPFACE_PROD) >>
-		  HICN_FACE_FLAGS_APPFACE_PROD_BIT;
-
-  *face_id = in_faces_vec->face_id;
-
-  return HICN_ERROR_NONE;
-}
-
-/**
- * @brief Retrieve a face from the ip6 local address and returns its dpo. This
- * method adds a lock on the face state.
- *
- * @param dpo: Result of the lookup. If the face doesn't exist dpo = NULL
- * @param hicnb_flags: Flags that indicate whether the face is an application
- * face or not
- * @param nat_addr: Ip v6 nat address of the face
- * @param sw_if: software interface id of the face
- *
- * @result HICN_ERROR_FACE_NOT_FOUND if the face does not exist, otherwise
- * HICN_ERROR_NONE.
- */
-always_inline int
-hicn_face_ip6_lock (hicn_face_id_t *face_id, u32 *in_faces_vec_id,
-		    u8 *hicnb_flags, const ip6_address_t *nat_addr)
-{
-  hicn_face_input_faces_t *in_faces_vec =
-    hicn_face_get_vec ((ip46_address_t *) nat_addr, &hicn_face_vec_hashtb);
-
-  if (PREDICT_FALSE (in_faces_vec == NULL))
-    return HICN_ERROR_FACE_NOT_FOUND;
-
-  *in_faces_vec_id = in_faces_vec->vec_id;
-  hicn_face_t *face = hicn_dpoi_get_from_idx (in_faces_vec->face_id);
-
-  *hicnb_flags = HICN_BUFFER_FLAGS_DEFAULT;
-  *hicnb_flags |= (face->flags & HICN_FACE_FLAGS_APPFACE_PROD) >>
-		  HICN_FACE_FLAGS_APPFACE_PROD_BIT;
-
-  *face_id = in_faces_vec->face_id;
-
-  return HICN_ERROR_NONE;
-}
-
-/**
  * @brief Call back to get the adj of the tunnel
  */
 static adj_walk_rc_t
@@ -658,11 +560,12 @@ hicn4_iface_adj_walk_cb (adj_index_t ai, void *ctx)
  * @param sw_if: software interface id of the face
  * @param node_index: vlib edge index to use in the packet processing
  */
-always_inline void
-hicn_iface_ip4_add_and_lock (hicn_face_id_t *index, u8 *hicnb_flags,
-			     const ip4_address_t *nat_addr, u32 sw_if,
-			     u32 adj_index, u32 node_index)
+always_inline int
+hicn_face_ip4_add_and_lock (hicn_face_id_t *index, u8 *hicnb_flags,
+			    const ip4_address_t *nat_addr, u32 sw_if,
+			    u32 adj_index, u32 node_index)
 {
+  int ret = HICN_ERROR_NONE;
   /*All (complete) faces are indexed by remote addess as well */
 
   ip46_address_t ip_address = { 0 };
@@ -675,12 +578,30 @@ hicn_iface_ip4_add_and_lock (hicn_face_id_t *index, u8 *hicnb_flags,
   if (face == NULL)
     {
       hicn_face_id_t idx;
-      hicn_iface_add (&ip_address, sw_if, &idx, DPO_PROTO_IP4, adj_index);
+      u8 face_flags = 0;
+
+      hicn_iface_add (&ip_address, sw_if, &idx, adj_index, face_flags);
 
       face = hicn_dpoi_get_from_idx (idx);
 
-      face->dpo.dpoi_type = DPO_FIRST;
-      face->dpo.dpoi_proto = DPO_PROTO_IP4;
+      if (*hicnb_flags & HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL &&
+	  adj_index != ADJ_INDEX_INVALID)
+	{
+	  face->dpo.dpoi_type = dpo_type_udp_ip6;
+	  face->dpo.dpoi_proto = DPO_PROTO_IP6;
+	}
+      else if (*hicnb_flags & HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL &&
+	       adj_index != ADJ_INDEX_INVALID)
+	{
+	  face->dpo.dpoi_type = dpo_type_udp_ip4;
+	  face->dpo.dpoi_proto = DPO_PROTO_IP4;
+	}
+      else
+	{
+	  face->dpo.dpoi_type = DPO_FIRST;
+	  face->dpo.dpoi_proto = DPO_PROTO_IP6;
+	}
+
       face->dpo.dpoi_index = adj_index;
       face->dpo.dpoi_next_node = node_index;
 
@@ -691,15 +612,17 @@ hicn_iface_ip4_add_and_lock (hicn_face_id_t *index, u8 *hicnb_flags,
       /* } */
 
       *hicnb_flags = HICN_BUFFER_FLAGS_DEFAULT;
+      *hicnb_flags |= HICN_BUFFER_FLAGS_NEW_FACE;
 
       *index = idx;
-      return;
+      return ret;
     }
   else
     {
       /* unlock the face. We don't take a lock on each interest we receive */
       hicn_face_id_t face_id = hicn_dpoi_get_index (face);
       hicn_face_unlock_with_id (face_id);
+      ret = HICN_ERROR_FACE_ALREADY_CREATED;
     }
 
   /* Code replicated on purpose */
@@ -708,6 +631,8 @@ hicn_iface_ip4_add_and_lock (hicn_face_id_t *index, u8 *hicnb_flags,
 		  HICN_FACE_FLAGS_APPFACE_PROD_BIT;
 
   *index = hicn_dpoi_get_index (face);
+
+  return ret;
 }
 
 /**
@@ -723,7 +648,8 @@ hicn6_iface_adj_walk_cb (adj_index_t ai, void *ctx)
   if ((adj->lookup_next_index == IP_LOOKUP_NEXT_MIDCHAIN) ||
       (adj->lookup_next_index == IP_LOOKUP_NEXT_MCAST_MIDCHAIN))
     {
-      dpo_set (&face->dpo, DPO_ADJACENCY_MIDCHAIN, adj->ia_nh_proto, ai);
+      dpo_set (&face->dpo, DPO_ADJACENCY_MIDCHAIN,
+	       (dpo_proto_t) adj->ia_nh_proto, ai);
       adj_nbr_midchain_stack (ai, &face->dpo);
     }
 
@@ -741,11 +667,13 @@ hicn6_iface_adj_walk_cb (adj_index_t ai, void *ctx)
  * @param sw_if: software interface id of the face
  * @param node_index: vlib edge index to use in the packet processing
  */
-always_inline void
-hicn_iface_ip6_add_and_lock (hicn_face_id_t *index, u8 *hicnb_flags,
-			     const ip6_address_t *nat_addr, u32 sw_if,
-			     u32 adj_index, u32 node_index)
+always_inline int
+hicn_face_ip6_add_and_lock (hicn_face_id_t *index, u8 *hicnb_flags,
+			    const ip6_address_t *nat_addr, u32 sw_if,
+			    u32 adj_index, u32 node_index)
 {
+  int ret = HICN_ERROR_NONE;
+
   /*All (complete) faces are indexed by remote addess as well */
   /* if the face exists, it adds a lock */
   hicn_face_t *face = hicn_face_get ((ip46_address_t *) nat_addr, sw_if,
@@ -754,13 +682,30 @@ hicn_iface_ip6_add_and_lock (hicn_face_id_t *index, u8 *hicnb_flags,
   if (face == NULL)
     {
       hicn_face_id_t idx;
-      hicn_iface_add ((ip46_address_t *) nat_addr, sw_if, &idx, DPO_PROTO_IP6,
-		      adj_index);
+      u8 face_flags = 0;
+
+      hicn_iface_add ((ip46_address_t *) nat_addr, sw_if, &idx, adj_index,
+		      face_flags);
 
       face = hicn_dpoi_get_from_idx (idx);
 
-      face->dpo.dpoi_type = DPO_FIRST;
-      face->dpo.dpoi_proto = DPO_PROTO_IP6;
+      if (*hicnb_flags & HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL &&
+	  adj_index != ADJ_INDEX_INVALID)
+	{
+	  face->dpo.dpoi_type = dpo_type_udp_ip6;
+	  face->dpo.dpoi_proto = DPO_PROTO_IP6;
+	}
+      else if (*hicnb_flags & HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL &&
+	       adj_index != ADJ_INDEX_INVALID)
+	{
+	  face->dpo.dpoi_type = dpo_type_udp_ip4;
+	  face->dpo.dpoi_proto = DPO_PROTO_IP4;
+	}
+      else
+	{
+	  face->dpo.dpoi_type = DPO_FIRST;
+	  face->dpo.dpoi_proto = DPO_PROTO_IP6;
+	}
       face->dpo.dpoi_index = adj_index;
       face->dpo.dpoi_next_node = node_index;
 
@@ -768,16 +713,18 @@ hicn_iface_ip6_add_and_lock (hicn_face_id_t *index, u8 *hicnb_flags,
 		    face);
 
       *hicnb_flags = HICN_BUFFER_FLAGS_DEFAULT;
+      *hicnb_flags |= HICN_BUFFER_FLAGS_NEW_FACE;
 
       *index = idx;
 
-      return;
+      return ret;
     }
   else
     {
       /* unlock the face. We don't take a lock on each interest we receive */
       hicn_face_id_t face_id = hicn_dpoi_get_index (face);
       hicn_face_unlock_with_id (face_id);
+      ret = HICN_ERROR_FACE_ALREADY_CREATED;
     }
 
   /* Code replicated on purpose */
@@ -786,6 +733,8 @@ hicn_iface_ip6_add_and_lock (hicn_face_id_t *index, u8 *hicnb_flags,
 		  HICN_FACE_FLAGS_APPFACE_PROD_BIT;
 
   *index = hicn_dpoi_get_index (face);
+
+  return ret;
 }
 
 #endif // __HICN_FACE_H__
diff --git a/hicn-plugin/src/faces/face_cli.c b/hicn-plugin/src/faces/face_cli.c
index a4092e6f4..20acefc5b 100644
--- a/hicn-plugin/src/faces/face_cli.c
+++ b/hicn-plugin/src/faces/face_cli.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/faces/face_node.c b/hicn-plugin/src/faces/face_node.c
index 5fe682bd0..dc9bfffd0 100644
--- a/hicn-plugin/src/faces/face_node.c
+++ b/hicn-plugin/src/faces/face_node.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -95,9 +95,6 @@ typedef enum
 #define IP_HEADER_4 ip4_header_t
 #define IP_HEADER_6 ip6_header_t
 
-#define LOCK_DPO_FACE_IP4 hicn_face_ip4_lock
-#define LOCK_DPO_FACE_IP6 hicn_face_ip6_lock
-
 #define TRACE_INPUT_PKT_IP4 hicn4_face_input_trace_t
 #define TRACE_INPUT_PKT_IP6 hicn6_face_input_trace_t
 
@@ -111,11 +108,12 @@ typedef enum
   do                                                                          \
     {                                                                         \
       vlib_buffer_t *b0;                                                      \
-      u32 bi0;                                                                \
+      u32 bi0, sw_if0;                                                        \
       u32 next0 = NEXT_ERROR_DROP_IP##ipv;                                    \
       IP_HEADER_##ipv *ip_hdr = NULL;                                         \
       hicn_buffer_t *hicnb0;                                                  \
-      int ret;                                                                \
+      int from_tunnel0;                                                       \
+      int ret0;                                                               \
       /* Prefetch for next iteration. */                                      \
       if (n_left_from > 1)                                                    \
 	{                                                                     \
@@ -138,23 +136,26 @@ typedef enum
                                                                               \
       u8 is_icmp = ip_hdr->protocol == IPPROTO_ICMPV##ipv;                    \
                                                                               \
+      from_tunnel0 =                                                          \
+	(hicnb0->flags & HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL ||                \
+	 hicnb0->flags & HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL) > 0;             \
+      sw_if0 = (from_tunnel0) * ~0 +                                          \
+	       (1 - from_tunnel0) * vnet_buffer (b0)->sw_if_index[VLIB_RX];   \
+                                                                              \
+      ret0 = hicn_face_ip##ipv##_add_and_lock (                               \
+	&hicnb0->face_id, &hicnb0->flags, &ip_hdr->dst_address, sw_if0,       \
+	vnet_buffer (b0)->ip.adj_index[VLIB_RX],                              \
+	/* Should not be used */ ~0);                                         \
+      /* Make sure the face is not created here */                            \
+      ASSERT (ret0 == HICN_ERROR_FACE_ALREADY_CREATED);                       \
+                                                                              \
       next0 =                                                                 \
 	is_icmp * NEXT_MAPME_IP##ipv + (1 - is_icmp) * NEXT_DATA_IP##ipv;     \
                                                                               \
-      ret = LOCK_DPO_FACE_IP##ipv (&(hicnb0->face_id),                        \
-				   &(hicnb0->in_faces_vec_id),                \
-				   &hicnb0->flags, &(ip_hdr->dst_address));   \
-                                                                              \
-      if (PREDICT_FALSE (ret != HICN_ERROR_NONE))                             \
-	next0 = NEXT_ERROR_DROP_IP##ipv;                                      \
-      else                                                                    \
-	{                                                                     \
-	  vlib_increment_combined_counter (                                   \
-	    &counters[hicnb0->face_id * HICN_N_COUNTER], thread_index,        \
-	    HICN_FACE_COUNTERS_DATA_RX, 1,                                    \
-	    vlib_buffer_length_in_chain (vm, b0));                            \
-	  stats.pkts_data_count += 1;                                         \
-	}                                                                     \
+      vlib_increment_combined_counter (                                       \
+	&counters[hicnb0->face_id * HICN_N_COUNTER], thread_index,            \
+	HICN_FACE_COUNTERS_DATA_RX, 1, vlib_buffer_length_in_chain (vm, b0)); \
+      stats.pkts_data_count += 1;                                             \
                                                                               \
       if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&              \
 			 (b0->flags & VLIB_BUFFER_IS_TRACED)))                \
@@ -178,13 +179,14 @@ typedef enum
   do                                                                          \
     {                                                                         \
       vlib_buffer_t *b0, *b1;                                                 \
-      u32 bi0, bi1;                                                           \
+      u32 bi0, bi1, sw_if0, sw_if1;                                           \
       u32 next0 = NEXT_ERROR_DROP_IP##ipv;                                    \
       u32 next1 = NEXT_ERROR_DROP_IP##ipv;                                    \
       IP_HEADER_##ipv *ip_hdr0 = NULL;                                        \
       IP_HEADER_##ipv *ip_hdr1 = NULL;                                        \
       hicn_buffer_t *hicnb0;                                                  \
       hicn_buffer_t *hicnb1;                                                  \
+      int from_tunnel0, from_tunnel1;                                         \
       int ret0, ret1;                                                         \
       /* Prefetch for next iteration. */                                      \
       {                                                                       \
@@ -216,41 +218,47 @@ typedef enum
       u8 is_icmp0 = ip_hdr0->protocol == IPPROTO_ICMPV##ipv;                  \
       u8 is_icmp1 = ip_hdr1->protocol == IPPROTO_ICMPV##ipv;                  \
                                                                               \
+      from_tunnel0 =                                                          \
+	(hicnb0->flags & HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL ||                \
+	 hicnb0->flags & HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL) > 0;             \
+      sw_if0 = (from_tunnel0) * ~0 +                                          \
+	       (1 - from_tunnel0) * vnet_buffer (b0)->sw_if_index[VLIB_RX];   \
+                                                                              \
+      ret0 = hicn_face_ip##ipv##_add_and_lock (                               \
+	&hicnb0->face_id, &hicnb0->flags, &ip_hdr0->dst_address, sw_if0,      \
+	vnet_buffer (b0)->ip.adj_index[VLIB_RX],                              \
+	/* Should not be used */ ~0);                                         \
+      /* Make sure the face is not created here */                            \
+      ASSERT (ret0 == HICN_ERROR_FACE_ALREADY_CREATED);                       \
+                                                                              \
+      from_tunnel1 =                                                          \
+	(hicnb1->flags & HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL ||                \
+	 hicnb1->flags & HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL) > 0;             \
+      sw_if1 = (from_tunnel1) * ~0 +                                          \
+	       (1 - from_tunnel1) * vnet_buffer (b1)->sw_if_index[VLIB_RX];   \
+                                                                              \
+      ret1 = hicn_face_ip##ipv##_add_and_lock (                               \
+	&hicnb1->face_id, &hicnb1->flags, &ip_hdr1->dst_address, sw_if1,      \
+	vnet_buffer (b1)->ip.adj_index[VLIB_RX],                              \
+	/* Should not be used */ ~0);                                         \
+      /* Make sure the face is not created here */                            \
+      ASSERT (ret1 == HICN_ERROR_FACE_ALREADY_CREATED);                       \
+                                                                              \
       next0 =                                                                 \
 	is_icmp0 * NEXT_MAPME_IP##ipv + (1 - is_icmp0) * NEXT_DATA_IP##ipv;   \
                                                                               \
       next1 =                                                                 \
 	is_icmp1 * NEXT_MAPME_IP##ipv + (1 - is_icmp1) * NEXT_DATA_IP##ipv;   \
                                                                               \
-      ret0 = LOCK_DPO_FACE_IP##ipv (&(hicnb0->face_id),                       \
-				    &(hicnb0->in_faces_vec_id),               \
-				    &hicnb0->flags, &(ip_hdr0->dst_address)); \
+      vlib_increment_combined_counter (                                       \
+	&counters[hicnb0->face_id * HICN_N_COUNTER], thread_index,            \
+	HICN_FACE_COUNTERS_DATA_RX, 1, vlib_buffer_length_in_chain (vm, b0)); \
+      stats.pkts_data_count += 1;                                             \
                                                                               \
-      ret1 = LOCK_DPO_FACE_IP##ipv (&(hicnb1->face_id),                       \
-				    &(hicnb1->in_faces_vec_id),               \
-				    &hicnb1->flags, &(ip_hdr1->dst_address)); \
-                                                                              \
-      if (PREDICT_FALSE (ret0 != HICN_ERROR_NONE))                            \
-	next0 = NEXT_ERROR_DROP_IP##ipv;                                      \
-      else                                                                    \
-	{                                                                     \
-	  vlib_increment_combined_counter (                                   \
-	    &counters[hicnb0->face_id * HICN_N_COUNTER], thread_index,        \
-	    HICN_FACE_COUNTERS_DATA_RX, 1,                                    \
-	    vlib_buffer_length_in_chain (vm, b0));                            \
-	  stats.pkts_data_count += 1;                                         \
-	}                                                                     \
-                                                                              \
-      if (PREDICT_FALSE (ret1 != HICN_ERROR_NONE))                            \
-	next1 = NEXT_ERROR_DROP_IP##ipv;                                      \
-      else                                                                    \
-	{                                                                     \
-	  vlib_increment_combined_counter (                                   \
-	    &counters[hicnb1->face_id * HICN_N_COUNTER], thread_index,        \
-	    HICN_FACE_COUNTERS_DATA_RX, 1,                                    \
-	    vlib_buffer_length_in_chain (vm, b1));                            \
-	  stats.pkts_data_count += 1;                                         \
-	}                                                                     \
+      vlib_increment_combined_counter (                                       \
+	&counters[hicnb1->face_id * HICN_N_COUNTER], thread_index,            \
+	HICN_FACE_COUNTERS_DATA_RX, 1, vlib_buffer_length_in_chain (vm, b1)); \
+      stats.pkts_data_count += 1;                                             \
                                                                               \
       if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&              \
 			 (b0->flags & VLIB_BUFFER_IS_TRACED)))                \
@@ -437,6 +445,7 @@ VLIB_REGISTER_NODE(hicn6_face_input_node) =
 
 typedef enum
 {
+  HICN4_FACE_OUTPUT_NEXT_ERROR_DROP,
   HICN4_FACE_OUTPUT_NEXT_ECHO_REPLY,
   HICN4_FACE_OUTPUT_NEXT_UDP4_ENCAP,
   HICN4_FACE_OUTPUT_NEXT_UDP6_ENCAP,
@@ -445,6 +454,7 @@ typedef enum
 
 typedef enum
 {
+  HICN6_FACE_OUTPUT_NEXT_ERROR_DROP,
   HICN6_FACE_OUTPUT_NEXT_ECHO_REPLY,
   HICN6_FACE_OUTPUT_NEXT_UDP4_ENCAP,
   HICN6_FACE_OUTPUT_NEXT_UDP6_ENCAP,
@@ -546,7 +556,9 @@ hicn_face_rewrite_interest (vlib_main_t *vm, vlib_buffer_t *b0,
 
   if (ret == HICN_LIB_ERROR_REWRITE_CKSUM_REQUIRED)
     {
-      ensure_offload_flags (b0, ip46_address_is_ip4 (&face->nat_addr));
+      u8 is_v4 = ip46_address_is_ip4 (&face->nat_addr) &&
+		 !ip6_address_is_loopback (&face->nat_addr.ip6);
+      ensure_offload_flags (b0, is_v4);
     }
 
   ASSERT (face->flags & HICN_FACE_FLAGS_FACE);
@@ -593,8 +605,8 @@ typedef struct
     {                                                                         \
       vlib_buffer_t *b0;                                                      \
       u32 bi0;                                                                \
-      u32 next0 = ~0;                                                         \
-      hicn_face_t *face;                                                      \
+      u32 next0 = HICN##ipv##_FACE_OUTPUT_NEXT_ERROR_DROP;                    \
+      hicn_face_t *face = NULL;                                               \
                                                                               \
       /* Prefetch for next iteration. */                                      \
       if (n_left_from > 1)                                                    \
@@ -615,9 +627,10 @@ typedef struct
       b0 = vlib_get_buffer (vm, bi0);                                         \
                                                                               \
       hicn_face_id_t face_id = vnet_buffer (b0)->ip.adj_index[VLIB_TX];       \
-      face = hicn_dpoi_get_from_idx (face_id);                                \
+      if (PREDICT_TRUE (hicn_dpoi_idx_is_valid (face_id)))                    \
+	face = hicn_dpoi_get_from_idx (face_id);                              \
                                                                               \
-      if (PREDICT_TRUE (face != NULL))                                        \
+      if (PREDICT_TRUE (face != NULL) && face->flags & HICN_FACE_FLAGS_FACE)  \
 	{                                                                     \
 	  hicn_face_rewrite_interest (vm, b0, face, &next0);                  \
 	  stats.pkts_interest_count += 1;                                     \
@@ -650,9 +663,9 @@ typedef struct
     {                                                                         \
       vlib_buffer_t *b0, *b1;                                                 \
       u32 bi0, bi1;                                                           \
-      u32 next0 = ~0;                                                         \
-      u32 next1 = ~0;                                                         \
-      hicn_face_t *face0, *face1;                                             \
+      u32 next0 = HICN##ipv##_FACE_OUTPUT_NEXT_ERROR_DROP;                    \
+      u32 next1 = HICN##ipv##_FACE_OUTPUT_NEXT_ERROR_DROP;                    \
+      hicn_face_t *face0 = NULL, *face1 = NULL;                               \
                                                                               \
       /* Prefetch for next iteration. */                                      \
       {                                                                       \
@@ -679,10 +692,13 @@ typedef struct
                                                                               \
       hicn_face_id_t face_id0 = vnet_buffer (b0)->ip.adj_index[VLIB_TX];      \
       hicn_face_id_t face_id1 = vnet_buffer (b1)->ip.adj_index[VLIB_TX];      \
-      face0 = hicn_dpoi_get_from_idx (face_id0);                              \
-      face1 = hicn_dpoi_get_from_idx (face_id1);                              \
+      if (PREDICT_TRUE (hicn_dpoi_idx_is_valid (face_id0)))                   \
+	face0 = hicn_dpoi_get_from_idx (face_id0);                            \
+      if (PREDICT_TRUE (hicn_dpoi_idx_is_valid (face_id1)))                   \
+	face1 = hicn_dpoi_get_from_idx (face_id1);                            \
                                                                               \
-      if (PREDICT_TRUE (face0 != NULL))                                       \
+      if (PREDICT_TRUE (face0 != NULL) &&                                     \
+	  face0->flags & HICN_FACE_FLAGS_FACE)                                \
 	{                                                                     \
 	  hicn_face_rewrite_interest (vm, b0, face0, &next0);                 \
 	  stats.pkts_interest_count += 1;                                     \
@@ -692,7 +708,8 @@ typedef struct
 	    vlib_buffer_length_in_chain (vm, b0));                            \
 	}                                                                     \
                                                                               \
-      if (PREDICT_TRUE (face1 != NULL))                                       \
+      if (PREDICT_TRUE (face1 != NULL) &&                                     \
+	  face1->flags & HICN_FACE_FLAGS_FACE)                                \
 	{                                                                     \
 	  hicn_face_rewrite_interest (vm, b1, face1, &next1);                 \
 	  stats.pkts_interest_count += 1;                                     \
@@ -797,7 +814,8 @@ VLIB_REGISTER_NODE (hicn4_face_output_node) = {
   .error_strings = hicn4_face_output_error_strings,
   .n_next_nodes = HICN4_FACE_OUTPUT_N_NEXT,
   /* Reusing the list of nodes from lookup to be compatible with arp */
-  .next_nodes = { [HICN4_FACE_OUTPUT_NEXT_ECHO_REPLY] = "hicn4-face-input",
+  .next_nodes = { [HICN4_FACE_OUTPUT_NEXT_ERROR_DROP] = "error-drop",
+		  [HICN4_FACE_OUTPUT_NEXT_ECHO_REPLY] = "hicn4-face-input",
 		  [HICN4_FACE_OUTPUT_NEXT_UDP4_ENCAP] = "udp4-encap",
 		  [HICN4_FACE_OUTPUT_NEXT_UDP6_ENCAP] = "udp6-encap" }
 };
@@ -867,7 +885,8 @@ VLIB_REGISTER_NODE (hicn6_face_output_node) = {
   .n_next_nodes = HICN6_FACE_OUTPUT_N_NEXT,
   /* Reusing the list of nodes from lookup to be compatible with neighbour
      discovery */
-  .next_nodes = { [HICN6_FACE_OUTPUT_NEXT_ECHO_REPLY] = "hicn6-face-input",
+  .next_nodes = { [HICN6_FACE_OUTPUT_NEXT_ERROR_DROP] = "error-drop",
+		  [HICN6_FACE_OUTPUT_NEXT_ECHO_REPLY] = "hicn6-face-input",
 		  [HICN6_FACE_OUTPUT_NEXT_UDP4_ENCAP] = "udp4-encap",
 		  [HICN6_FACE_OUTPUT_NEXT_UDP6_ENCAP] = "udp6-encap" }
 };
diff --git a/hicn-plugin/src/faces/face_node.h b/hicn-plugin/src/faces/face_node.h
index 3b38e71b3..70daa1393 100644
--- a/hicn-plugin/src/faces/face_node.h
+++ b/hicn-plugin/src/faces/face_node.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/faces/iface_node.c b/hicn-plugin/src/faces/iface_node.c
index bf9c56515..84205af9b 100644
--- a/hicn-plugin/src/faces/iface_node.c
+++ b/hicn-plugin/src/faces/iface_node.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -107,8 +107,8 @@ typedef enum
   ip6_address_t *local_address1 =                                             \
     ip6_interface_first_address (&ip6_main, swif1);
 
-#define DPO_ADD_LOCK_IFACE_IP4 hicn_iface_ip4_add_and_lock
-#define DPO_ADD_LOCK_IFACE_IP6 hicn_iface_ip6_add_and_lock
+#define DPO_ADD_LOCK_FACE_IP4 hicn_face_ip4_add_and_lock
+#define DPO_ADD_LOCK_FACE_IP6 hicn_face_ip6_add_and_lock
 
 //#define VLIB_EDGE_IP4 data_fwd_iface_ip4_vlib_edge
 //#define VLIB_EDGE_IP6 data_fwd_iface_ip6_vlib_edge
@@ -144,6 +144,7 @@ typedef struct
 
 typedef enum
 {
+  HICN4_IFACE_OUTPUT_NEXT_DROP,
   HICN4_IFACE_OUTPUT_NEXT_LOOKUP,
   HICN4_IFACE_OUTPUT_NEXT_UDP4_ENCAP,
   HICN4_IFACE_OUTPUT_NEXT_UDP6_ENCAP,
@@ -161,6 +162,7 @@ typedef struct
 
 typedef enum
 {
+  HICN6_IFACE_OUTPUT_NEXT_DROP,
   HICN6_IFACE_OUTPUT_NEXT_LOOKUP,
   HICN6_IFACE_OUTPUT_NEXT_UDP4_ENCAP,
   HICN6_IFACE_OUTPUT_NEXT_UDP6_ENCAP,
@@ -188,7 +190,7 @@ typedef enum
   do                                                                          \
     {                                                                         \
       vlib_buffer_t *b0;                                                      \
-      u32 bi0, next0, next_iface0;                                            \
+      u32 bi0, next0, next_iface0, sw_if0;                                    \
       IP_HEADER_##ipv *ip_hdr = NULL;                                         \
       hicn_buffer_t *hicnb0;                                                  \
       /* Prefetch for next iteration. */                                      \
@@ -219,15 +221,23 @@ typedef enum
 	is_icmp * NEXT_MAPME_IP##ipv + (1 - is_icmp) * NEXT_INTEREST_IP##ipv; \
                                                                               \
       next_iface0 = NEXT_DATA_LOOKUP_IP##ipv;                                 \
+      sw_if0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];                        \
                                                                               \
-      if (hicnb0->flags & HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL)                 \
-	next_iface0 = NEXT_UDP_ENCAP_IP4;                                     \
-      else if (hicnb0->flags & HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL)            \
-	next_iface0 = NEXT_UDP_ENCAP_IP6;                                     \
+      if (hicnb0->flags & HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL &&               \
+	  vnet_buffer (b0)->ip.adj_index[VLIB_RX] != ADJ_INDEX_INVALID)       \
+	{                                                                     \
+	  next_iface0 = NEXT_UDP_ENCAP_IP4;                                   \
+	  sw_if0 = ~0;                                                        \
+	}                                                                     \
+      else if (hicnb0->flags & HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL &&          \
+	       vnet_buffer (b0)->ip.adj_index[VLIB_RX] != ADJ_INDEX_INVALID)  \
+	{                                                                     \
+	  next_iface0 = NEXT_UDP_ENCAP_IP6;                                   \
+	  sw_if0 = ~0;                                                        \
+	}                                                                     \
                                                                               \
-      DPO_ADD_LOCK_IFACE_IP##ipv (                                            \
-	&(hicnb0->face_id), &hicnb0->flags, &(ip_hdr->src_address),           \
-	vnet_buffer (b0)->sw_if_index[VLIB_RX],                               \
+      DPO_ADD_LOCK_FACE_IP##ipv (                                             \
+	&(hicnb0->face_id), &hicnb0->flags, &(ip_hdr->src_address), sw_if0,   \
 	vnet_buffer (b0)->ip.adj_index[VLIB_RX], next_iface0);                \
                                                                               \
       if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&              \
@@ -236,7 +246,7 @@ typedef enum
 	  TRACE_INPUT_PKT_IP##ipv *t =                                        \
 	    vlib_add_trace (vm, node, b0, sizeof (*t));                       \
 	  t->pkt_type = HICN_PKT_TYPE_INTEREST;                               \
-	  t->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];            \
+	  t->sw_if_index = sw_if0;                                            \
 	  t->next_index = next0;                                              \
 	  clib_memcpy_fast (t->packet_data, vlib_buffer_get_current (b0),     \
 			    sizeof (t->packet_data));                         \
@@ -257,7 +267,7 @@ typedef enum
   do                                                                          \
     {                                                                         \
       vlib_buffer_t *b0, *b1;                                                 \
-      u32 bi0, bi1, next0, next1, next_iface0, next_iface1;                   \
+      u32 bi0, bi1, next0, next1, next_iface0, next_iface1, sw_if0, sw_if1;   \
       IP_HEADER_##ipv *ip_hdr0 = NULL;                                        \
       IP_HEADER_##ipv *ip_hdr1 = NULL;                                        \
       hicn_buffer_t *hicnb0, *hicnb1;                                         \
@@ -300,27 +310,43 @@ typedef enum
 	      (1 - is_icmp1) * NEXT_INTEREST_IP##ipv;                         \
                                                                               \
       next_iface0 = NEXT_DATA_LOOKUP_IP##ipv;                                 \
+      sw_if0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];                        \
                                                                               \
-      if (hicnb0->flags & HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL)                 \
-	next_iface0 = NEXT_UDP_ENCAP_IP4;                                     \
-      else if (hicnb0->flags & HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL)            \
-	next_iface0 = NEXT_UDP_ENCAP_IP6;                                     \
+      if (hicnb0->flags & HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL &&               \
+	  vnet_buffer (b0)->ip.adj_index[VLIB_RX] != ADJ_INDEX_INVALID)       \
+	{                                                                     \
+	  next_iface0 = NEXT_UDP_ENCAP_IP4;                                   \
+	  sw_if0 = ~0;                                                        \
+	}                                                                     \
+      else if (hicnb0->flags & HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL &&          \
+	       vnet_buffer (b0)->ip.adj_index[VLIB_RX] != ADJ_INDEX_INVALID)  \
+	{                                                                     \
+	  next_iface0 = NEXT_UDP_ENCAP_IP6;                                   \
+	  sw_if0 = ~0;                                                        \
+	}                                                                     \
                                                                               \
       next_iface1 = NEXT_DATA_LOOKUP_IP##ipv;                                 \
+      sw_if1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];                        \
                                                                               \
-      if (hicnb1->flags & HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL)                 \
-	next_iface1 = NEXT_UDP_ENCAP_IP4;                                     \
-      else if (hicnb1->flags & HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL)            \
-	next_iface1 = NEXT_UDP_ENCAP_IP6;                                     \
+      if (hicnb1->flags & HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL &&               \
+	  vnet_buffer (b1)->ip.adj_index[VLIB_RX] != ADJ_INDEX_INVALID)       \
+	{                                                                     \
+	  next_iface1 = NEXT_UDP_ENCAP_IP4;                                   \
+	  sw_if1 = ~0;                                                        \
+	}                                                                     \
+      else if (hicnb1->flags & HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL &&          \
+	       vnet_buffer (b1)->ip.adj_index[VLIB_RX] != ADJ_INDEX_INVALID)  \
+	{                                                                     \
+	  next_iface1 = NEXT_UDP_ENCAP_IP6;                                   \
+	  sw_if1 = ~0;                                                        \
+	}                                                                     \
                                                                               \
-      DPO_ADD_LOCK_IFACE_IP##ipv (                                            \
-	&(hicnb0->face_id), &hicnb0->flags, &(ip_hdr0->src_address),          \
-	vnet_buffer (b0)->sw_if_index[VLIB_RX],                               \
+      DPO_ADD_LOCK_FACE_IP##ipv (                                             \
+	&(hicnb0->face_id), &hicnb0->flags, &(ip_hdr0->src_address), sw_if0,  \
 	vnet_buffer (b0)->ip.adj_index[VLIB_RX], next_iface0);                \
                                                                               \
-      DPO_ADD_LOCK_IFACE_IP##ipv (                                            \
-	&(hicnb1->face_id), &hicnb1->flags, &(ip_hdr1->src_address),          \
-	vnet_buffer (b1)->sw_if_index[VLIB_RX],                               \
+      DPO_ADD_LOCK_FACE_IP##ipv (                                             \
+	&(hicnb1->face_id), &hicnb1->flags, &(ip_hdr1->src_address), sw_if1,  \
 	vnet_buffer (b1)->ip.adj_index[VLIB_RX], next_iface1);                \
                                                                               \
       if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&              \
@@ -329,7 +355,7 @@ typedef enum
 	  TRACE_INPUT_PKT_IP##ipv *t =                                        \
 	    vlib_add_trace (vm, node, b0, sizeof (*t));                       \
 	  t->pkt_type = HICN_PKT_TYPE_INTEREST;                               \
-	  t->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];            \
+	  t->sw_if_index = sw_if0;                                            \
 	  t->next_index = next0;                                              \
 	  clib_memcpy_fast (t->packet_data, vlib_buffer_get_current (b0),     \
 			    sizeof (t->packet_data));                         \
@@ -341,7 +367,7 @@ typedef enum
 	  TRACE_INPUT_PKT_IP##ipv *t =                                        \
 	    vlib_add_trace (vm, node, b1, sizeof (*t));                       \
 	  t->pkt_type = HICN_PKT_TYPE_INTEREST;                               \
-	  t->sw_if_index = vnet_buffer (b1)->sw_if_index[VLIB_RX];            \
+	  t->sw_if_index = sw_if1;                                            \
 	  t->next_index = next1;                                              \
 	  clib_memcpy_fast (t->packet_data, vlib_buffer_get_current (b1),     \
 			    sizeof (t->packet_data));                         \
@@ -588,7 +614,7 @@ hicn_rewrite_iface_data6 (vlib_main_t *vm, vlib_buffer_t *b0,
       vlib_buffer_t *b0;                                                      \
       u32 bi0;                                                                \
       u32 next0 = next_index;                                                 \
-      hicn_face_t *face;                                                      \
+      hicn_face_t *face = NULL;                                               \
                                                                               \
       /* Prefetch for next iteration. */                                      \
       if (n_left_from > 1)                                                    \
@@ -609,7 +635,8 @@ hicn_rewrite_iface_data6 (vlib_main_t *vm, vlib_buffer_t *b0,
       b0 = vlib_get_buffer (vm, bi0);                                         \
                                                                               \
       hicn_face_id_t face_id = vnet_buffer (b0)->ip.adj_index[VLIB_TX];       \
-      face = hicn_dpoi_get_from_idx (face_id);                                \
+      if (PREDICT_TRUE (hicn_dpoi_idx_is_valid (face_id)))                    \
+	face = hicn_dpoi_get_from_idx (face_id);                              \
                                                                               \
       if (PREDICT_TRUE (face != NULL))                                        \
 	{                                                                     \
@@ -646,7 +673,7 @@ hicn_rewrite_iface_data6 (vlib_main_t *vm, vlib_buffer_t *b0,
       u32 bi0, bi1;                                                           \
       u32 next0 = next_index;                                                 \
       u32 next1 = next_index;                                                 \
-      hicn_face_t *face0, *face1;                                             \
+      hicn_face_t *face0 = NULL, *face1 = NULL;                               \
                                                                               \
       /* Prefetch for next iteration. */                                      \
       {                                                                       \
@@ -674,8 +701,10 @@ hicn_rewrite_iface_data6 (vlib_main_t *vm, vlib_buffer_t *b0,
                                                                               \
       hicn_face_id_t face_id0 = vnet_buffer (b0)->ip.adj_index[VLIB_TX];      \
       hicn_face_id_t face_id1 = vnet_buffer (b1)->ip.adj_index[VLIB_TX];      \
-      face0 = hicn_dpoi_get_from_idx (face_id0);                              \
-      face1 = hicn_dpoi_get_from_idx (face_id1);                              \
+      if (PREDICT_TRUE (hicn_dpoi_idx_is_valid (face_id0)))                   \
+	face0 = hicn_dpoi_get_from_idx (face_id0);                            \
+      if (PREDICT_TRUE (hicn_dpoi_idx_is_valid (face_id1)))                   \
+	face1 = hicn_dpoi_get_from_idx (face_id1);                            \
                                                                               \
       if (PREDICT_TRUE (face0 != NULL))                                       \
 	{                                                                     \
@@ -738,7 +767,7 @@ hicn4_iface_output_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 
   from = vlib_frame_vector_args (frame);
   n_left_from = frame->n_vectors;
-  next_index = node->cached_next_index;
+  next_index = HICN4_IFACE_OUTPUT_NEXT_DROP;
 
   while (n_left_from > 0)
     {
@@ -792,7 +821,8 @@ VLIB_REGISTER_NODE (hicn4_iface_output_node) = {
   .error_strings = hicn4_iface_output_error_strings,
   .n_next_nodes = HICN4_IFACE_OUTPUT_N_NEXT,
   /* edit / add dispositions here */
-  .next_nodes = { [HICN4_IFACE_OUTPUT_NEXT_LOOKUP] = "ip4-lookup",
+  .next_nodes = { [HICN4_IFACE_OUTPUT_NEXT_DROP] = "error-drop",
+		  [HICN4_IFACE_OUTPUT_NEXT_LOOKUP] = "ip4-lookup",
 		  [HICN4_IFACE_OUTPUT_NEXT_UDP4_ENCAP] = "udp4-encap",
 		  [HICN4_IFACE_OUTPUT_NEXT_UDP6_ENCAP] = "udp6-encap" },
 };
@@ -807,7 +837,7 @@ hicn6_iface_output_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 
   from = vlib_frame_vector_args (frame);
   n_left_from = frame->n_vectors;
-  next_index = node->cached_next_index;
+  next_index = HICN6_IFACE_OUTPUT_NEXT_DROP;
 
   while (n_left_from > 0)
     {
@@ -860,11 +890,10 @@ VLIB_REGISTER_NODE (hicn6_iface_output_node) = {
   .error_strings = hicn6_iface_output_error_strings,
   .n_next_nodes = HICN6_IFACE_OUTPUT_N_NEXT,
   /* edit / add dispositions here */
-  .next_nodes = { [HICN6_IFACE_OUTPUT_NEXT_LOOKUP] = "ip6-lookup",
+  .next_nodes = { [HICN6_IFACE_OUTPUT_NEXT_DROP] = "error-drop",
+		  [HICN6_IFACE_OUTPUT_NEXT_LOOKUP] = "ip6-lookup",
 		  [HICN6_IFACE_OUTPUT_NEXT_UDP4_ENCAP] = "udp4-encap",
-		  [HICN6_IFACE_OUTPUT_NEXT_UDP6_ENCAP] = "udp6-encap"
-
-  },
+		  [HICN6_IFACE_OUTPUT_NEXT_UDP6_ENCAP] = "udp6-encap" },
 };
 
 /*
diff --git a/hicn-plugin/src/faces/iface_node.h b/hicn-plugin/src/faces/iface_node.h
index acb3cab0f..3fa6bb484 100644
--- a/hicn-plugin/src/faces/iface_node.h
+++ b/hicn-plugin/src/faces/iface_node.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/faces/inlines.h b/hicn-plugin/src/faces/inlines.h
index 95a1c2ad2..ad9e26b62 100644
--- a/hicn-plugin/src/faces/inlines.h
+++ b/hicn-plugin/src/faces/inlines.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,24 +21,19 @@
 always_inline void
 ensure_offload_flags (vlib_buffer_t *b, int is_v4)
 {
-  vnet_buffer_offload_flags_set(b, VNET_BUFFER_OFFLOAD_F_TCP_CKSUM);
-  vnet_buffer_offload_flags_set(b, is_v4 * VNET_BUFFER_OFFLOAD_F_IP_CKSUM);
+  vnet_buffer_offload_flags_set (b, VNET_BUFFER_OFFLOAD_F_TCP_CKSUM);
+  vnet_buffer_offload_flags_set (b, is_v4 * VNET_BUFFER_OFFLOAD_F_IP_CKSUM);
 
   size_t l3_header_size =
     is_v4 * sizeof (ip4_header_t) + (!is_v4) * sizeof (ip6_header_t);
 
   /* Make sure l3_hdr_offset and l4_hdr_offset are set */
-  if (!(b->flags & VNET_BUFFER_F_L3_HDR_OFFSET_VALID))
-    {
-      b->flags |= VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
-      vnet_buffer (b)->l3_hdr_offset = b->current_data;
-    }
-  if (!(b->flags & VNET_BUFFER_F_L4_HDR_OFFSET_VALID))
-    {
-      b->flags |= VNET_BUFFER_F_L4_HDR_OFFSET_VALID;
-      vnet_buffer (b)->l4_hdr_offset =
-	vnet_buffer (b)->l3_hdr_offset + l3_header_size;
-    }
+  b->flags |= VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
+  vnet_buffer (b)->l3_hdr_offset = b->current_data;
+
+  b->flags |= VNET_BUFFER_F_L4_HDR_OFFSET_VALID;
+  vnet_buffer (b)->l4_hdr_offset =
+    vnet_buffer (b)->l3_hdr_offset + l3_header_size;
 }
 
 #endif /* __HICN_FACE_INLINES_H__ */
\ No newline at end of file
diff --git a/hicn-plugin/src/hashtb.c b/hicn-plugin/src/hashtb.c
index a74353239..eb7da81f2 100644
--- a/hicn-plugin/src/hashtb.c
+++ b/hicn-plugin/src/hashtb.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -187,7 +187,7 @@ hicn_hashtb_alloc (hicn_hashtb_h *ph, u32 max_elems, size_t app_data_size)
     }
   pool_get_aligned (h->ht_nodes, nodep, 8);
   // alloc node 0
-  nodep = nodep; /* Silence 'not used' warning */
+  (void) nodep; /* Silence 'not used' warning */
 
   h->ht_node_count = max_elems;
   h->ht_nodes_used = 1;
@@ -206,7 +206,7 @@ hicn_hashtb_alloc (hicn_hashtb_h *ph, u32 max_elems, size_t app_data_size)
     }
   /* 'Hide' the zero-th node so we can use zero as an 'empty' value */
   pool_get_aligned (h->ht_overflow_buckets, bucket, 8);
-  bucket = bucket; /* Silence 'not used' warning */
+  (void) bucket; /* Silence 'not used' warning */
 
   h->ht_overflow_bucket_count = count;
   h->ht_overflow_buckets_used = 1;
diff --git a/hicn-plugin/src/hashtb.h b/hicn-plugin/src/hashtb.h
index 3965ec65d..4b787e2d7 100644
--- a/hicn-plugin/src/hashtb.h
+++ b/hicn-plugin/src/hashtb.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/hicn.api b/hicn-plugin/src/hicn.api
index 9643f2098..44382c743 100644
--- a/hicn-plugin/src/hicn.api
+++ b/hicn-plugin/src/hicn.api
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -437,8 +437,14 @@ define hicn_api_enable_disable_reply
   /* Arbitrary context, so client can match reply to request */
   u32 context;
 
-/* Return value, zero means all OK */
+  /* Return value, zero means all OK */
   i32 retval;
+
+  /* Number of faces created */
+  u8 nfaces;
+
+  /* IDs of new faces */
+  u32 faceids[16];
 };
 
 define hicn_api_register_prod_app
diff --git a/hicn-plugin/src/hicn.c b/hicn-plugin/src/hicn.c
index 9bec91455..1131d4339 100644
--- a/hicn-plugin/src/hicn.c
+++ b/hicn-plugin/src/hicn.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -149,8 +149,8 @@ hicn_infra_plugin_enable_disable (int enable_disable, int pit_size_req,
       // check if CS is bugger tha PIT or bigger than the available
       // vlib_buffers
       uword cs_buffers = (n_buffers > HICN_PARAM_CS_MIN_MBUF) ?
-			   n_buffers - HICN_PARAM_CS_MIN_MBUF :
-			   0;
+				 n_buffers - HICN_PARAM_CS_MIN_MBUF :
+				 0;
 
       if (cs_size_req > (pit_size_req / 2) || cs_size_req > cs_buffers)
 	{
diff --git a/hicn-plugin/src/hicn.h b/hicn-plugin/src/hicn.h
index 4ff4f6ae6..aaf16c917 100644
--- a/hicn-plugin/src/hicn.h
+++ b/hicn-plugin/src/hicn.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -61,10 +61,8 @@ typedef u8 weight_t;
  * 2*CLIB_CACHE_LINE_BYTES.  */
 /* This flag is used to mark packets whose lenght is less that
  * 2*CLIB_CACHE_LINE_BYTES. */
-#define HICN_BUFFER_FLAGS_PKT_LESS_TWO_CL  0x02
-#define HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL 0x04
-#define HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL 0x08
-#define HICN_BUFFER_FLAGS_FROM_CS	   0x10
+#define HICN_BUFFER_FLAGS_PKT_LESS_TWO_CL 0x02
+#define HICN_BUFFER_FLAGS_FROM_CS	  0x10
 
 /* The following is stored in the opaque2 field in the vlib_buffer_t */
 typedef struct
@@ -83,7 +81,6 @@ typedef struct
   u8 vft_id;	 /* " */
 
   hicn_face_id_t face_id; /* ingress iface, sizeof(u32) */
-  u32 in_faces_vec_id;	  /* vector of possible input face for a data packet */
 
   hicn_type_t type;
 } hicn_buffer_t;
diff --git a/hicn-plugin/src/hicn_api.c b/hicn-plugin/src/hicn_api.c
index b72675f63..85279eb0b 100644
--- a/hicn-plugin/src/hicn_api.c
+++ b/hicn-plugin/src/hicn_api.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -40,12 +40,12 @@
 #include "route.h"
 
 /* define message IDs */
-#include <hicn/hicn.api_enum.h>
-#include <hicn/hicn.api_types.h>
+#include <vpp_plugins/hicn/hicn.api_enum.h>
+#include <vpp_plugins/hicn/hicn.api_types.h>
 
 /* define generated endian-swappers */
 #define vl_endianfun
-#include <hicn/hicn_all_api_h.h>
+#include <vpp_plugins/hicn/hicn_all_api_h.h>
 #undef vl_endianfun
 
 #define REPLY_MSG_ID_BASE sm->msg_id_base
@@ -79,8 +79,8 @@ vl_api_hicn_api_node_params_set_t_handler (
 
   f64 pit_max_lifetime_sec = mp->pit_max_lifetime_sec;
   pit_max_lifetime_sec = pit_max_lifetime_sec == -1 ?
-			   HICN_PARAM_PIT_LIFETIME_DFLT_MAX_MS / SEC_MS :
-			   pit_max_lifetime_sec;
+				 HICN_PARAM_PIT_LIFETIME_DFLT_MAX_MS / SEC_MS :
+				 pit_max_lifetime_sec;
 
   int cs_max_size = clib_net_to_host_i32 (mp->cs_max_size);
   cs_max_size = cs_max_size == -1 ? HICN_PARAM_CS_ENTRIES_DFLT : cs_max_size;
@@ -159,7 +159,7 @@ send_face_details (hicn_face_t *face, vl_api_hicn_face_t *mp)
     {
       sbuf =
 	format (0, "%U", format_vnet_sw_interface_name, vnm, sw_interface);
-      strcpy ((char *) (mp->if_name), (char *) sbuf);
+      strcpy_s ((char *) (mp->if_name), sizeof (mp->if_name), (char *) sbuf);
     }
 }
 
@@ -567,17 +567,34 @@ vl_api_hicn_api_enable_disable_t_handler (vl_api_hicn_api_enable_disable_t *mp)
   fib_prefix_t prefix;
   ip_prefix_decode (&mp->prefix, &prefix);
 
+  hicn_face_id_t *vec_faces = NULL;
+
   switch (clib_net_to_host_u32 (mp->enable_disable))
     {
     case HICN_ENABLE:
-      rv = hicn_route_enable (&prefix);
+      HICN_DEBUG ("Calling hicn enable from API.");
+      rv = hicn_route_enable (&prefix, &vec_faces);
       break;
     case HICN_DISABLE:
+      HICN_DEBUG ("Calling hicn disable from API.");
       rv = hicn_route_disable (&prefix);
       break;
     }
 
-  REPLY_MACRO (VL_API_HICN_API_ENABLE_DISABLE_REPLY /* , rmp, mp, rv */);
+  REPLY_MACRO2 (VL_API_HICN_API_ENABLE_DISABLE_REPLY, ({
+		  rmp->nfaces = 0;
+		  if (vec_faces != NULL)
+		    {
+		      hicn_face_id_t *face;
+		      vec_foreach (face, vec_faces)
+			{
+			  rmp->faceids[rmp->nfaces++] =
+			    clib_host_to_net_u32 (*face);
+			}
+
+		      vec_free (vec_faces);
+		    }
+		}));
 }
 
 /*********************************** UDP TUNNELS
@@ -632,7 +649,7 @@ done:
 
 /************************************************************************************/
 
-#include <hicn/hicn.api.c>
+#include <vpp_plugins/hicn/hicn.api.c>
 
 /* Set up the API message handling tables */
 clib_error_t *
diff --git a/hicn-plugin/src/hicn_api_test.c b/hicn-plugin/src/hicn_api_test.c
index 04e216e38..fbba5ffc3 100644
--- a/hicn-plugin/src/hicn_api_test.c
+++ b/hicn-plugin/src/hicn_api_test.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -31,11 +31,11 @@
 
 #include <vpp/api/vpe.api_types.h>
 
-#include <hicn/hicn_api.h>
-#include "error.h"
+#include <vpp_plugins/hicn/hicn_api.h>
+#include <vpp_plugins/hicn/error.h>
 
 /* Declare message IDs */
-#include "hicn_msg_enum.h"
+#include <vpp_plugins/hicn/hicn_msg_enum.h>
 
 /* SUPPORTING FUNCTIONS NOT LOADED BY VPP_API_TEST */
 uword
@@ -1000,8 +1000,8 @@ api_hicn_api_enable_disable (vat_main_t *vam)
     }
 
   prefix.fp_proto = ip46_address_is_ip4 (&(prefix.fp_addr)) ?
-		      FIB_PROTOCOL_IP4 :
-		      FIB_PROTOCOL_IP6;
+			    FIB_PROTOCOL_IP4 :
+			    FIB_PROTOCOL_IP6;
 
   // Construct the API message
   M (HICN_API_ENABLE_DISABLE, mp);
@@ -1053,8 +1053,8 @@ api_hicn_api_register_prod_app (vat_main_t *vam)
     }
 
   prefix.fp_proto = ip46_address_is_ip4 (&(prefix.fp_addr)) ?
-		      FIB_PROTOCOL_IP4 :
-		      FIB_PROTOCOL_IP6;
+			    FIB_PROTOCOL_IP4 :
+			    FIB_PROTOCOL_IP6;
   /* Construct the API message */
   M (HICN_API_REGISTER_PROD_APP, mp);
   ip_prefix_encode (&prefix, &mp->prefix);
@@ -1310,7 +1310,7 @@ vl_api_hicn_api_udp_tunnel_add_del_reply_t_handler (
   fformat (vam->ofp, "udp-encap %d\n", uei);
 }
 
-#include <hicn/hicn.api_test.c>
+#include <vpp_plugins/hicn/hicn.api_test.c>
 
 /*
  * fd.io coding-style-patch-verification: ON
diff --git a/hicn-plugin/src/hicn_logging.h b/hicn-plugin/src/hicn_logging.h
new file mode 100644
index 000000000..a960a7212
--- /dev/null
+++ b/hicn-plugin/src/hicn_logging.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __HICN_DEBUG_H__
+#define __HICN_DEBUG_H__
+
+#ifdef HICN_DDEBUG
+#define HICN_DEBUG(...)                                                       \
+  do                                                                          \
+    {                                                                         \
+      clib_warning (__VA_ARGS__);                                             \
+    }                                                                         \
+  while (0)
+#else
+#define HICN_DEBUG(...)
+#endif /* HICN_DEBUG */
+
+#define HICN_ERROR(...) clib_error_return (0, __VA_ARGS__)
+
+#endif /* __HICN_DEBUG_H__ */
\ No newline at end of file
diff --git a/libtransport/src/protocols/fec_base.cc b/hicn-plugin/src/infra.c
index 9252bc473..e0dba5efd 100644
--- a/libtransport/src/protocols/fec_base.cc
+++ b/hicn-plugin/src/infra.c
@@ -13,12 +13,13 @@
  * limitations under the License.
  */
 
-#include <protocols/fec/rs.h>
-#include <protocols/fec_base.h>
+#include "infra.h"
 
-namespace transport {
-namespace protocol {
+/**
+ * @file infra.c
+ *
+ */
 
-namespace fec {}  // namespace fec
-}  // namespace protocol
-}  // namespace transport
\ No newline at end of file
+/* PIT and CS size */
+u32 hicn_infra_pit_size;
+u32 hicn_infra_cs_size;
diff --git a/hicn-plugin/src/infra.h b/hicn-plugin/src/infra.h
index 900ecedde..c942ad581 100644
--- a/hicn-plugin/src/infra.h
+++ b/hicn-plugin/src/infra.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -57,8 +57,8 @@ extern hicn_main_t hicn_main;
 extern int hicn_infra_fwdr_initialized;
 
 /* PIT and CS size */
-u32 hicn_infra_pit_size;
-u32 hicn_infra_cs_size;
+extern u32 hicn_infra_pit_size;
+extern u32 hicn_infra_cs_size;
 
 /**
  * @brief Enable and disable the hicn plugin
diff --git a/hicn-plugin/src/interest_hitcs.h b/hicn-plugin/src/interest_hitcs.h
index 05a790688..0df987778 100644
--- a/hicn-plugin/src/interest_hitcs.h
+++ b/hicn-plugin/src/interest_hitcs.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/interest_hitcs_node.c b/hicn-plugin/src/interest_hitcs_node.c
index e29b173a9..947b4cb68 100644
--- a/hicn-plugin/src/interest_hitcs_node.c
+++ b/hicn-plugin/src/interest_hitcs_node.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -189,7 +189,7 @@ hicn_interest_hitcs_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	       * the data through it
 	       */
 	      next0 = isv6 ? HICN_INTEREST_HITCS_NEXT_IFACE6_OUT :
-			     HICN_INTEREST_HITCS_NEXT_IFACE4_OUT;
+				   HICN_INTEREST_HITCS_NEXT_IFACE4_OUT;
 	      vnet_buffer (b0)->ip.adj_index[VLIB_TX] = hicnb0->face_id;
 
 	      clone_from_cs (vm, &pitp->u.cs.cs_pkt_buf, b0, isv6);
diff --git a/hicn-plugin/src/interest_hitpit.h b/hicn-plugin/src/interest_hitpit.h
index 44cf2c879..18ef94aa7 100644
--- a/hicn-plugin/src/interest_hitpit.h
+++ b/hicn-plugin/src/interest_hitpit.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/interest_hitpit_node.c b/hicn-plugin/src/interest_hitpit_node.c
index 837eddca7..33dc782cd 100644
--- a/hicn-plugin/src/interest_hitpit_node.c
+++ b/hicn-plugin/src/interest_hitpit_node.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -88,7 +88,8 @@ hicn_interest_hitpit_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  u8 dpo_ctx_id0;
 	  u8 found = 0;
 	  int nh_idx;
-	  hicn_face_id_t outface;
+	  hicn_face_id_t outfaces[MAX_OUT_FACES];
+	  u32 outfaces_len;
 	  hicn_hash_entry_t *hash_entry0;
 	  hicn_buffer_t *hicnb0;
 	  int ret;
@@ -171,23 +172,77 @@ hicn_interest_hitpit_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 
 		  if (found)
 		    {
-		      strategy_vft0->hicn_select_next_hop (dpo_ctx_id0,
-							   &nh_idx, &outface);
+		      strategy_vft0->hicn_select_next_hop (
+			dpo_ctx_id0, &nh_idx, outfaces, &outfaces_len);
 		      /* Retransmission */
 		      /*
 		       * Prepare the packet for the
 		       * forwarding
 		       */
-		      next0 = isv6 ? HICN_INTEREST_HITPIT_NEXT_FACE6_OUTPUT :
-				     HICN_INTEREST_HITPIT_NEXT_FACE4_OUTPUT;
-		      vnet_buffer (b0)->ip.adj_index[VLIB_TX] = outface;
-
-		      /*
-		       * Update the egress face in
-		       * the PIT
-		       */
-		      pitp->u.pit.pe_txnh = nh_idx;
-		      stats.interests_retx++;
+		      if (outfaces_len == 1)
+			{
+			  next0 = isv6 ?
+					  HICN_INTEREST_HITPIT_NEXT_FACE6_OUTPUT :
+					  HICN_INTEREST_HITPIT_NEXT_FACE4_OUTPUT;
+			  vnet_buffer (b0)->ip.adj_index[VLIB_TX] =
+			    outfaces[0];
+
+			  /*
+			   * Update the egress face in
+			   * the PIT
+			   */
+			  pitp->u.pit.pe_txnh = nh_idx;
+			  stats.interests_retx++;
+			}
+		      else
+			{
+			  // restore pointers
+			  to_next -= 1;
+			  n_left_to_next += 1;
+			  u32 clones[outfaces_len];
+			  int ret =
+			    vlib_buffer_clone (vm, bi0, clones, outfaces_len,
+					       CLIB_CACHE_LINE_BYTES * 2);
+			  ASSERT (ret == outfaces_len);
+			  for (u32 nh = 0; nh < outfaces_len; nh++)
+			    {
+			      vlib_buffer_t *local_b0 =
+				vlib_get_buffer (vm, clones[nh]);
+			      to_next[0] = clones[nh];
+			      to_next += 1;
+			      n_left_to_next -= 1;
+
+			      next0 =
+				isv6 ? HICN_INTEREST_HITPIT_NEXT_FACE6_OUTPUT :
+					     HICN_INTEREST_HITPIT_NEXT_FACE4_OUTPUT;
+			      vnet_buffer (local_b0)->ip.adj_index[VLIB_TX] =
+				outfaces[nh];
+			      stats.interests_retx++;
+
+			      /* Maybe trace */
+			      if (PREDICT_FALSE (
+				    (node->flags & VLIB_NODE_FLAG_TRACE) &&
+				    (local_b0->flags & VLIB_BUFFER_IS_TRACED)))
+				{
+				  hicn_interest_hitpit_trace_t *t =
+				    vlib_add_trace (vm, node, local_b0,
+						    sizeof (*t));
+				  t->pkt_type = HICN_PKT_TYPE_INTEREST;
+				  t->sw_if_index = vnet_buffer (local_b0)
+						     ->sw_if_index[VLIB_RX];
+				  t->next_index = next0;
+				}
+
+			      /*
+			       * Verify speculative enqueue, maybe switch
+			       * current next frame
+			       */
+			      vlib_validate_buffer_enqueue_x1 (
+				vm, node, next_index, to_next, n_left_to_next,
+				clones[nh], next0);
+			    }
+			  continue;
+			}
 		    }
 		  else
 		    {
diff --git a/hicn-plugin/src/interest_pcslookup.h b/hicn-plugin/src/interest_pcslookup.h
index 87d093e91..4da9c1939 100644
--- a/hicn-plugin/src/interest_pcslookup.h
+++ b/hicn-plugin/src/interest_pcslookup.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/interest_pcslookup_node.c b/hicn-plugin/src/interest_pcslookup_node.c
index d3f6c7bca..ff0da12d7 100644
--- a/hicn-plugin/src/interest_pcslookup_node.c
+++ b/hicn-plugin/src/interest_pcslookup_node.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/mapme.h b/hicn-plugin/src/mapme.h
index 63bd42610..1d46ea9f3 100644
--- a/hicn-plugin/src/mapme.h
+++ b/hicn-plugin/src/mapme.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,9 +21,9 @@
 #include <hicn/mapme.h>
 
 #include "hicn.h"
-#include "route.h"
 #include "strategy_dpo_ctx.h"
 #include "strategy_dpo_manager.h" // dpo_is_hicn
+#include "udp_tunnels/udp_tunnel.h"
 
 /**
  * @file
@@ -63,7 +63,6 @@ typedef struct hicn_mapme_conf_s
   bool remove_dpo; // FIXME used ?
 
   vlib_main_t *vm;
-  vlib_log_class_t log_class;
 } hicn_mapme_main_t;
 
 /**
@@ -100,65 +99,33 @@ STATIC_ASSERT (sizeof (hicn_mapme_tfib_t) <= sizeof (hicn_dpo_ctx_t),
 
 #define TFIB(dpo_ctx) ((hicn_mapme_tfib_t *) (dpo_ctx))
 
-static_always_inline int
-hicn_mapme_nh_set (hicn_mapme_tfib_t *tfib, hicn_face_id_t face_id)
-{
-  hicn_dpo_ctx_t *strategy_ctx = (hicn_dpo_ctx_t *) tfib;
-  const fib_prefix_t *prefix =
-    fib_entry_get_prefix (strategy_ctx->fib_entry_index);
-
-  u32 n_entries = tfib->entry_count;
-  /* Remove all the existing next hops and set the new one */
-  for (int i = 0; i < n_entries; i++)
-    {
-      hicn_face_t *face = hicn_dpoi_get_from_idx (strategy_ctx->next_hops[0]);
-      ip_adjacency_t *adj = adj_get (face->dpo.dpoi_index);
-      ip_nh_del_helper (face->dpo.dpoi_proto, prefix,
-			&adj->sub_type.nbr.next_hop, face->sw_if);
-    }
-  hicn_face_t *face = hicn_dpoi_get_from_idx (face_id);
-  ip_nh_add_helper (face->dpo.dpoi_proto, prefix, &face->nat_addr,
-		    face->sw_if);
-  return 0;
-}
-
 /**
- * @brief Add a next hop iif it is not already a next hops
+ * @brief Check whether a face is already included in the TFIB.
+ *
+ * NOTE: linear scan on a contiguous small array should be the most efficient.
  */
 static_always_inline int
-hicn_mapme_nh_add (hicn_mapme_tfib_t *tfib, hicn_face_id_t face_id)
+hicn_mapme_tfib_has (hicn_mapme_tfib_t *tfib, hicn_face_id_t face_id)
 {
-  for (u8 pos = 0; pos < tfib->entry_count; pos++)
-    if (tfib->next_hops[pos] == face_id)
-      return 0;
-
-  /* Add the next hop in the vrf 0 which will add it to the entry in the hICN
-   * vrf */
-  hicn_dpo_ctx_t *strategy_ctx = (hicn_dpo_ctx_t *) tfib;
-  const fib_prefix_t *prefix =
-    fib_entry_get_prefix (strategy_ctx->fib_entry_index);
-  hicn_face_t *face = hicn_dpoi_get_from_idx (face_id);
-  ip_nh_add_helper (face->dpo.dpoi_proto, prefix, &face->nat_addr,
-		    face->sw_if);
-
+  u8 pos = HICN_PARAM_FIB_ENTRY_NHOPS_MAX - tfib->tfib_entry_count;
+  for (u8 pos2 = pos; pos2 < HICN_PARAM_FIB_ENTRY_NHOPS_MAX; pos2++)
+    if (tfib->next_hops[pos2] == face_id)
+      return 1;
   return 0;
 }
 
 /**
  * Add a 'previous' hop to the TFIB
- *
- * XXX we should have the for look in the reverse order for simpler code.
  */
 static_always_inline int
 hicn_mapme_tfib_add (hicn_mapme_tfib_t *tfib, hicn_face_id_t face_id)
 {
-  u8 pos = HICN_PARAM_FIB_ENTRY_NHOPS_MAX - tfib->tfib_entry_count;
+  // Don't add if it already exists
+  // (eg. an old IU received on a face on which we are retransmitting)
+  if (hicn_mapme_tfib_has (tfib, face_id))
+    return 0;
 
-  // XXX don 't add if it already exist
-  // eg.an old IU received on a face on which we are retransmitting
-  for (u8 pos2 = pos; pos2 < HICN_PARAM_FIB_ENTRY_NHOPS_MAX; pos2++)
-    if (tfib->next_hops[pos2] == face_id)
-      return 0;
+  u8 pos = HICN_PARAM_FIB_ENTRY_NHOPS_MAX - tfib->tfib_entry_count;
 
   // Make sure we have enough room
   if (pos <= tfib->entry_count)
@@ -190,7 +157,6 @@ hicn_mapme_tfib_clear (hicn_mapme_tfib_t *tfib)
     {
       hicn_face_unlock_with_id (tfib->next_hops[pos]);
       tfib->next_hops[pos] = invalid;
-      break;
     }
 
   tfib->tfib_entry_count = 0;
@@ -358,10 +324,6 @@ hicn_mapme_get_dpo_face_node (hicn_face_id_t face_id)
     }
 }
 
-#define DEBUG(...) // vlib_log_debug(mapme_main.log_class, __VA_ARGS__)
-#define WARN(...)  // vlib_log_warn(mapme_main.log_class, __VA_ARGS__)
-#define ERROR(...) // vlib_log_err(mapme_main.log_class, __VA_ARGS__)
-
 #endif /* __HICN_MAPME__ */
 
 /*
diff --git a/hicn-plugin/src/mapme_ack.h b/hicn-plugin/src/mapme_ack.h
index 821baf203..72ed7a0c4 100644
--- a/hicn-plugin/src/mapme_ack.h
+++ b/hicn-plugin/src/mapme_ack.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,7 +14,7 @@
  */
 
 /*
- * Copyright (c) 2017-2019 by Cisco Systems Inc. All Rights Reserved.
+ * Copyright (c) 2021 by Cisco Systems Inc. All Rights Reserved.
  *
  */
 
diff --git a/hicn-plugin/src/mapme_ack_node.c b/hicn-plugin/src/mapme_ack_node.c
index fad344b73..ea4834665 100644
--- a/hicn-plugin/src/mapme_ack_node.c
+++ b/hicn-plugin/src/mapme_ack_node.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,6 +14,7 @@
  */
 
 #include <vnet/ip/ip6_packet.h>
+#include <vlib/log.h>
 
 #include "hicn.h"
 #include "mapme.h"
@@ -69,7 +70,8 @@ hicn_mapme_process_ack (vlib_main_t *vm, vlib_buffer_t *b,
   dpo = fib_epm_lookup (&(prefix.name), prefix.len);
   if (!dpo)
     {
-      DEBUG ("Ignored ACK for non-existing FIB entry. Ignored.");
+      HICN_ERROR ("Ignored ACK for non-existing FIB entry %U. Ignored.",
+		  format_ip_prefix, &prefix);
       return true;
     }
 
@@ -80,7 +82,7 @@ hicn_mapme_process_ack (vlib_main_t *vm, vlib_buffer_t *b,
 
   if (tfib == NULL)
     {
-      WARN ("Unable to get strategy ctx.");
+      HICN_ERROR ("Unable to get strategy ctx.");
       return false;
     }
 
@@ -92,7 +94,7 @@ hicn_mapme_process_ack (vlib_main_t *vm, vlib_buffer_t *b,
    */
   if (params.seq < fib_seq)
     {
-      DEBUG ("Ignored ACK for low seq");
+      HICN_ERROR ("MAPME: Ignored ACK for low seq");
       return true;
     }
 
diff --git a/hicn-plugin/src/mapme_ctrl.h b/hicn-plugin/src/mapme_ctrl.h
index a40a969b0..76382c6d2 100644
--- a/hicn-plugin/src/mapme_ctrl.h
+++ b/hicn-plugin/src/mapme_ctrl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,7 +14,7 @@
  */
 
 /*
- * Copyright (c) 2017-2019 by Cisco Systems Inc. All Rights Reserved.
+ * Copyright (c) 2021 by Cisco Systems Inc. All Rights Reserved.
  *
  */
 
diff --git a/hicn-plugin/src/mapme_ctrl_node.c b/hicn-plugin/src/mapme_ctrl_node.c
index 613958d9c..5314c49a0 100644
--- a/hicn-plugin/src/mapme_ctrl_node.c
+++ b/hicn-plugin/src/mapme_ctrl_node.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -18,6 +18,7 @@
  */
 #include <vnet/ip/ip6_packet.h>
 #include <vnet/dpo/load_balance.h>
+#include <vlib/log.h>
 
 #include "hicn.h"
 #include "mapme.h"
@@ -30,6 +31,7 @@
 #include "strategy_dpo_ctx.h"
 #include "error.h"
 #include "state.h"
+#include "route.h"
 
 extern hicn_mapme_main_t mapme_main;
 
@@ -47,6 +49,110 @@ static char *hicn_mapme_ctrl_error_strings[] = {
 #undef _
 };
 
+static_always_inline int
+hicn_mapme_nh_set (hicn_mapme_tfib_t *tfib, hicn_face_id_t face_id)
+{
+  hicn_dpo_ctx_t *strategy_ctx = (hicn_dpo_ctx_t *) tfib;
+  const fib_prefix_t *prefix =
+    fib_entry_get_prefix (strategy_ctx->fib_entry_index);
+
+  int ret = 0;
+
+  if ((tfib->entry_count == 1) && (tfib->next_hops[0] == face_id))
+    return ret;
+
+  u32 n_entries = tfib->entry_count;
+  /* Remove all the existing next hops and set the new one */
+  for (int i = 0; i < n_entries; i++)
+    {
+      hicn_face_t *face = hicn_dpoi_get_from_idx (strategy_ctx->next_hops[0]);
+      if (dpo_is_adj (&face->dpo))
+	{
+	  ip_adjacency_t *adj = adj_get (face->dpo.dpoi_index);
+	  ip_nh_adj_add_del_helper (prefix->fp_proto, prefix,
+				    &adj->sub_type.nbr.next_hop, face->sw_if,
+				    0);
+	}
+      else if (face->dpo.dpoi_type == dpo_type_udp_ip4 ||
+	       face->dpo.dpoi_type == dpo_type_udp_ip6)
+	{
+	  ip_nh_udp_tunnel_add_del_helper (prefix->fp_proto, prefix,
+					   face->dpo.dpoi_index,
+					   face->dpo.dpoi_proto, 0);
+	}
+      else
+	{
+	  continue;
+	}
+    }
+
+  ret = HICN_ERROR_MAPME_NEXT_HOP_ADDED;
+  hicn_face_t *face = hicn_dpoi_get_from_idx (face_id);
+  if (face->dpo.dpoi_type == dpo_type_udp_ip4 ||
+      face->dpo.dpoi_type == dpo_type_udp_ip6)
+    {
+      ip_nh_udp_tunnel_add_del_helper (prefix->fp_proto, prefix,
+				       face->dpo.dpoi_index,
+				       face->dpo.dpoi_proto, 1);
+    }
+  else if (dpo_is_adj (&face->dpo))
+    {
+      ip_nh_adj_add_del_helper (prefix->fp_proto, prefix, &face->nat_addr,
+				face->sw_if, 1);
+    }
+  else
+    {
+      ret = HICN_ERROR_MAPME_NEXT_HOP_NOT_ADDED;
+    }
+
+  return ret;
+}
+
+/**
+ * @brief Check whether a face is already included in the FIB nexthops.
+ *
+ * NOTE: linear scan on a contiguous small array should be the most efficient.
+ */
+static_always_inline int
+hicn_mapme_nh_has (hicn_mapme_tfib_t *tfib, hicn_face_id_t face_id)
+{
+  for (u8 pos = 0; pos < tfib->entry_count; pos++)
+    if (tfib->next_hops[pos] == face_id)
+      return 1;
+  return 0;
+}
+
+/**
+ * @brief Add a next hop iif it is not already a next hops
+ */
+static_always_inline int
+hicn_mapme_nh_add (hicn_mapme_tfib_t *tfib, hicn_face_id_t face_id)
+{
+  if (hicn_mapme_nh_has (tfib, face_id))
+    return 0;
+
+  /* Add the next hop in the vrf 0 which will add it to the entry in the hICN
+   * vrf */
+  hicn_dpo_ctx_t *strategy_ctx = (hicn_dpo_ctx_t *) tfib;
+  const fib_prefix_t *prefix =
+    fib_entry_get_prefix (strategy_ctx->fib_entry_index);
+  hicn_face_t *face = hicn_dpoi_get_from_idx (face_id);
+  if (face->dpo.dpoi_type == dpo_type_udp_ip4 ||
+      face->dpo.dpoi_type == dpo_type_udp_ip6)
+    {
+      ip_nh_udp_tunnel_add_del_helper ((fib_protocol_t) face->dpo.dpoi_proto,
+				       prefix, face->dpo.dpoi_index,
+				       face->dpo.dpoi_proto, 1);
+    }
+  else
+    {
+      ip_nh_adj_add_del_helper ((fib_protocol_t) face->dpo.dpoi_proto, prefix,
+				&face->nat_addr, face->sw_if, 1);
+    }
+
+  return 0;
+}
+
 /*
  * @brief Process incoming control messages (Interest Update)
  * @param vm vlib main data structure
@@ -97,7 +203,7 @@ hicn_mapme_process_ctrl (vlib_main_t *vm, vlib_buffer_t *b,
        * Destroying the face has led to removing all corresponding FIB
        * entries. In that case, we need to correctly restore the FIB entries.
        */
-      DEBUG ("Re-creating FIB entry with next hop on connection")
+      HICN_DEBUG ("Re-creating FIB entry with next hop on connection")
 #error "not implemented"
 #else
       // ERROR("Received IU for non-existing FIB entry");
@@ -109,7 +215,7 @@ hicn_mapme_process_ctrl (vlib_main_t *vm, vlib_buffer_t *b,
   if (!dpo_is_hicn ((dpo)))
     {
       /* We have an IP DPO */
-      WARN ("Not implemented yet.");
+      HICN_ERROR ("Not implemented yet.");
       return false;
     }
 #endif
@@ -119,7 +225,7 @@ hicn_mapme_process_ctrl (vlib_main_t *vm, vlib_buffer_t *b,
 
   if (tfib == NULL)
     {
-      WARN ("Unable to get strategy ctx.");
+      HICN_ERROR ("Unable to get strategy ctx.");
       return false;
     }
 
@@ -127,7 +233,7 @@ hicn_mapme_process_ctrl (vlib_main_t *vm, vlib_buffer_t *b,
 
   if (params.seq > fib_seq)
     {
-      DEBUG (
+      HICN_DEBUG (
 	"Higher sequence number than FIB %d > %d, updating seq and next hops",
 	params.seq, fib_seq);
 
@@ -139,25 +245,29 @@ hicn_mapme_process_ctrl (vlib_main_t *vm, vlib_buffer_t *b,
       /* Remove ingress face from TFIB in case it was present */
       hicn_mapme_tfib_del (tfib, in_face_id);
 
+      HICN_DEBUG ("Locks on face %d: %d", in_face_id,
+		  hicn_dpoi_get_from_idx (in_face_id)->locks);
+
       /* Move next hops to TFIB... but in_face... */
       for (u8 pos = 0; pos < tfib->entry_count; pos++)
 	{
-	  hicn_face_t *face = hicn_dpoi_get_from_idx (tfib->next_hops[pos]);
-	  hicn_face_t *in_face = hicn_dpoi_get_from_idx (in_face_id);
-	  if (dpo_is_adj (&face->dpo))
-	    {
-	      ip_adjacency_t *adj = adj_get (dpo->dpoi_index);
-	      if (ip46_address_cmp (&(adj->sub_type.nbr.next_hop),
-				    &(in_face->nat_addr)) == 0)
-		break;
-	    }
-	  DEBUG ("Adding nexthop to the tfib, dpo index in_face %d, dpo index "
-		 "tfib %d",
-		 in_face_id, tfib->next_hops[pos]);
+	  if (tfib->next_hops[pos] == in_face_id)
+	    continue;
+	  HICN_DEBUG (
+	    "Adding nexthop to the tfib, dpo index in_face %d, dpo index "
+	    "tfib %d",
+	    in_face_id, tfib->next_hops[pos]);
 	  hicn_mapme_tfib_add (tfib, tfib->next_hops[pos]);
 	}
 
-      hicn_mapme_nh_set (tfib, in_face_id);
+      int ret = hicn_mapme_nh_set (tfib, in_face_id);
+      HICN_DEBUG ("Locks on face %d: %d", in_face_id,
+		  hicn_dpoi_get_from_idx (in_face_id)->locks);
+      if (ret == HICN_ERROR_MAPME_NEXT_HOP_ADDED &&
+	  hicn_get_buffer (b)->flags & HICN_BUFFER_FLAGS_NEW_FACE)
+	{
+	  hicn_face_unlock_with_id (in_face_id);
+	}
 
       /* We transmit both the prefix and the full dpo (type will be needed to
        * pick the right transmit node */
@@ -168,15 +278,22 @@ hicn_mapme_process_ctrl (vlib_main_t *vm, vlib_buffer_t *b,
     }
   else if (params.seq == fib_seq)
     {
-      DEBUG ("Same sequence number than FIB %d > %d, adding next hop",
-	     params.seq, fib_seq);
+      HICN_DEBUG ("Same sequence number than FIB %d > %d, adding next hop",
+		  params.seq, fib_seq);
 
-      /* Remove ingress face from TFIB in case it was present */
-      hicn_mapme_tfib_del (tfib, in_face_id);
+      /**
+       * Add nh BEFORE removing the face from the tfib, as if the last lock is
+       * held by the tfib, deleting it first would also delete the face,
+       * resulting in a undefined behavior after (Debug mode -> SIGABRT,
+       * Release Mode -> Corrupted memory / SIGSEGV).
+       **/
 
       /* Add ingress face to next hops */
       hicn_mapme_nh_add (tfib, in_face_id);
 
+      /* Remove ingress face from TFIB in case it was present */
+      hicn_mapme_tfib_del (tfib, in_face_id);
+
       /* Multipath, multihoming, multiple producers or duplicate interest */
       retx_t *retx = vlib_process_signal_event_data (
 	vm, hicn_mapme_eventmgr_process_node.index,
@@ -187,8 +304,17 @@ hicn_mapme_process_ctrl (vlib_main_t *vm, vlib_buffer_t *b,
     {
       /*
        * face is propagating outdated information, we can just consider it as a
-       * prevHops
+       * prevHops, unless it is the current nexthop.
        */
+      if (hicn_mapme_nh_has (tfib, in_face_id))
+	{
+	  HICN_DEBUG ("Ignored seq %d < fib_seq %d from current nexthop",
+		      params.seq, fib_seq);
+	  return true;
+	}
+      HICN_DEBUG ("Received seq %d < fib_seq %d, sending backwards",
+		  params.seq, fib_seq);
+
       hicn_mapme_tfib_add (tfib, in_face_id);
 
       retx_t *retx = vlib_process_signal_event_data (
diff --git a/hicn-plugin/src/mapme_eventmgr.c b/hicn-plugin/src/mapme_eventmgr.c
index 49a9b5c57..c7ae4ecd7 100644
--- a/hicn-plugin/src/mapme_eventmgr.c
+++ b/hicn-plugin/src/mapme_eventmgr.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -24,6 +24,11 @@
 
 #define DEFAULT_TIMEOUT 1.0 /* s */
 
+/**
+ * @brief This is a process node reacting to face events.
+ */
+vlib_node_registration_t hicn_mapme_eventmgr_process_node;
+
 hicn_mapme_main_t mapme_main;
 
 hicn_prefix_t *retx_pool;
@@ -33,7 +38,6 @@ void
 hicn_mapme_init (vlib_main_t *vm)
 {
   mapme_main.vm = vm;
-  mapme_main.log_class = vlib_log_register_class ("hicn_mapme", 0);
 }
 
 /* borrowed from vnet/fib/ip4_fib.c */
@@ -77,7 +81,6 @@ hicn_mapme_process_fib_entry (vlib_main_t *vm, hicn_face_id_t face,
   const dpo_id_t *load_balance_dpo_id;
   load_balance_t *lb;
   dpo_id_t *dpo_id;
-  fib_entry_t *fib_entry;
 
   load_balance_dpo_id = fib_entry_contribute_ip_forwarding (*fib_entry_index);
 
@@ -92,12 +95,14 @@ hicn_mapme_process_fib_entry (vlib_main_t *vm, hicn_face_id_t face,
     {
       /* un-const */
       dpo_id = (dpo_id_t *) load_balance_get_bucket_i (lb, i);
-
       if (dpo_is_hicn (dpo_id))
 	{
+#ifdef HICN_DDEBUG
+	  fib_entry_t *fib_entry;
 	  fib_entry = fib_entry_get (*fib_entry_index);
-	  vlib_cli_output (vm, "set face pending %U", format_fib_prefix,
-			   &fib_entry->fe_prefix);
+	  HICN_DEBUG ("set face pending %U", format_fib_prefix,
+		      &fib_entry->fe_prefix);
+#endif
 	}
     }
 }
@@ -107,16 +112,10 @@ hicn_mapme_process_ip4_fib (vlib_main_t *vm, hicn_face_id_t face)
 {
   ip4_main_t *im4 = &ip4_main;
   fib_table_t *fib_table;
-  int table_id = -1, fib_index = ~0;
 
   pool_foreach (fib_table, im4->fibs)
     {
-      ip4_fib_t *fib = pool_elt_at_index (im4->v4_fibs, fib_table->ft_index);
-
-      if (table_id >= 0 && table_id != (int) fib->table_id)
-	continue;
-      if (fib_index != ~0 && fib_index != (int) fib->index)
-	continue;
+      ip4_fib_t *fib = pool_elt_at_index (ip4_fibs, fib_table->ft_index);
 
       fib_node_index_t *fib_entry_index;
       ip4_fib_show_walk_ctx_t ctx = {
@@ -241,8 +240,8 @@ hicn_mapme_send_message (vlib_main_t *vm, const hicn_prefix_t *prefix,
   size_t n;
 
   /* This should be retrieved from face information */
-  DEBUG ("Retransmission for prefix %U seq=%d", format_ip46_address,
-	 &prefix->name, IP46_TYPE_ANY, params->seq);
+  HICN_DEBUG ("Retransmission for prefix %U seq=%d", format_ip46_address,
+	      &prefix->name, IP46_TYPE_ANY, params->seq);
 
   char *node_name = hicn_mapme_get_dpo_face_node (face);
   if (!node_name)
@@ -257,7 +256,7 @@ hicn_mapme_send_message (vlib_main_t *vm, const hicn_prefix_t *prefix,
   u8 *buffer = get_packet_buffer (
     vm, node_index, face, (ip46_address_t *) prefix,
     (params->protocol == IPPROTO_IPV6) ? HICN_TYPE_IPV6_ICMP :
-					 HICN_TYPE_IPV4_ICMP);
+					       HICN_TYPE_IPV4_ICMP);
   n = hicn_mapme_create_packet (buffer, prefix, params);
   if (n <= 0)
     {
@@ -275,7 +274,7 @@ hicn_mapme_send_updates (vlib_main_t *vm, hicn_prefix_t *prefix, dpo_id_t dpo,
   hicn_mapme_tfib_t *tfib = TFIB (hicn_strategy_dpo_ctx_get (dpo.dpoi_index));
   if (!tfib)
     {
-      DEBUG ("NULL TFIB entry id=%d", dpo.dpoi_index);
+      HICN_ERROR ("NULL TFIB entry id=%d", dpo.dpoi_index);
       return;
     }
 
@@ -337,7 +336,7 @@ hicn_mapme_eventmgr_process (vlib_main_t *vm, vlib_node_runtime_t *rt,
 	   * Also, we only run a timer when there are pending retransmissions.
 	   */
 	  timeout = (due_time > current_time) ? due_time - current_time :
-						DEFAULT_TIMEOUT;
+						      DEFAULT_TIMEOUT;
 	  due_time = current_time + timeout;
 	}
       else
@@ -493,8 +492,8 @@ hicn_mapme_eventmgr_process (vlib_main_t *vm, vlib_node_runtime_t *rt,
 		TFIB (hicn_strategy_dpo_ctx_get (retx->dpo.dpoi_index));
 	      if (!tfib)
 		{
-		  DEBUG ("NULL TFIB entry for dpoi_index=%d",
-			 retx->dpo.dpoi_index);
+		  HICN_ERROR ("NULL TFIB entry for dpoi_index=%d",
+			      retx->dpo.dpoi_index);
 		  continue;
 		}
 
diff --git a/hicn-plugin/src/mapme_eventmgr.h b/hicn-plugin/src/mapme_eventmgr.h
index 2100a6f90..559ba2e75 100644
--- a/hicn-plugin/src/mapme_eventmgr.h
+++ b/hicn-plugin/src/mapme_eventmgr.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -39,8 +39,7 @@ typedef struct
 /**
  * @brief This is a process node reacting to face events.
  */
-// not static !
-vlib_node_registration_t hicn_mapme_eventmgr_process_node;
+extern vlib_node_registration_t hicn_mapme_eventmgr_process_node;
 
 /**
  * @brief Initialize MAP-Me on forwarder
diff --git a/hicn-plugin/src/mgmt.c b/hicn-plugin/src/mgmt.c
index b820a378f..6e9ce9fd8 100644
--- a/hicn-plugin/src/mgmt.c
+++ b/hicn-plugin/src/mgmt.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,7 +21,7 @@
 #include "mgmt.h"
 
 /* define message IDs */
-#include "hicn_msg_enum.h"
+#include <vpp_plugins/hicn/hicn_msg_enum.h>
 
 /* shared routine betweeen API and CLI, leveraging API message structure */
 int
@@ -46,7 +46,8 @@ hicn_mgmt_node_stats_get (vl_api_hicn_api_node_stats_get_reply_t *rmp)
 
   vlib_error_main_t *em;
   vlib_node_t *n;
-  foreach_vlib_main() {
+  foreach_vlib_main ()
+  {
     em = &this_vlib_main->error_main;
     n = vlib_get_node (this_vlib_main, hicn_interest_pcslookup_node.index);
     u32 node_cntr_base_idx = n->error_heap_index;
diff --git a/hicn-plugin/src/mgmt.h b/hicn-plugin/src/mgmt.h
index 8eaa18fa8..03e73999f 100644
--- a/hicn-plugin/src/mgmt.h
+++ b/hicn-plugin/src/mgmt.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -18,7 +18,7 @@
 
 #include <vppinfra/error.h>
 #include "faces/face.h"
-#include "hicn_api.h"
+#include <vpp_plugins/hicn/hicn_api.h>
 
 /**
  * @file mgmt.h
diff --git a/hicn-plugin/src/params.h b/hicn-plugin/src/params.h
index 7c7850d30..324429abe 100644
--- a/hicn-plugin/src/params.h
+++ b/hicn-plugin/src/params.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -60,9 +60,9 @@ STATIC_ASSERT ((HICN_PARAM_FACES_MAX & (HICN_PARAM_FACES_MAX - 1)) == 0,
 // HICN_PARAM_PIT_ENTRY_PHOPS_MAX - 4 must be a power of two
 #define HICN_PARAM_PIT_ENTRY_PHOPS_MAX 20
 
-STATIC_ASSERT ((ceil (log2 ((HICN_PARAM_PIT_ENTRY_PHOPS_MAX - 4)))) ==
-		 (floor (log2 ((HICN_PARAM_PIT_ENTRY_PHOPS_MAX - 4)))),
-	       "HICN_PARAM_PIT_ENTRY_PHOPS_MAX - 4 must be a power of two");
+// STATIC_ASSERT ((ceil (log2 ((HICN_PARAM_PIT_ENTRY_PHOPS_MAX - 4)))) ==
+// 		 (floor (log2 ((HICN_PARAM_PIT_ENTRY_PHOPS_MAX - 4)))),
+// 	       "HICN_PARAM_PIT_ENTRY_PHOPS_MAX - 4 must be a power of two");
 
 STATIC_ASSERT (
   (HICN_PARAM_PIT_ENTRY_PHOPS_MAX <= HICN_PARAM_FACES_MAX),
@@ -113,7 +113,7 @@ STATIC_ASSERT (
 #define IPV6_DEFAULT_VERSION	   6
 #define IPV6_DEFAULT_TRAFFIC_CLASS 0
 #define IPV6_DEFAULT_FLOW_LABEL	   0
-#define HCIN_IP6_VERSION_TRAFFIC_FLOW                                         \
+#define HICN_IP6_VERSION_TRAFFIC_FLOW                                         \
   (IPV6_DEFAULT_VERSION << 28) | (IPV6_DEFAULT_TRAFFIC_CLASS << 20) |         \
     (IPV6_DEFAULT_FLOW_LABEL & 0xfffff)
 #define HICN_IP6_PROTOCOL  IP_PROTOCOL_TCP
diff --git a/hicn-plugin/src/parser.h b/hicn-plugin/src/parser.h
index 5c75ce3bd..0e60c526f 100644
--- a/hicn-plugin/src/parser.h
+++ b/hicn-plugin/src/parser.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -59,10 +59,13 @@ hicn_interest_parse_pkt (vlib_buffer_t *pkt, hicn_name_t *name, u16 *namelen,
   u8 next_proto_offset = 6 + (1 - *isv6) * 3;
   // in the ipv6 header the next header field is at byte 6
   // in the ipv4 header the protocol field is at byte 9
-  hicn_type_t type = (hicn_type_t){ { .l4 = IPPROTO_NONE,
-				      .l3 = IPPROTO_NONE,
-				      .l2 = ip_pkt[next_proto_offset],
-				      .l1 = ip_proto } };
+  hicn_type_t type =
+    (hicn_type_t){ { .l4 = IPPROTO_NONE,
+		     .l3 = ip_pkt[next_proto_offset] == IPPROTO_UDP ?
+				   IPPROTO_ENCAP :
+				   IPPROTO_NONE,
+		     .l2 = ip_pkt[next_proto_offset],
+		     .l1 = ip_proto } };
   hicn_get_buffer (pkt)->type = type;
 
   hicn_ops_vft[type.l1]->get_interest_name (type, &pkt_hdr->protocol, name);
@@ -97,10 +100,13 @@ hicn_data_parse_pkt (vlib_buffer_t *pkt, hicn_name_t *name, u16 *namelen,
    * header the protocol field is at byte 9
    */
   u8 next_proto_offset = 6 + (1 - *isv6) * 3;
-  hicn_type_t type = (hicn_type_t){ { .l4 = IPPROTO_NONE,
-				      .l3 = IPPROTO_NONE,
-				      .l2 = ip_pkt[next_proto_offset],
-				      .l1 = ip_proto } };
+  hicn_type_t type =
+    (hicn_type_t){ { .l4 = IPPROTO_NONE,
+		     .l3 = ip_pkt[next_proto_offset] == IPPROTO_UDP ?
+				   IPPROTO_ENCAP :
+				   IPPROTO_NONE,
+		     .l2 = ip_pkt[next_proto_offset],
+		     .l1 = ip_proto } };
   hicn_get_buffer (pkt)->type = type;
   hicn_ops_vft[type.l1]->get_data_name (type, &pkt_hdr->protocol, name);
   *namelen = (1 - (*isv6)) * HICN_V4_NAME_LEN + (*isv6) * HICN_V6_NAME_LEN;
diff --git a/hicn-plugin/src/pcs.c b/hicn-plugin/src/pcs.c
index d9e0baf6f..d6e4fd954 100644
--- a/hicn-plugin/src/pcs.c
+++ b/hicn-plugin/src/pcs.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/pcs.h b/hicn-plugin/src/pcs.h
index 083efa901..b98b72a53 100644
--- a/hicn-plugin/src/pcs.h
+++ b/hicn-plugin/src/pcs.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -91,7 +91,7 @@ typedef struct __attribute__ ((packed)) hicn_pit_entry_s
 
 } hicn_pit_entry_t;
 
-#define HICN_CS_ENTRY_OPAQUE_SIZE HICN_HASH_NODE_APP_DATA_SIZE - 36
+#define HICN_CS_ENTRY_OPAQUE_SIZE HICN_HASH_NODE_APP_DATA_SIZE - 32
 
 /*
  * CS entry, unioned with a PIT entry below
@@ -105,17 +105,17 @@ typedef struct __attribute__ ((packed)) hicn_cs_entry_s
   /* 20B + 4B = 24B */
   u32 cs_pkt_buf;
 
-  /* Ingress face */
-  /* 24B + 4B = 28B */
-  hicn_face_id_t cs_rxface;
+  //   /* Ingress face */
+  //   /* 24B + 4B = 28B */
+  //   hicn_face_id_t cs_rxface;
 
   /* Linkage for LRU, in the form of hashtable node indexes */
-  /* 28B + 8B = 36B */
+  /* 24B + 8B = 32B */
   u32 cs_lru_prev;
   u32 cs_lru_next;
 
   /* Reserved for implementing cache policy different than LRU */
-  /* 36B + (64 - 36)B = 64B */
+  /* 32B + (64 - 32)B = 64B */
   u8 opaque[HICN_CS_ENTRY_OPAQUE_SIZE];
 
 } __attribute__ ((packed)) hicn_cs_entry_t;
@@ -167,8 +167,7 @@ always_inline void hicn_pit_to_cs (vlib_main_t *vm, hicn_pit_cs_t *pitcs,
 				   hicn_hash_entry_t *hash_entry,
 				   hicn_hash_node_t *node,
 				   const hicn_dpo_vft_t *dpo_vft,
-				   dpo_id_t *hicn_dpo_id,
-				   hicn_face_id_t inface_id, u8 is_appface);
+				   dpo_id_t *hicn_dpo_id);
 
 always_inline void hicn_pcs_cs_update (vlib_main_t *vm, hicn_pit_cs_t *pitcs,
 				       hicn_pcs_entry_t *old_entry,
@@ -193,7 +192,7 @@ always_inline int hicn_pcs_cs_insert_update (
   vlib_main_t *vm, hicn_pit_cs_t *pitcs, hicn_pcs_entry_t *entry,
   hicn_hash_node_t *node, hicn_hash_entry_t **hash_entry, u64 hashval,
   u32 *node_id, index_t *dpo_ctx_id, u8 *vft_id, u8 *is_cs, u8 *hash_entry_id,
-  u32 *bucket_id, u8 *bucket_is_overflow, hicn_face_id_t inface);
+  u32 *bucket_id, u8 *bucket_is_overflow);
 
 always_inline int
 hicn_pcs_pit_insert (hicn_pit_cs_t *pitcs, hicn_pcs_entry_t *entry,
@@ -352,7 +351,6 @@ hicn_pcs_delete_internal (hicn_pit_cs_t *pitcs, hicn_pcs_entry_t **pcs_entryp,
   else
     {
       pitcs->pcs_pit_dealloc++;
-      hicn_strategy_dpo_ctx_unlock (hicn_dpo_id);
 
       /* Flush faces */
       hicn_faces_flush (&(pcs->u.pit.faces));
@@ -370,7 +368,7 @@ always_inline void
 hicn_pit_to_cs (vlib_main_t *vm, hicn_pit_cs_t *pitcs,
 		hicn_pcs_entry_t *pcs_entry, hicn_hash_entry_t *hash_entry,
 		hicn_hash_node_t *node, const hicn_dpo_vft_t *dpo_vft,
-		dpo_id_t *hicn_dpo_id, hicn_face_id_t inface_id, u8 is_appface)
+		dpo_id_t *hicn_dpo_id)
 {
 
   /*
@@ -378,7 +376,6 @@ hicn_pit_to_cs (vlib_main_t *vm, hicn_pit_cs_t *pitcs,
    * hash entry.
    */
   pitcs->pcs_pit_count--;
-  hicn_strategy_dpo_ctx_unlock (hicn_dpo_id);
   /* Flush faces */
   hicn_faces_flush (&(pcs_entry->u.pit.faces));
 
@@ -386,8 +383,6 @@ hicn_pit_to_cs (vlib_main_t *vm, hicn_pit_cs_t *pitcs,
   node->hn_flags |= HICN_HASH_NODE_CS_FLAGS;
   pcs_entry->shared.entry_flags |= HICN_PCS_ENTRY_CS_FLAG;
 
-  pcs_entry->u.cs.cs_rxface = inface_id;
-
   /* Update the CS according to the policy */
   hicn_cs_policy_t *policy_state;
   hicn_cs_policy_vft_t *policy_vft;
@@ -432,40 +427,8 @@ hicn_pcs_cs_update (vlib_main_t *vm, hicn_pit_cs_t *pitcs,
   policy_state = &pitcs->policy_state;
   policy_vft = &pitcs->policy_vft;
 
-  if (entry->u.cs.cs_rxface != old_entry->u.cs.cs_rxface)
-    {
-      /* Dequeue content from the old queue */
-      policy_vft->hicn_cs_dequeue (pitcs, node, old_entry, policy_state);
-
-      old_entry->u.cs.cs_rxface = entry->u.cs.cs_rxface;
-      policy_state = &pitcs->policy_state;
-      policy_vft = &pitcs->policy_vft;
-
-      policy_vft->hicn_cs_insert (pitcs, node, old_entry, policy_state);
-
-      if (policy_state->count > policy_state->max)
-	{
-	  hicn_hash_node_t *node;
-	  hicn_pcs_entry_t *pcs_entry;
-	  hicn_hash_entry_t *hash_entry;
-	  policy_vft->hicn_cs_delete_get (pitcs, policy_state, &node,
-					  &pcs_entry, &hash_entry);
-
-	  /*
-	   * We don't have to decrease the lock (therefore we cannot
-	   * use hicn_pcs_cs_delete function)
-	   */
-	  policy_vft->hicn_cs_dequeue (pitcs, node, pcs_entry, policy_state);
-
-	  hicn_cs_delete_trimmed (pitcs, &pcs_entry, hash_entry, &node, vm);
-
-	  /* Update the global CS counter */
-	  pitcs->pcs_cs_count--;
-	}
-    }
-  else
-    /* Update the CS LRU, moving this item to the head */
-    policy_vft->hicn_cs_update (pitcs, node, old_entry, policy_state);
+  /* Update the CS LRU, moving this item to the head */
+  policy_vft->hicn_cs_update (pitcs, node, old_entry, policy_state);
 }
 
 always_inline void
@@ -565,13 +528,12 @@ hicn_pcs_cs_insert_update (vlib_main_t *vm, hicn_pit_cs_t *pitcs,
 			   hicn_hash_entry_t **hash_entry, u64 hashval,
 			   u32 *node_id, index_t *dpo_ctx_id, u8 *vft_id,
 			   u8 *is_cs, u8 *hash_entry_id, u32 *bucket_id,
-			   u8 *bucket_is_overflow, hicn_face_id_t inface)
+			   u8 *bucket_is_overflow)
 {
   int ret;
 
   ASSERT (entry == hicn_hashtb_node_data (node));
 
-  entry->u.cs.cs_rxface = inface;
   ret = hicn_pcs_cs_insert (vm, pitcs, entry, node, hash_entry, hashval,
 			    node_id, dpo_ctx_id, vft_id, is_cs, hash_entry_id,
 			    bucket_id, bucket_is_overflow);
diff --git a/hicn-plugin/src/pg.c b/hicn-plugin/src/pg.c
index 2f98e9c16..b77e8fcac 100644
--- a/hicn-plugin/src/pg.c
+++ b/hicn-plugin/src/pg.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -203,11 +203,11 @@ hicnpg_client_interest_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	      iface = (hpgm->index_ifaces % hpgm->n_ifaces);
 	      /* Rewrite and send */
 	      isv6_0 ?
-		hicn_rewrite_interestv6 (
+		      hicn_rewrite_interestv6 (
 		  vm, b0, (hpgm->index / hpgm->n_flows) % hpgm->max_seq_number,
 		  hpgm->interest_lifetime, hpgm->index % hpgm->n_flows,
 		  iface) :
-		hicn_rewrite_interestv4 (
+		      hicn_rewrite_interestv4 (
 		  vm, b0, (hpgm->index / hpgm->n_flows) % hpgm->max_seq_number,
 		  hpgm->interest_lifetime, hpgm->index % hpgm->n_flows, iface);
 
@@ -216,7 +216,7 @@ hicnpg_client_interest_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 		hpgm->index++;
 
 	      next0 = isv6_0 ? HICNPG_INTEREST_NEXT_V6_LOOKUP :
-			       HICNPG_INTEREST_NEXT_V4_LOOKUP;
+				     HICNPG_INTEREST_NEXT_V4_LOOKUP;
 	    }
 	  if (hicn_interest_parse_pkt (b1, &name1, &namelen1, &hicn1,
 				       &isv6_1) == HICN_ERROR_NONE)
@@ -229,11 +229,11 @@ hicnpg_client_interest_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	      iface = (hpgm->index_ifaces % hpgm->n_ifaces);
 	      /* Rewrite and send */
 	      isv6_1 ?
-		hicn_rewrite_interestv6 (
+		      hicn_rewrite_interestv6 (
 		  vm, b1, (hpgm->index / hpgm->n_flows) % hpgm->max_seq_number,
 		  hpgm->interest_lifetime, hpgm->index % hpgm->n_flows,
 		  iface) :
-		hicn_rewrite_interestv4 (
+		      hicn_rewrite_interestv4 (
 		  vm, b1, (hpgm->index / hpgm->n_flows) % hpgm->max_seq_number,
 		  hpgm->interest_lifetime, hpgm->index % hpgm->n_flows, iface);
 
@@ -242,7 +242,7 @@ hicnpg_client_interest_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 		hpgm->index++;
 
 	      next1 = isv6_1 ? HICNPG_INTEREST_NEXT_V6_LOOKUP :
-			       HICNPG_INTEREST_NEXT_V4_LOOKUP;
+				     HICNPG_INTEREST_NEXT_V4_LOOKUP;
 	    }
 	  /* Send pkt to next node */
 	  vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0;
@@ -320,11 +320,11 @@ hicnpg_client_interest_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 
 	      /* Rewrite and send */
 	      isv6_0 ?
-		hicn_rewrite_interestv6 (
+		      hicn_rewrite_interestv6 (
 		  vm, b0, (hpgm->index / hpgm->n_flows) % hpgm->max_seq_number,
 		  hpgm->interest_lifetime, hpgm->index % hpgm->n_flows,
 		  iface) :
-		hicn_rewrite_interestv4 (
+		      hicn_rewrite_interestv4 (
 		  vm, b0, (hpgm->index / hpgm->n_flows) % hpgm->max_seq_number,
 		  hpgm->interest_lifetime, hpgm->index % hpgm->n_flows, iface);
 
@@ -333,7 +333,7 @@ hicnpg_client_interest_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 		hpgm->index++;
 
 	      next0 = isv6_0 ? HICNPG_INTEREST_NEXT_V6_LOOKUP :
-			       HICNPG_INTEREST_NEXT_V4_LOOKUP;
+				     HICNPG_INTEREST_NEXT_V4_LOOKUP;
 	    }
 	  /* Send pkt to ip lookup */
 	  vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0;
@@ -386,12 +386,12 @@ hicn_rewrite_interestv4 (vlib_main_t *vm, vlib_buffer_t *b0, u32 seq_number,
     .ip4 = hicnpg_main.pgen_clt_src_addr.ip4,
   };
   hicn_name_t dst_name = {
-    .ip4.prefix_as_ip4 = hicnpg_main.pgen_clt_hicn_name->fp_addr.ip4,
-    .ip4.suffix = seq_number,
+    .prefix.ip4 = hicnpg_main.pgen_clt_hicn_name->fp_addr.ip4,
+    .suffix = seq_number,
   };
 
   src_addr.ip4.as_u32 += clib_host_to_net_u32 (iface);
-  dst_name.ip4.prefix_as_ip4.as_u32 += clib_net_to_host_u32 (next_flow);
+  dst_name.prefix.ip4.as_u32 += clib_net_to_host_u32 (next_flow);
 
   /* Update locator and name */
   hicn_type_t type = hicn_get_buffer (b0)->type;
@@ -432,11 +432,11 @@ hicn_rewrite_interestv6 (vlib_main_t *vm, vlib_buffer_t *b0, u32 seq_number,
     .ip6 = hicnpg_main.pgen_clt_src_addr.ip6,
   };
   hicn_name_t dst_name = {
-    .ip6.prefix_as_ip6 = hicnpg_main.pgen_clt_hicn_name->fp_addr.ip6,
-    .ip6.suffix = seq_number,
+    .prefix.ip6 = hicnpg_main.pgen_clt_hicn_name->fp_addr.ip6,
+    .suffix = seq_number,
   };
   src_addr.ip6.as_u32[3] += clib_host_to_net_u32 (iface);
-  dst_name.ip6.prefix_as_ip6.as_u32[3] += clib_net_to_host_u32 (next_flow);
+  dst_name.prefix.ip6.as_u32[3] += clib_net_to_host_u32 (next_flow);
 
   /* Update locator and name */
   hicn_type_t type = hicn_get_buffer (b0)->type;
@@ -1011,10 +1011,10 @@ hicnpg_node_server_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	      rb = vlib_get_buffer (vm, hpgsm->pgen_svr_buffer_idx);
 
 	      isv6_0 ? convert_interest_to_data_v6 (vm, b0, rb, bi0) :
-		       convert_interest_to_data_v4 (vm, b0, rb, bi0);
+			     convert_interest_to_data_v4 (vm, b0, rb, bi0);
 
 	      next0 = isv6_0 ? HICNPG_SERVER_NEXT_V6_LOOKUP :
-			       HICNPG_SERVER_NEXT_V4_LOOKUP;
+				     HICNPG_SERVER_NEXT_V4_LOOKUP;
 	    }
 
 	  if (match1)
@@ -1029,10 +1029,10 @@ hicnpg_node_server_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	      rb = vlib_get_buffer (vm, hpgsm->pgen_svr_buffer_idx);
 
 	      isv6_1 ? convert_interest_to_data_v6 (vm, b1, rb, bi1) :
-		       convert_interest_to_data_v4 (vm, b1, rb, bi1);
+			     convert_interest_to_data_v4 (vm, b1, rb, bi1);
 
 	      next1 = isv6_1 ? HICNPG_SERVER_NEXT_V6_LOOKUP :
-			       HICNPG_SERVER_NEXT_V4_LOOKUP;
+				     HICNPG_SERVER_NEXT_V4_LOOKUP;
 	    }
 	  pkts_processed += 2;
 
@@ -1107,10 +1107,10 @@ hicnpg_node_server_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	      rb = vlib_get_buffer (vm, hpgsm->pgen_svr_buffer_idx);
 
 	      isv6_0 ? convert_interest_to_data_v6 (vm, b0, rb, bi0) :
-		       convert_interest_to_data_v4 (vm, b0, rb, bi0);
+			     convert_interest_to_data_v4 (vm, b0, rb, bi0);
 
 	      next0 = isv6_0 ? HICNPG_SERVER_NEXT_V6_LOOKUP :
-			       HICNPG_SERVER_NEXT_V4_LOOKUP;
+				     HICNPG_SERVER_NEXT_V4_LOOKUP;
 	    }
 	  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
 			     (b0->flags & VLIB_BUFFER_IS_TRACED)))
diff --git a/hicn-plugin/src/pg.h b/hicn-plugin/src/pg.h
index 059b076fb..7855248e6 100644
--- a/hicn-plugin/src/pg.h
+++ b/hicn-plugin/src/pg.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/route.c b/hicn-plugin/src/route.c
index 34a94936e..a84891b9a 100644
--- a/hicn-plugin/src/route.c
+++ b/hicn-plugin/src/route.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -33,6 +33,7 @@
 #include "strategies/dpo_mw.h"
 #include "infra.h"
 #include "udp_tunnels/udp_tunnel.h"
+#include "mapme.h"
 
 #define FIB_SOURCE_HICN 0x04 // Right after the FIB_SOURCE_INTERFACE priority
 
@@ -105,94 +106,76 @@ int
 hicn_route_set_strategy (fib_prefix_t *prefix, u8 strategy_id)
 {
   const dpo_id_t *hicn_dpo_id;
-  dpo_id_t new_dpo_id = DPO_INVALID;
   int ret;
-  hicn_dpo_ctx_t *old_hicn_dpo_ctx;
-  const hicn_dpo_vft_t *new_dpo_vft;
-  index_t new_hicn_dpo_idx;
+  hicn_dpo_ctx_t *hicn_dpo_ctx;
   u32 fib_index;
 
   ret = hicn_route_get_dpo (prefix, &hicn_dpo_id, &fib_index);
 
   if (ret == HICN_ERROR_NONE)
     {
-      old_hicn_dpo_ctx = hicn_strategy_dpo_ctx_get (hicn_dpo_id->dpoi_index);
+      hicn_dpo_ctx = hicn_strategy_dpo_ctx_get (hicn_dpo_id->dpoi_index);
+      const hicn_dpo_vft_t *dpo_vft = hicn_dpo_get_vft_from_id (strategy_id);
 
-      new_dpo_vft = hicn_dpo_get_vft_from_id (strategy_id);
-
-      if (new_dpo_vft == NULL || old_hicn_dpo_ctx == NULL)
+      if (hicn_dpo_ctx == NULL || dpo_vft == NULL)
 	return HICN_ERROR_STRATEGY_NOT_FOUND;
 
-      /* Create a new dpo for the new strategy */
-      new_dpo_vft->hicn_dpo_create (
-	hicn_dpo_id->dpoi_proto, old_hicn_dpo_ctx->next_hops,
-	old_hicn_dpo_ctx->entry_count, &new_hicn_dpo_idx);
-
-      /* the value we got when we registered */
-      dpo_set (&new_dpo_id, new_dpo_vft->hicn_dpo_get_type (),
-	       (ip46_address_is_ip4 (&prefix->fp_addr) ? DPO_PROTO_IP4 :
-							 DPO_PROTO_IP6),
-	       new_hicn_dpo_idx);
-
-      /* Here is where we create the "via" like route */
-      /*
-       * For the moment we use the global one the prefix you want
-       * to match Neale suggested -- FIB_SOURCE_HICN the client
-       * that is adding them -- no easy explanation at this time…
-       */
-      fib_node_index_t new_fib_node_index =
-	fib_table_entry_special_dpo_update (fib_index, prefix, hicn_fib_src,
-					    FIB_ENTRY_FLAG_EXCLUSIVE,
-					    &new_dpo_id);
-
-      dpo_unlock (&new_dpo_id);
-      ret = (new_fib_node_index != FIB_NODE_INDEX_INVALID) ?
-	      HICN_ERROR_NONE :
-	      HICN_ERROR_ROUTE_NOT_UPDATED;
+      dpo_vft->hicn_dpo_update_type (hicn_dpo_ctx);
     }
   // Remember to remove the lock from the table when removing the entry
   return ret;
 }
 
-int
-ip_nh_add_helper (fib_protocol_t fib_proto, const fib_prefix_t *rpfx,
-		  ip46_address_t *nh, u32 sw_if)
+static int
+ip_nh_add_del_helper (fib_protocol_t fib_proto, const fib_prefix_t *rpfx,
+		      ip46_address_t *nh, u32 sw_if, u32 udp_encap_id,
+		      dpo_proto_t proto, u8 is_add)
 {
   fib_route_path_t *rpaths = NULL, rpath;
 
   u32 fib_index = fib_table_find (fib_proto, 0);
-
   clib_memset (&rpath, 0, sizeof (rpath));
+
+  if (nh)
+    {
+      rpath.frp_addr = *nh;
+      rpath.frp_sw_if_index = sw_if;
+    }
+  else if (udp_encap_id != ~0)
+    {
+      rpath.frp_udp_encap_id = udp_encap_id;
+      rpath.frp_flags |= FIB_ROUTE_PATH_UDP_ENCAP;
+    }
+
   rpath.frp_weight = 1;
-  rpath.frp_sw_if_index = sw_if;
-  rpath.frp_addr = *nh;
-  rpath.frp_proto = ip46_address_is_ip4 (nh) ? DPO_PROTO_IP4 : DPO_PROTO_IP6;
+  rpath.frp_proto = proto;
 
   vec_add1 (rpaths, rpath);
 
-  fib_table_entry_path_add2 (fib_index, rpfx, FIB_SOURCE_CLI,
-			     FIB_ENTRY_FLAG_NONE, rpaths);
+  if (is_add)
+    fib_table_entry_path_add2 (fib_index, rpfx, FIB_SOURCE_API,
+			       FIB_ENTRY_FLAG_NONE, rpaths);
+  else
+    fib_table_entry_path_remove2 (fib_index, rpfx, FIB_SOURCE_API, rpaths);
+
   return 0;
 }
 
 int
-ip_nh_del_helper (fib_protocol_t fib_proto, const fib_prefix_t *rpfx,
-		  ip46_address_t *nh, u32 sw_if)
+ip_nh_adj_add_del_helper (fib_protocol_t fib_proto, const fib_prefix_t *rpfx,
+			  ip46_address_t *nh, u32 sw_if, u8 is_add)
 {
-  fib_route_path_t *rpaths = NULL, rpath;
-
-  u32 fib_index = fib_table_find (fib_proto, 0);
-
-  clib_memset (&rpath, 0, sizeof (rpath));
-  rpath.frp_weight = 1;
-  rpath.frp_sw_if_index = sw_if;
-  rpath.frp_addr = *nh;
-  rpath.frp_proto = ip46_address_is_ip4 (nh) ? DPO_PROTO_IP4 : DPO_PROTO_IP6;
-
-  vec_add1 (rpaths, rpath);
+  return ip_nh_add_del_helper (
+    fib_proto, rpfx, nh, sw_if, ~0,
+    ip46_address_is_ip4 (nh) ? DPO_PROTO_IP4 : DPO_PROTO_IP6, is_add);
+}
 
-  fib_table_entry_path_remove2 (fib_index, rpfx, FIB_SOURCE_CLI, rpaths);
-  return 0;
+int
+ip_nh_udp_tunnel_add_del_helper (fib_protocol_t fib_proto,
+				 const fib_prefix_t *rpfx, u32 uei,
+				 dpo_proto_t proto, u8 is_add)
+{
+  return ip_nh_add_del_helper (fib_proto, rpfx, NULL, ~0, uei, proto, is_add);
 }
 
 static ip46_address_t *
@@ -234,13 +217,14 @@ get_address (ip46_address_t *nh, u32 sw_if, fib_protocol_t proto)
 }
 
 static void
-sync_hicn_fib_entry (hicn_dpo_ctx_t *fib_entry)
+sync_hicn_fib_entry (hicn_dpo_ctx_t *fib_entry, hicn_face_id_t **pvec_faces)
 {
+  hicn_face_id_t *vec_faces = NULL;
   const dpo_id_t *dpo_loadbalance =
     fib_entry_contribute_ip_forwarding (fib_entry->fib_entry_index);
+  const fib_entry_t *_fib_entry = fib_entry_get (fib_entry->fib_entry_index);
   const load_balance_t *lb0 = load_balance_get (dpo_loadbalance->dpoi_index);
   index_t hicn_fib_entry_index = hicn_strategy_dpo_ctx_get_index (fib_entry);
-  hicn_face_id_t *vec_faces = 0;
 
   dpo_id_t temp = DPO_INVALID;
   const dpo_id_t *former_dpo = &temp;
@@ -287,32 +271,31 @@ sync_hicn_fib_entry (hicn_dpo_ctx_t *fib_entry)
 	  nh = get_address (&(adj->sub_type.nbr.next_hop), sw_if,
 			    fib_entry->proto);
 	  ADD_FACE (nh);
+	  HICN_DEBUG ("Added new HICN face: %d because of route prefix %U",
+		      face_id, format_ip_prefix, &_fib_entry->fe_prefix);
 	}
       else if (dpo->dpoi_type == dpo_type_udp_ip4 ||
 	       dpo->dpoi_type == dpo_type_udp_ip6)
 	{
-	  u8 proto = dpo->dpoi_type == dpo_type_udp_ip4 ? FIB_PROTOCOL_IP4 :
-							  FIB_PROTOCOL_IP6;
+	  dpo_proto_t proto =
+	    dpo->dpoi_type == dpo_type_udp_ip4 ? DPO_PROTO_IP4 : DPO_PROTO_IP6;
 	  ip46_address_t _nh = { 0 };
 	  nh = &_nh;
-	  switch (dpo->dpoi_proto)
+	  switch (_fib_entry->fe_prefix.fp_proto)
 	    {
 	    case FIB_PROTOCOL_IP6:
-	    case FIB_PROTOCOL_IP4:
-	      /**
-	       * Independently of the type of tunnel, encapsulated packet
-	       * can be either v6 or v4, so we need to create 2 faces for each
-	       * version. Tunneled hicn packet MUST have locator set to the
-	       * loopback address, so ::1 for IPv6 and 127.0.0.1 for IPv4.
-	       */
 	      ip46_address_set_ip6 (nh, &localhost6);
 	      ADD_FACE (nh);
+	      break;
+	    case FIB_PROTOCOL_IP4:
 	      ip46_address_set_ip4 (nh, &localhost4);
 	      ADD_FACE (nh);
 	      break;
 	    default:
 	      continue;
 	    }
+	  HICN_DEBUG ("Added new UDP face: %d because of route prefix %s",
+		      face_id, format_ip_prefix, &_fib_entry->fe_prefix);
 	  udp_tunnel_add_existing (dpo->dpoi_index, proto);
 	}
     }
@@ -345,7 +328,8 @@ sync_hicn_fib_entry (hicn_dpo_ctx_t *fib_entry)
       /* Remove the lock added by hicn_face_add */
       hicn_face_unlock_with_id (*face_id);
     }
-  vec_free (vec_faces);
+
+  *pvec_faces = vec_faces;
 }
 
 static void
@@ -380,7 +364,7 @@ disable_data_receiving_rm_fib_entry (vnet_main_t *vnm, vnet_sw_interface_t *si,
 }
 
 int
-hicn_route_enable (fib_prefix_t *prefix)
+hicn_route_enable (fib_prefix_t *prefix, hicn_face_id_t **pvec_faces)
 {
 
   int ret = HICN_ERROR_NONE;
@@ -413,10 +397,14 @@ hicn_route_enable (fib_prefix_t *prefix)
 
   if (fib_hicn_entry_index == FIB_NODE_INDEX_INVALID)
     {
+      HICN_DEBUG (
+	"No route found for %U. Creating DPO and tracking fib prefix.",
+	format_ip_prefix, prefix);
       dpo_id_t dpo = DPO_INVALID;
       index_t dpo_idx;
       default_dpo.hicn_dpo_create (prefix->fp_proto, 0, NEXT_HOP_INVALID,
 				   &dpo_idx);
+      HICN_DEBUG ("Created new DPO_MW_CTX_T: %d.", dpo_idx);
 
       /* the value we got when we registered */
       /*
@@ -425,8 +413,14 @@ hicn_route_enable (fib_prefix_t *prefix)
        */
       dpo_set (&dpo, default_dpo.hicn_dpo_get_type (),
 	       (ip46_address_is_ip4 (&prefix->fp_addr) ? DPO_PROTO_IP4 :
-							 DPO_PROTO_IP6),
+							       DPO_PROTO_IP6),
 	       dpo_idx);
+      HICN_DEBUG (
+	"dpo_set called with parameters: type=%d, proto=%s, index=%d",
+	default_dpo.hicn_dpo_get_type (),
+	ip46_address_is_ip4 (&prefix->fp_addr) ? "DPO_PROTO_IP4" :
+						       "DPO_PROTO_IP6",
+	dpo_idx);
 
       hicn_dpo_ctx_t *fib_entry = hicn_strategy_dpo_ctx_get (dpo_idx);
 
@@ -448,7 +442,8 @@ hicn_route_enable (fib_prefix_t *prefix)
 	  fib_hicn_index, prefix, hicn_fib_src,
 	  (FIB_ENTRY_FLAG_EXCLUSIVE | FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT), &dpo);
 
-      sync_hicn_fib_entry (fib_entry);
+      HICN_DEBUG ("Calling sync_hicn_fib_entry");
+      sync_hicn_fib_entry (fib_entry, pvec_faces);
 
       /* We added a route, therefore add one lock to the table */
       fib_table_lock (fib_index, prefix->fp_proto, hicn_fib_src);
@@ -470,6 +465,8 @@ hicn_route_enable (fib_prefix_t *prefix)
     }
   else
     {
+      HICN_DEBUG ("Found a route for %U. Updating DPO.", format_ip_prefix,
+		  &prefix);
       const dpo_id_t *load_balance_dpo_id;
       const dpo_id_t *strategy_dpo_id;
 
@@ -481,6 +478,7 @@ hicn_route_enable (fib_prefix_t *prefix)
       if (load_balance_dpo_id->dpoi_type != DPO_LOAD_BALANCE)
 	{
 	  ret = HICN_ERROR_ROUTE_NO_LD;
+	  HICN_ERROR ("DPO is not a load balance.");
 	  goto done;
 	}
       else
@@ -493,19 +491,22 @@ hicn_route_enable (fib_prefix_t *prefix)
 	  if (!dpo_is_hicn (strategy_dpo_id))
 	    {
 	      ret = HICN_ERROR_ROUTE_DPO_NO_HICN;
+	      HICN_ERROR ("DPO is not hicn.");
 	      goto done;
 	    }
 
 	  if (lb->lb_n_buckets > 1)
 	    {
 	      ret = HICN_ERROR_ROUTE_MLT_LD;
+	      HICN_ERROR ("Too many load balance buckets.");
 	      goto done;
 	    }
 
 	  hicn_dpo_ctx_t *hicn_fib_entry =
 	    hicn_strategy_dpo_ctx_get (strategy_dpo_id->dpoi_index);
 
-	  sync_hicn_fib_entry (hicn_fib_entry);
+	  HICN_DEBUG ("Calling sync_hicn_fib_entry");
+	  sync_hicn_fib_entry (hicn_fib_entry, pvec_faces);
 	}
     }
 
@@ -527,6 +528,7 @@ hicn_route_disable (fib_prefix_t *prefix)
 
   if (fib_hicn_entry_index == FIB_NODE_INDEX_INVALID)
     {
+      HICN_ERROR ("Route %U not found", format_ip_prefix, prefix);
       return HICN_ERROR_ROUTE_NOT_FOUND;
     }
   else
@@ -542,6 +544,8 @@ hicn_route_disable (fib_prefix_t *prefix)
       /* The dpo is not a load balance dpo as expected */
       if (load_balance_dpo_id->dpoi_type != DPO_LOAD_BALANCE)
 	{
+	  HICN_ERROR ("DPO for route %U is not a load balance.",
+		      format_ip_prefix, prefix);
 	  ret = HICN_ERROR_ROUTE_NO_LD;
 	  goto done;
 	}
@@ -554,12 +558,16 @@ hicn_route_disable (fib_prefix_t *prefix)
 
 	  if (!dpo_is_hicn (strategy_dpo_id))
 	    {
+	      HICN_ERROR ("ERROR: DPO for route %U is not a hicn.",
+			  format_ip_prefix, prefix);
 	      ret = HICN_ERROR_ROUTE_DPO_NO_HICN;
 	      goto done;
 	    }
 
 	  if (lb->lb_n_buckets > 1)
 	    {
+	      HICN_ERROR ("DPO for route %U contains multiple next hops.",
+			  format_ip_prefix, prefix);
 	      ret = HICN_ERROR_ROUTE_MLT_LD;
 	      goto done;
 	    }
@@ -567,17 +575,37 @@ hicn_route_disable (fib_prefix_t *prefix)
 	  hicn_fib_entry =
 	    hicn_strategy_dpo_ctx_get (strategy_dpo_id->dpoi_index);
 
+	  HICN_DEBUG ("Found from hicn_strategy_dpo_ctx_get with index %d: %p",
+		      strategy_dpo_id->dpoi_index, hicn_fib_entry);
+
+	  if (PREDICT_FALSE (!hicn_fib_entry))
+	    {
+	      HICN_ERROR (
+		"hicn_strategy_dpo_ctx_get for index %d returned NULL",
+		strategy_dpo_id->dpoi_index);
+	      ret = HICN_ERROR_ROUTE_DPO_NO_HICN;
+	      goto done;
+	    }
+
 	  for (int i = 0; i < hicn_fib_entry->entry_count; i++)
 	    {
 	      hicn_strategy_dpo_ctx_del_nh (hicn_fib_entry->next_hops[i],
 					    hicn_fib_entry);
 	    }
+
+	  hicn_mapme_tfib_clear ((hicn_mapme_tfib_t *) hicn_fib_entry);
 	}
 
+      HICN_DEBUG (
+	"Calling fib_entry_untrack and fib_table_entry_special_remove "
+	"for route %U.",
+	format_ip_prefix, prefix);
+
       fib_entry_untrack (hicn_fib_entry->fib_entry_index,
 			 hicn_fib_entry->fib_sibling);
 
       fib_table_entry_special_remove (fib_hicn_index, prefix, hicn_fib_src);
+      fib_node_unlock (&hicn_fib_entry->fib_node);
 
       /* Disable the feature to punt data packet every time we enable a new
        * hicn route */
@@ -618,7 +646,11 @@ hicn_fib_back_walk_notify (fib_node_t *node, fib_node_back_walk_ctx_t *ctx)
 
   hicn_dpo_ctx_t *fib_entry = hicn_ctx_from_fib_node (node);
 
-  sync_hicn_fib_entry (fib_entry);
+  hicn_face_id_t *vec_faces = NULL;
+  HICN_DEBUG ("Calling sync_hicn_fib_entry from hicn_fib_back_walk_notify");
+  sync_hicn_fib_entry (fib_entry, &vec_faces);
+  if (vec_faces != NULL)
+    vec_free (vec_faces);
 
   return (FIB_NODE_BACK_WALK_CONTINUE);
 }
@@ -661,7 +693,8 @@ enable_data_on_existing_hicn (fib_node_index_t fei, void *ctx)
 	  goto done;
 	}
 
-      enable_disable_data_receiving (strategy_dpo_id->dpoi_proto, sw_if, 1);
+      enable_disable_data_receiving (
+	(fib_protocol_t) strategy_dpo_id->dpoi_proto, sw_if, 1);
     }
 
 done:
@@ -673,18 +706,18 @@ set_table_interface_add_del (vnet_main_t *vnm, u32 sw_if_index, u32 is_add)
 {
 
   if (!is_add)
-    return HICN_ERROR_NONE;
+    return NULL;
 
-  int rv = ip_table_bind (FIB_PROTOCOL_IP4, sw_if_index, HICN_FIB_TABLE, 1);
+  int rv = ip_table_bind (FIB_PROTOCOL_IP4, sw_if_index, HICN_FIB_TABLE);
 
   if (!rv)
     {
-      rv = ip_table_bind (FIB_PROTOCOL_IP6, sw_if_index, HICN_FIB_TABLE, 1);
+      rv = ip_table_bind (FIB_PROTOCOL_IP6, sw_if_index, HICN_FIB_TABLE);
 
       if (rv)
 	{
 	  /* An error occurred. Bind the interface back to the default fib */
-	  ip_table_bind (FIB_PROTOCOL_IP4, sw_if_index, 0, 1);
+	  ip_table_bind (FIB_PROTOCOL_IP4, sw_if_index, 0);
 	}
     }
 
@@ -707,10 +740,11 @@ set_table_interface_add_del (vnet_main_t *vnm, u32 sw_if_index, u32 is_add)
     }
 
   return rv ? clib_error_return (0, "unable to add hicn table to interface") :
-	      0;
+		    0;
 }
 
-VNET_SW_INTERFACE_ADD_DEL_FUNCTION (set_table_interface_add_del);
+VNET_SW_INTERFACE_ADD_DEL_FUNCTION_PRIO (set_table_interface_add_del,
+					 VNET_ITF_FUNC_PRIORITY_HIGH);
 
 void
 hicn_route_init ()
@@ -720,7 +754,8 @@ hicn_route_init ()
   hicn_fib_src =
     fib_source_allocate ("hicn", FIB_SOURCE_HICN, FIB_SOURCE_BH_API);
 
-  hicn_fib_node_type = fib_node_register_new_type (&hicn_fib_vft);
+  hicn_fib_node_type =
+    fib_node_register_new_type ("hicn_route_fib_node", &hicn_fib_vft);
 
   ip_table_create (FIB_PROTOCOL_IP4, HICN_FIB_TABLE, 1, (const u8 *) "hicn4");
   ip_table_create (FIB_PROTOCOL_IP6, HICN_FIB_TABLE, 1, (const u8 *) "hicn6");
diff --git a/hicn-plugin/src/route.h b/hicn-plugin/src/route.h
index 19b18b8c6..072926498 100644
--- a/hicn-plugin/src/route.h
+++ b/hicn-plugin/src/route.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -73,28 +73,31 @@ int hicn_route_get_dpo (const fib_prefix_t *prefix, const dpo_id_t **hicn_dpo,
 int hicn_route_set_strategy (fib_prefix_t *prefix, u32 strategy_id);
 
 /**
- * @Brief Helper to add a nex hop in the vrf 0. If there are no entries in the
- * vrf 0 that matches with the prefix (epm), a new one is created.
+ * @Brief Helper to add an adj nex hop in the vrf 0. If there are no entries in
+ * the vrf 0 that matches with the prefix (epm), a new one is created.
  *
  * @param fib_proto FIB_PROTOCOL_IP6 or FIB_PROTOCOL_IP4 (mpls not supported)
- * @param pfx Prefix for which to add a next hop
+ * @param rpfx Prefix for which to add a next hop
  * @param nh Next hop to add
  * @param sw_if Software interface index to add in the next hop
  */
-int ip_nh_add_helper (fib_protocol_t fib_proto, const fib_prefix_t *pfx,
-		      ip46_address_t *nh, u32 sw_if);
+int ip_nh_adj_add_del_helper (fib_protocol_t fib_proto,
+			      const fib_prefix_t *rpfx, ip46_address_t *nh,
+			      u32 sw_if, u8 is_add);
 
 /**
- * @Brief Helper to remove a nex hop in the vrf 0. If there are no entries in
- * the vrf 0 nothing happens.
+ * @Brief Helper to add an udp-tunnel nex hop in the vrf 0. If there are no
+ * entries in the vrf 0 that matches with the prefix (epm), a new one is
+ * created.
  *
  * @param fib_proto FIB_PROTOCOL_IP6 or FIB_PROTOCOL_IP4 (mpls not supported)
- * @param pfx Prefix for which to remove a next hop
- * @param nh Next hop to remove
- * @param sw_if Software interface index in the next hop definition
+ * @param rpfx Prefix for which to add a next hop
+ * @param uei The UDP ENCAP ID
+ * @param sw_if The
  */
-int ip_nh_del_helper (fib_protocol_t fib_proto, const fib_prefix_t *rpfx,
-		      ip46_address_t *nh, u32 sw_if);
+int ip_nh_udp_tunnel_add_del_helper (fib_protocol_t fib_proto,
+				     const fib_prefix_t *rpfx, u32 uei,
+				     dpo_proto_t proto, u8 is_add);
 
 /**
  * @Brief Enable an hICN for an ip prefix
@@ -106,7 +109,7 @@ int ip_nh_del_helper (fib_protocol_t fib_proto, const fib_prefix_t *rpfx,
  * loadbalancer in the vrf HICN already contains a dpo which is not an hICN one
  * HICN_ERROR_ROUTE_MLT_LD if there are more than a dpo in the vpp loadbalancer
  */
-int hicn_route_enable (fib_prefix_t *prefix);
+int hicn_route_enable (fib_prefix_t *prefix, hicn_face_id_t **vec_faces);
 
 /**
  * @Brief Disable an hICN for an ip prefix. If hICN wasn't enable on the prefix
diff --git a/hicn-plugin/src/state.h b/hicn-plugin/src/state.h
index 561aef2db..39953722d 100644
--- a/hicn-plugin/src/state.h
+++ b/hicn-plugin/src/state.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/strategies/dpo_mw.c b/hicn-plugin/src/strategies/dpo_mw.c
index 70ef7d7c9..1a7d2e495 100644
--- a/hicn-plugin/src/strategies/dpo_mw.c
+++ b/hicn-plugin/src/strategies/dpo_mw.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -28,6 +28,7 @@ static const hicn_dpo_vft_t hicn_dpo_mw_vft = {
   .hicn_dpo_get_type = &hicn_dpo_strategy_mw_get_type,
   .hicn_dpo_module_init = &hicn_dpo_strategy_mw_module_init,
   .hicn_dpo_create = &hicn_strategy_mw_ctx_create,
+  .hicn_dpo_update_type = &hicn_strategy_mw_update_ctx_type,
   .hicn_dpo_add_update_nh = &hicn_strategy_mw_ctx_add_nh,
   .hicn_dpo_del_nh = &hicn_strategy_mw_ctx_del_nh,
   .hicn_dpo_format = &hicn_strategy_mw_format_ctx
@@ -117,8 +118,22 @@ hicn_strategy_mw_ctx_create (fib_protocol_t proto,
 
   *dpo_idx = hicn_strategy_dpo_ctx_get_index (hicn_strategy_ctx);
 
-  init_dpo_ctx (hicn_strategy_ctx, next_hop, nh_len, hicn_dpo_type_mw, proto);
+  HICN_DEBUG ("Successful hicn_strategy_dpo_ctx_alloc with index %d",
+	      *dpo_idx);
 
+  init_dpo_ctx (hicn_strategy_ctx, next_hop, nh_len, hicn_dpo_type_mw,
+		(dpo_proto_t) proto);
+
+  memset (hicn_strategy_mw_ctx->weight, 0, HICN_PARAM_FIB_ENTRY_NHOPS_MAX);
+}
+
+void
+hicn_strategy_mw_update_ctx_type (hicn_dpo_ctx_t *hicn_strategy_ctx)
+{
+  hicn_strategy_mw_ctx_t *hicn_strategy_mw_ctx;
+  hicn_strategy_mw_ctx = (hicn_strategy_mw_ctx_t *) hicn_strategy_ctx->data;
+
+  hicn_strategy_ctx->dpo_type = hicn_dpo_type_mw;
   memset (hicn_strategy_mw_ctx->weight, 0, HICN_PARAM_FIB_ENTRY_NHOPS_MAX);
 }
 
diff --git a/hicn-plugin/src/strategies/dpo_mw.h b/hicn-plugin/src/strategies/dpo_mw.h
index 1a174631a..d2807d1a5 100644
--- a/hicn-plugin/src/strategies/dpo_mw.h
+++ b/hicn-plugin/src/strategies/dpo_mw.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -72,6 +72,13 @@ void hicn_strategy_mw_ctx_create (fib_protocol_t proto,
 				  index_t *dpo_idx);
 
 /**
+ * @brief Update existing ctx setting it to mw
+ *
+ * @param hicn_strategy_ctx pointer to the ctx to update
+ */
+void hicn_strategy_mw_update_ctx_type (hicn_dpo_ctx_t *hicn_strategy_ctx);
+
+/**
  * @brief Add or update a next hop in the dpo ctx.
  *
  * This function is meant to be used in the control plane and not in the data
diff --git a/hicn-plugin/src/strategies/dpo_rp.c b/hicn-plugin/src/strategies/dpo_rp.c
new file mode 100644
index 000000000..7f527cdb6
--- /dev/null
+++ b/hicn-plugin/src/strategies/dpo_rp.c
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "dpo_rp.h"
+#include "strategy_rp.h"
+#include "../strategy_dpo_manager.h"
+#include "../strategy_dpo_ctx.h"
+
+/**
+ * @brief DPO type value for the rp_strategy
+ */
+static dpo_type_t hicn_dpo_type_rp;
+
+static const hicn_dpo_vft_t hicn_dpo_rp_vft = {
+  .hicn_dpo_is_type = &hicn_dpo_is_type_strategy_rp,
+  .hicn_dpo_get_type = &hicn_dpo_strategy_rp_get_type,
+  .hicn_dpo_module_init = &hicn_dpo_strategy_rp_module_init,
+  .hicn_dpo_create = &hicn_strategy_rp_ctx_create,
+  .hicn_dpo_update_type = &hicn_strategy_rp_update_ctx_type,
+  .hicn_dpo_add_update_nh = &hicn_strategy_rp_ctx_add_nh,
+  .hicn_dpo_del_nh = &hicn_strategy_rp_ctx_del_nh,
+  .hicn_dpo_format = &hicn_strategy_rp_format_ctx
+};
+
+int
+hicn_dpo_is_type_strategy_rp (const dpo_id_t *dpo)
+{
+  return dpo->dpoi_type == hicn_dpo_type_rp;
+}
+
+void
+hicn_dpo_strategy_rp_module_init (void)
+{
+  /*
+   * Register our type of dpo
+   */
+  hicn_dpo_type_rp = hicn_dpo_register_new_type (
+    hicn_nodes_strategy, &hicn_dpo_rp_vft, hicn_rp_strategy_get_vft (),
+    &dpo_strategy_rp_ctx_vft);
+}
+
+dpo_type_t
+hicn_dpo_strategy_rp_get_type (void)
+{
+  return hicn_dpo_type_rp;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+u8 *
+hicn_strategy_rp_format_ctx (u8 *s, int n, ...)
+{
+  va_list args;
+  va_start (args, n);
+  s = format_hicn_strategy_rp_ctx (s, &args);
+  return s;
+}
+
+u8 *
+format_hicn_strategy_rp_ctx (u8 *s, va_list *ap)
+{
+  int i = 0;
+  index_t index = va_arg (*ap, index_t);
+  hicn_dpo_ctx_t *dpo_ctx = NULL;
+  u32 indent = va_arg (*ap, u32);
+
+  dpo_ctx = hicn_strategy_dpo_ctx_get (index);
+  if (dpo_ctx == NULL)
+    return s;
+
+  for (i = 0; i < HICN_PARAM_FIB_ENTRY_NHOPS_MAX; i++)
+    {
+      u8 *buf = NULL;
+      if (i < dpo_ctx->entry_count)
+	buf = format (NULL, "FIB");
+      else if (i >= HICN_PARAM_FIB_ENTRY_NHOPS_MAX - dpo_ctx->tfib_entry_count)
+	buf = format (NULL, "TFIB");
+      else
+	continue;
+
+      s = format (s, "\n");
+      s = format (s, "%U ", format_hicn_face, dpo_ctx->next_hops[i], indent);
+      s = format (s, " %s", buf);
+    }
+
+  return (s);
+}
+
+void
+hicn_strategy_rp_ctx_create (fib_protocol_t proto,
+			     const hicn_face_id_t *next_hop, int nh_len,
+			     index_t *dpo_idx)
+{
+  hicn_dpo_ctx_t *hicn_strategy_ctx;
+
+  /* Allocate a hicn_dpo_ctx on the vpp pool and initialize it */
+  hicn_strategy_ctx = hicn_strategy_dpo_ctx_alloc ();
+
+  *dpo_idx = hicn_strategy_dpo_ctx_get_index (hicn_strategy_ctx);
+
+  init_dpo_ctx (hicn_strategy_ctx, next_hop, nh_len, hicn_dpo_type_rp,
+		(dpo_proto_t) proto);
+}
+
+void
+hicn_strategy_rp_update_ctx_type (hicn_dpo_ctx_t *hicn_strategy_ctx)
+{
+  hicn_strategy_ctx->dpo_type = hicn_dpo_type_rp;
+  // don't care to reset data, it is not used
+}
+
+int
+hicn_strategy_rp_ctx_add_nh (hicn_face_id_t nh, index_t dpo_idx)
+{
+  hicn_dpo_ctx_t *hicn_strategy_dpo_ctx = hicn_strategy_dpo_ctx_get (dpo_idx);
+  u8 pos = 0;
+
+  if (hicn_strategy_dpo_ctx == NULL)
+    {
+      return HICN_ERROR_STRATEGY_NOT_FOUND;
+    }
+
+  hicn_strategy_dpo_ctx_add_nh (nh, hicn_strategy_dpo_ctx, &pos);
+  // nothing else to initialize in this strategy
+  return HICN_ERROR_NONE;
+}
+
+int
+hicn_strategy_rp_ctx_del_nh (hicn_face_id_t face_id, index_t dpo_idx)
+{
+  hicn_dpo_ctx_t *hicn_strategy_dpo_ctx = hicn_strategy_dpo_ctx_get (dpo_idx);
+  // No need to change the current_nhop. It will be updated at the next
+  // selection.
+  return hicn_strategy_dpo_ctx_del_nh (face_id, hicn_strategy_dpo_ctx);
+}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/hicn-plugin/src/strategies/dpo_rp.h b/hicn-plugin/src/strategies/dpo_rp.h
new file mode 100644
index 000000000..4fe645add
--- /dev/null
+++ b/hicn-plugin/src/strategies/dpo_rp.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __HICN_DPO_RP_H__
+#define __HICN_DPO_RP_H__
+
+#include <vnet/dpo/dpo.h>
+#include "../strategy_dpo_ctx.h"
+
+/**
+ * @file dpo_rp.h
+ *
+ * This file implements the strategy vtf (see strategy.h) and
+ * the dpo vft (see strategy_dpo_manager.h) for the strategy
+ * replication.
+ */
+
+typedef struct hicn_strategy_rp_ctx_s
+{
+} hicn_strategy_rp_ctx_t;
+
+/**
+ * @brief Format the dpo ctx for a human-readable string
+ *
+ * @param s String to which to append the formatted dpo ctx
+ * @param ap List of parameters for the formatting
+ *
+ * @result The string with the formatted dpo ctx
+ */
+u8 *format_hicn_strategy_rp_ctx (u8 *s, va_list *ap);
+
+const static dpo_vft_t dpo_strategy_rp_ctx_vft = {
+  .dv_lock = hicn_strategy_dpo_ctx_lock,
+  .dv_unlock = hicn_strategy_dpo_ctx_unlock,
+  .dv_format = format_hicn_strategy_rp_ctx,
+};
+
+/**
+ * @brief Retrieve an hicn_strategy_rp_ctx object
+ *
+ * @param indext Index of the hicn_dpo_ctx to retrieve
+ * @return The hicn_dpo_ctx object or NULL
+ */
+hicn_dpo_ctx_t *hicn_strategy_rp_ctx_get (index_t index);
+
+/**
+ * @brief Create a new replication ctx
+ *
+ * @param proto The protocol to which the dpo is meant for (see vpp docs)
+ * @param next_hop A list of next hops to be inserted in the dpo ctx
+ * @param nh_len Size of the list
+ * @param dpo_idx index_t that will hold the index of the created dpo ctx
+ * @return HICN_ERROR_NONE if the creation was fine, otherwise EINVAL
+ */
+void hicn_strategy_rp_ctx_create (fib_protocol_t proto,
+				  const hicn_face_id_t *next_hop, int nh_len,
+				  index_t *dpo_idx);
+
+/**
+ * @brief Update existing ctx setting it to rp
+ *
+ * @param hicn_strategy_ctx pointer to the ctx to update
+ */
+void hicn_strategy_rp_update_ctx_type (hicn_dpo_ctx_t *hicn_strategy_ctx);
+
+/**
+ * @brief Add or update a next hop in the dpo ctx.
+ *
+ * This function is meant to be used in the control plane and not in the data
+ * plane, as it is not optimized for the latter.
+ *
+ * @param nh Next hop to insert in the dpo ctx
+ * @param dpo_idx Index of the dpo ctx to update with the new or updated next
+ * hop
+ * @return HICN_ERROR_NONE if the update or insert was fine,
+ * otherwise HICN_ERROR_DPO_CTX_NOT_FOUND
+ */
+int hicn_strategy_rp_ctx_add_nh (hicn_face_id_t nh, index_t dpo_idx);
+
+/**
+ * @brief Delete a next hop in the dpo ctx.
+ *
+ * @param face_id Face identifier of the next hop
+ * @param dpo_idx Index of the dpo ctx to update with the new or updated next
+ * hop
+ * @return HICN_ERROR_NONE if the update or insert was fine,
+ * otherwise HICN_ERROR_DPO_CTS_NOT_FOUND
+ */
+int hicn_strategy_rp_ctx_del_nh (hicn_face_id_t face_id, index_t dpo_idx);
+
+/**
+ * @brief Prefetch a dpo
+ *
+ * @param dpo_idx Index of the dpo ctx to prefetch
+ */
+void hicn_strategy_rp_ctx_prefetch (index_t dpo_idx);
+
+/**
+ * @brief Return true if the dpo is of type strategy rp
+ *
+ * @param dpo Dpo to check the type
+ */
+int hicn_dpo_is_type_strategy_rp (const dpo_id_t *dpo);
+
+/**
+ * @brief Initialize the Replication strategy
+ */
+void hicn_dpo_strategy_rp_module_init (void);
+
+/**
+ * @brief Return the dpo type for the Replication strategy
+ */
+dpo_type_t hicn_dpo_strategy_rp_get_type (void);
+
+/**
+ * @brief Format the dpo ctx for the strategy Replication
+ *
+ * @param s String to append the formatted dpo ctx
+ * @param ap List of arguments to format
+ */
+u8 *format_hicn_dpo_strategy_rp (u8 *s, va_list *ap);
+
+/**
+ * @brief Format the dpo ctx for the strategy Replication. To
+ * call from other functions
+ *
+ * @param s String to append the formatted dpo ctx
+ * @param ... List of arguments to format
+ */
+u8 *hicn_strategy_rp_format_ctx (u8 *s, int n, ...);
+
+#endif // __HICN_DPO_RP_H__
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/hicn-plugin/src/strategies/dpo_rr.c b/hicn-plugin/src/strategies/dpo_rr.c
index 3fe506bd1..86b68186b 100644
--- a/hicn-plugin/src/strategies/dpo_rr.c
+++ b/hicn-plugin/src/strategies/dpo_rr.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -28,6 +28,7 @@ static const hicn_dpo_vft_t hicn_dpo_rr_vft = {
   .hicn_dpo_get_type = &hicn_dpo_strategy_rr_get_type,
   .hicn_dpo_module_init = &hicn_dpo_strategy_rr_module_init,
   .hicn_dpo_create = &hicn_strategy_rr_ctx_create,
+  .hicn_dpo_update_type = &hicn_strategy_rr_update_ctx_type,
   .hicn_dpo_add_update_nh = &hicn_strategy_rr_ctx_add_nh,
   .hicn_dpo_del_nh = &hicn_strategy_rr_ctx_del_nh,
   .hicn_dpo_format = &hicn_strategy_rr_format_ctx
@@ -117,11 +118,22 @@ hicn_strategy_rr_ctx_create (fib_protocol_t proto,
 
   *dpo_idx = hicn_strategy_dpo_ctx_get_index (hicn_strategy_ctx);
 
-  init_dpo_ctx (hicn_strategy_ctx, next_hop, nh_len, hicn_dpo_type_rr, proto);
+  init_dpo_ctx (hicn_strategy_ctx, next_hop, nh_len, hicn_dpo_type_rr,
+		(dpo_proto_t) proto);
 
   hicn_strategy_rr_ctx->current_nhop = 0;
 }
 
+void
+hicn_strategy_rr_update_ctx_type (hicn_dpo_ctx_t *hicn_strategy_ctx)
+{
+  hicn_strategy_rr_ctx_t *hicn_strategy_rr_ctx;
+  hicn_strategy_rr_ctx = (hicn_strategy_rr_ctx_t *) hicn_strategy_ctx->data;
+
+  hicn_strategy_ctx->dpo_type = hicn_dpo_type_rr;
+  hicn_strategy_rr_ctx->current_nhop = 0;
+}
+
 int
 hicn_strategy_rr_ctx_add_nh (hicn_face_id_t nh, index_t dpo_idx)
 {
diff --git a/hicn-plugin/src/strategies/dpo_rr.h b/hicn-plugin/src/strategies/dpo_rr.h
index e68e2917d..72ec7b5df 100644
--- a/hicn-plugin/src/strategies/dpo_rr.h
+++ b/hicn-plugin/src/strategies/dpo_rr.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -74,6 +74,13 @@ void hicn_strategy_rr_ctx_create (fib_protocol_t proto,
 				  index_t *dpo_idx);
 
 /**
+ * @brief Update existing ctx setting it to rr
+ *
+ * @param hicn_strategy_ctx pointer to the ctx to update
+ */
+void hicn_strategy_rr_update_ctx_type (hicn_dpo_ctx_t *hicn_strategy_ctx);
+
+/**
  * @brief Add or update a next hop in the dpo ctx.
  *
  * This function is meant to be used in the control plane and not in the data
diff --git a/hicn-plugin/src/strategies/strategy_mw.c b/hicn-plugin/src/strategies/strategy_mw.c
index 9409ec856..990e64a5d 100644
--- a/hicn-plugin/src/strategies/strategy_mw.c
+++ b/hicn-plugin/src/strategies/strategy_mw.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,7 +25,7 @@ void hicn_receive_data_mw (index_t dpo_idx, int nh_idx);
 void hicn_add_interest_mw (index_t dpo_idx, hicn_hash_entry_t *pit_entry);
 void hicn_on_interest_timeout_mw (index_t dpo_idx);
 u32 hicn_select_next_hop_mw (index_t dpo_idx, int *nh_idx,
-			     hicn_face_id_t *outface);
+			     hicn_face_id_t *outfaces, uint32_t *len);
 u32 get_strategy_node_index_mw (void);
 u8 *hicn_strategy_format_trace_mw (u8 *s, hicn_strategy_trace_t *t);
 u8 *hicn_strategy_format_mw (u8 *s, va_list *ap);
@@ -51,12 +51,16 @@ hicn_mw_strategy_get_vft (void)
 /* DPO should be give in input as it containes all the information to calculate
  * the next hops*/
 u32
-hicn_select_next_hop_mw (index_t dpo_idx, int *nh_idx, hicn_face_id_t *outface)
+hicn_select_next_hop_mw (index_t dpo_idx, int *nh_idx,
+			 hicn_face_id_t *outfaces, uint32_t *len)
 {
   hicn_dpo_ctx_t *dpo_ctx = hicn_strategy_dpo_ctx_get (dpo_idx);
 
   if (dpo_ctx == NULL)
-    return HICN_ERROR_STRATEGY_NOT_FOUND;
+    {
+      *len = 0;
+      return HICN_ERROR_STRATEGY_NOT_FOUND;
+    }
 
   hicn_strategy_mw_ctx_t *hicn_strategy_mw_ctx =
     (hicn_strategy_mw_ctx_t *) dpo_ctx->data;
@@ -71,7 +75,8 @@ hicn_select_next_hop_mw (index_t dpo_idx, int *nh_idx, hicn_face_id_t *outface)
 	}
     }
 
-  *outface = dpo_ctx->next_hops[next_hop_index];
+  outfaces[0] = dpo_ctx->next_hops[next_hop_index];
+  *len = 1;
 
   return HICN_ERROR_NONE;
 }
@@ -84,7 +89,6 @@ hicn_add_interest_mw (index_t dpo_ctx_idx, hicn_hash_entry_t *hash_entry)
 			   .dpoi_proto = 0,
 			   .dpoi_next_node = 0,
 			   .dpoi_index = dpo_ctx_idx };
-  hicn_strategy_dpo_ctx_lock (&hicn_dpo_id);
   hash_entry->vft_id = hicn_dpo_get_vft_id (&hicn_dpo_id);
 }
 
diff --git a/hicn-plugin/src/strategies/strategy_mw.h b/hicn-plugin/src/strategies/strategy_mw.h
index 9e0078b23..186e8c5ab 100644
--- a/hicn-plugin/src/strategies/strategy_mw.h
+++ b/hicn-plugin/src/strategies/strategy_mw.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/strategies/strategy_mw_cli.c b/hicn-plugin/src/strategies/strategy_mw_cli.c
index 6b56e9fd5..4ace68423 100644
--- a/hicn-plugin/src/strategies/strategy_mw_cli.c
+++ b/hicn-plugin/src/strategies/strategy_mw_cli.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -76,7 +76,7 @@ hicn_mw_strategy_cli_set_weight_command_fn (vlib_main_t *vm,
     }
 
   prefix.fp_proto = ip46_address_is_ip4 (&prefix.fp_addr) ? FIB_PROTOCOL_IP4 :
-							    FIB_PROTOCOL_IP6;
+								  FIB_PROTOCOL_IP6;
   ret = hicn_route_get_dpo (&prefix, &hicn_dpo_id, &fib_index);
 
   if (ret == HICN_ERROR_NONE)
diff --git a/hicn-plugin/src/strategies/strategy_rp.c b/hicn-plugin/src/strategies/strategy_rp.c
new file mode 100644
index 000000000..748cd69b1
--- /dev/null
+++ b/hicn-plugin/src/strategies/strategy_rp.c
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "dpo_rp.h"
+#include "../strategy.h"
+#include "../strategy_dpo_ctx.h"
+#include "../faces/face.h"
+#include "../hashtb.h"
+#include "../strategy_dpo_manager.h"
+
+/* Simple strategy that forwards intertests to all next hops */
+/* It does not require to exend the hicn_dpo */
+void hicn_receive_data_rp (index_t dpo_idx, int nh_idx);
+void hicn_add_interest_rp (index_t dpo_idx, hicn_hash_entry_t *pit_entry);
+void hicn_on_interest_timeout_rp (index_t dpo_idx);
+u32 hicn_select_next_hop_rp (index_t dpo_idx, int *nh_idx,
+			     hicn_face_id_t *outfaces, uint32_t *len);
+u8 *hicn_strategy_format_trace_rp (u8 *s, hicn_strategy_trace_t *t);
+u8 *hicn_strategy_format_rp (u8 *s, va_list *ap);
+
+static hicn_strategy_vft_t hicn_strategy_rp_vft = {
+  .hicn_receive_data = &hicn_receive_data_rp,
+  .hicn_add_interest = &hicn_add_interest_rp,
+  .hicn_on_interest_timeout = &hicn_on_interest_timeout_rp,
+  .hicn_select_next_hop = &hicn_select_next_hop_rp,
+  .hicn_format_strategy_trace = &hicn_strategy_format_trace_rp,
+  .hicn_format_strategy = &hicn_strategy_format_rp
+};
+
+/*
+ * Return the vft of the strategy.
+ */
+hicn_strategy_vft_t *
+hicn_rp_strategy_get_vft (void)
+{
+  return &hicn_strategy_rp_vft;
+}
+
+/* DPO should be give in input as it containes all the information to calculate
+ * the next hops*/
+u32
+hicn_select_next_hop_rp (index_t dpo_idx, int *nh_idx,
+			 hicn_face_id_t *outfaces, uint32_t *len)
+{
+  hicn_dpo_ctx_t *dpo_ctx = hicn_strategy_dpo_ctx_get (dpo_idx);
+
+  if (dpo_ctx == NULL || dpo_ctx->entry_count == 0)
+    {
+      *len = 0;
+      return HICN_ERROR_STRATEGY_NOT_FOUND;
+    }
+
+  int i = 0;
+  while (i < MAX_OUT_FACES && i < dpo_ctx->entry_count)
+    {
+      outfaces[i] = dpo_ctx->next_hops[i];
+      i++;
+    }
+  *len = i;
+
+  return HICN_ERROR_NONE;
+}
+
+void
+hicn_add_interest_rp (index_t dpo_ctx_idx, hicn_hash_entry_t *hash_entry)
+{
+  /* Nothing to do */
+}
+
+void
+hicn_on_interest_timeout_rp (index_t dpo_idx)
+{
+  /* Nothing to do in the rp strategy when we receive an interest */
+}
+
+void
+hicn_receive_data_rp (index_t dpo_idx, int nh_idx)
+{
+  /* nothing to do */
+}
+
+/* packet trace format function */
+u8 *
+hicn_strategy_format_trace_rp (u8 *s, hicn_strategy_trace_t *t)
+{
+  s = format (s, "Strategy_rp: pkt: %d, sw_if_index %d, next index %d",
+	      (int) t->pkt_type, t->sw_if_index, t->next_index);
+  return (s);
+}
+
+u8 *
+hicn_strategy_format_rp (u8 *s, va_list *ap)
+{
+
+  u32 indent = va_arg (*ap, u32);
+  s = format (s, "Replication: send to all the next hops \n", indent);
+  return (s);
+}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/hicn-light/src/hicn/config/controlRemovePolicy.h b/hicn-plugin/src/strategies/strategy_rp.h
index ebe098985..c308497cc 100644
--- a/hicn-light/src/hicn/config/controlRemovePolicy.h
+++ b/hicn-plugin/src/strategies/strategy_rp.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,24 +13,29 @@
  * limitations under the License.
  */
 
+#ifndef __HICN_STRATEGY_RP_H__
+#define __HICN_STRATEGY_RP_H__
+
+#include "../strategy.h"
+
 /**
- * @file control_RemovePolicy.h
- * @brief Remove a policy from the FIB
- *
- * Implements the "remove policy" and "help remove policy" nodes of the command
- * tree
+ * @file strategy_rp.h
  *
+ * This file implements the replication strategy. In this
+ * strategy all the next hops are used to send an intertest.
  */
 
-#ifndef Control_RemovePolicy_h
-#define Control_RemovePolicy_h
-
-#ifdef WITH_POLICY
-
-#include <hicn/config/controlState.h>
-CommandOps *controlRemovePolicy_Create(ControlState *state);
-CommandOps *controlRemovePolicy_HelpCreate(ControlState *state);
+/**
+ * @brief Return the vft for the Replication strategy
+ */
+hicn_strategy_vft_t *hicn_rp_strategy_get_vft (void);
 
-#endif /* WITH_POLICY */
+#endif // __HICN_STRATEGY_RP_H__
 
-#endif  // Control_RemovePolicy_h
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/hicn-plugin/src/strategies/strategy_rr.c b/hicn-plugin/src/strategies/strategy_rr.c
index 9995191b7..192cf5fc3 100644
--- a/hicn-plugin/src/strategies/strategy_rr.c
+++ b/hicn-plugin/src/strategies/strategy_rr.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -26,7 +26,7 @@ void hicn_receive_data_rr (index_t dpo_idx, int nh_idx);
 void hicn_add_interest_rr (index_t dpo_idx, hicn_hash_entry_t *pit_entry);
 void hicn_on_interest_timeout_rr (index_t dpo_idx);
 u32 hicn_select_next_hop_rr (index_t dpo_idx, int *nh_idx,
-			     hicn_face_id_t *outface);
+			     hicn_face_id_t *outfaces, uint32_t *len);
 u8 *hicn_strategy_format_trace_rr (u8 *s, hicn_strategy_trace_t *t);
 u8 *hicn_strategy_format_rr (u8 *s, va_list *ap);
 
@@ -51,17 +51,22 @@ hicn_rr_strategy_get_vft (void)
 /* DPO should be give in input as it containes all the information to calculate
  * the next hops*/
 u32
-hicn_select_next_hop_rr (index_t dpo_idx, int *nh_idx, hicn_face_id_t *outface)
+hicn_select_next_hop_rr (index_t dpo_idx, int *nh_idx,
+			 hicn_face_id_t *outfaces, uint32_t *len)
 {
   hicn_dpo_ctx_t *dpo_ctx = hicn_strategy_dpo_ctx_get (dpo_idx);
 
   if (dpo_ctx == NULL)
-    return HICN_ERROR_STRATEGY_NOT_FOUND;
+    {
+      *len = 0;
+      return HICN_ERROR_STRATEGY_NOT_FOUND;
+    }
 
   hicn_strategy_rr_ctx_t *hicn_strategy_rr_ctx =
     (hicn_strategy_rr_ctx_t *) dpo_ctx->data;
 
-  *outface = dpo_ctx->next_hops[hicn_strategy_rr_ctx->current_nhop];
+  outfaces[0] = dpo_ctx->next_hops[hicn_strategy_rr_ctx->current_nhop];
+  *len = 1;
 
   hicn_strategy_rr_ctx->current_nhop =
     (hicn_strategy_rr_ctx->current_nhop + 1) % dpo_ctx->entry_count;
@@ -77,7 +82,6 @@ hicn_add_interest_rr (index_t dpo_ctx_idx, hicn_hash_entry_t *hash_entry)
 			   .dpoi_proto = 0,
 			   .dpoi_next_node = 0,
 			   .dpoi_index = dpo_ctx_idx };
-  hicn_strategy_dpo_ctx_lock (&hicn_dpo_id);
   hash_entry->vft_id = hicn_dpo_get_vft_id (&hicn_dpo_id);
 }
 
diff --git a/hicn-plugin/src/strategies/strategy_rr.h b/hicn-plugin/src/strategies/strategy_rr.h
index 4dfe76b43..fb7520180 100644
--- a/hicn-plugin/src/strategies/strategy_rr.h
+++ b/hicn-plugin/src/strategies/strategy_rr.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/strategy.h b/hicn-plugin/src/strategy.h
index 28af55f01..efc6e464e 100644
--- a/hicn-plugin/src/strategy.h
+++ b/hicn-plugin/src/strategy.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -53,7 +53,7 @@ typedef struct hicn_strategy_vft_s
   void (*hicn_on_interest_timeout) (index_t dpo_idx);
   void (*hicn_add_interest) (index_t dpo_idx, hicn_hash_entry_t *pit_entry);
   u32 (*hicn_select_next_hop) (index_t dpo_idx, int *nh_idx,
-			       hicn_face_id_t *outface);
+			       hicn_face_id_t *outfaces, uint32_t *len);
   u8 *(*hicn_format_strategy_trace) (u8 *, hicn_strategy_trace_t *);
   u8 *(*hicn_format_strategy) (u8 *s, va_list *ap);
   /**< Format an hICN dpo*/
@@ -86,6 +86,8 @@ const static char *const *const hicn_nodes_strategy[DPO_PROTO_NUM] = {
   [DPO_PROTO_IP4] = hicn_ip4_nodes,
 };
 
+const static uint32_t MAX_OUT_FACES = 8;
+
 extern vlib_node_registration_t hicn_strategy_node;
 
 #endif /* //__HICN_STRATEGY__ */
diff --git a/hicn-plugin/src/strategy_dpo_ctx.c b/hicn-plugin/src/strategy_dpo_ctx.c
index edfe75aa8..2279ecc75 100644
--- a/hicn-plugin/src/strategy_dpo_ctx.c
+++ b/hicn-plugin/src/strategy_dpo_ctx.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,7 +21,7 @@ hicn_dpo_ctx_t *hicn_strategy_dpo_ctx_pool;
 void
 hicn_strategy_init_dpo_ctx_pool ()
 {
-  pool_init_fixed (hicn_strategy_dpo_ctx_pool, 256);
+  // pool_init_fixed (hicn_strategy_dpo_ctx_pool, 256);
 }
 
 void
@@ -29,9 +29,16 @@ hicn_strategy_dpo_ctx_lock (dpo_id_t *dpo)
 {
   hicn_dpo_ctx_t *dpo_ctx = hicn_strategy_dpo_ctx_get (dpo->dpoi_index);
 
-  if (dpo_ctx != NULL)
+  if (PREDICT_TRUE (dpo_ctx != NULL))
     {
       dpo_ctx->locks++;
+      HICN_DEBUG ("Locking DPO CTX with index %d. Lock now: %d",
+		  dpo->dpoi_index, dpo_ctx->locks);
+    }
+  else
+    {
+      HICN_ERROR ("Trying to lock NULL spo_ctx with index %d",
+		  dpo->dpoi_index);
     }
 }
 
@@ -41,15 +48,23 @@ hicn_strategy_dpo_ctx_unlock (dpo_id_t *dpo)
   hicn_dpo_ctx_t *hicn_strategy_dpo_ctx =
     (hicn_dpo_ctx_t *) hicn_strategy_dpo_ctx_get (dpo->dpoi_index);
 
-  if (hicn_strategy_dpo_ctx != NULL)
+  if (PREDICT_TRUE (hicn_strategy_dpo_ctx != NULL))
     {
       hicn_strategy_dpo_ctx->locks--;
+      HICN_DEBUG ("Unlcking DPO CTX with index %d. Lock now: %d",
+		  dpo->dpoi_index, hicn_strategy_dpo_ctx->locks);
 
       if (0 == hicn_strategy_dpo_ctx->locks)
 	{
+	  HICN_DEBUG ("Releasing DPO CTX %d", dpo->dpoi_index);
 	  pool_put (hicn_strategy_dpo_ctx_pool, hicn_strategy_dpo_ctx);
 	}
     }
+  else
+    {
+      HICN_ERROR ("Trying to unlock NULL spo_ctx with index %d",
+		  dpo->dpoi_index);
+    }
 }
 
 u8 *
@@ -90,8 +105,11 @@ hicn_strategy_dpo_ctx_get (index_t index)
 hicn_dpo_ctx_t *
 hicn_strategy_dpo_ctx_alloc ()
 {
+  HICN_DEBUG ("Allocating new DPO CTX");
   hicn_dpo_ctx_t *dpo_ctx;
-  pool_get (hicn_strategy_dpo_ctx_pool, dpo_ctx);
+  pool_get_aligned (hicn_strategy_dpo_ctx_pool, dpo_ctx,
+		    2 * CLIB_CACHE_LINE_BYTES);
+  dpo_ctx->locks = 0;
   return dpo_ctx;
 }
 
diff --git a/hicn-plugin/src/strategy_dpo_ctx.h b/hicn-plugin/src/strategy_dpo_ctx.h
index fe63a4258..cb8ca4051 100644
--- a/hicn-plugin/src/strategy_dpo_ctx.h
+++ b/hicn-plugin/src/strategy_dpo_ctx.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -108,7 +108,7 @@ init_dpo_ctx (hicn_dpo_ctx_t *dpo_ctx, const hicn_face_id_t *next_hop,
   dpo_ctx->seq = INIT_SEQ;
   dpo_ctx->dpo_type = dpo_type;
 
-  dpo_ctx->proto = proto;
+  dpo_ctx->proto = (fib_protocol_t) proto;
 
   for (int i = 0; i < HICN_PARAM_FIB_ENTRY_NHOPS_MAX && i < nh_len; i++)
     {
diff --git a/hicn-plugin/src/strategy_dpo_manager.c b/hicn-plugin/src/strategy_dpo_manager.c
index 3c441ccac..6c5767bc9 100644
--- a/hicn-plugin/src/strategy_dpo_manager.c
+++ b/hicn-plugin/src/strategy_dpo_manager.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -19,6 +19,7 @@
 #include "strategy_dpo_ctx.h"
 #include "strategies/dpo_mw.h"
 #include "strategies/dpo_rr.h"
+#include "strategies/dpo_rp.h"
 #include "strategy.h"
 #include "faces/face.h"
 
@@ -98,11 +99,13 @@ hicn_dpos_init (void)
   hicn_strategy_init_dpo_ctx_pool ();
   hicn_dpo_strategy_mw_module_init ();
   hicn_dpo_strategy_rr_module_init ();
+  hicn_dpo_strategy_rp_module_init ();
 
   default_dpo.hicn_dpo_is_type = &hicn_dpo_is_type_strategy_mw;
   default_dpo.hicn_dpo_get_type = &hicn_dpo_strategy_mw_get_type;
   default_dpo.hicn_dpo_module_init = &hicn_dpo_strategy_mw_module_init;
   default_dpo.hicn_dpo_create = &hicn_strategy_mw_ctx_create;
+  default_dpo.hicn_dpo_update_type = &hicn_strategy_mw_update_ctx_type;
   default_dpo.hicn_dpo_add_update_nh = &hicn_strategy_mw_ctx_add_nh;
   default_dpo.hicn_dpo_del_nh = &hicn_strategy_mw_ctx_del_nh;
   default_dpo.hicn_dpo_format = &hicn_strategy_mw_format_ctx;
@@ -128,12 +131,12 @@ format_hicn_strategy_list (u8 *s, int n, ...)
   return (s);
 }
 
-u8
+int
 hicn_dpo_strategy_id_is_valid (int strategy_id)
 {
   return vec_len (strategies_id) > strategy_id ?
-	   HICN_ERROR_NONE :
-	   HICN_ERROR_DPO_MGR_ID_NOT_VALID;
+		 HICN_ERROR_NONE :
+		 HICN_ERROR_DPO_MGR_ID_NOT_VALID;
 }
 
 int
diff --git a/hicn-plugin/src/strategy_dpo_manager.h b/hicn-plugin/src/strategy_dpo_manager.h
index 7a2ce3fee..b8a0c9e92 100644
--- a/hicn-plugin/src/strategy_dpo_manager.h
+++ b/hicn-plugin/src/strategy_dpo_manager.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -53,6 +53,8 @@ typedef struct hicn_dpo_vft_s
   void (*hicn_dpo_create) (
     fib_protocol_t proto, const hicn_face_id_t *nh, int nh_len,
     index_t *dpo_idx); /**< Create the context of the hICN dpo */
+  void (*hicn_dpo_update_type) (
+    hicn_dpo_ctx_t *hicn_strategy_ctx); /**change dpo type */
   int (*hicn_dpo_add_update_nh) (
     hicn_face_id_t nh,
     index_t dpo_idx); /**< Add a next hop to the hICN dpo context */
@@ -171,7 +173,7 @@ u8 *format_hicn_strategy_list (u8 *s, int n, ...);
  *
  * @result HICN_ERROR_NONE is the id is valid, otherwise EINVAL
  */
-u8 hicn_dpo_strategy_id_is_valid (int strategy_id);
+int hicn_dpo_strategy_id_is_valid (int strategy_id);
 
 /**
  * @brief Return the number of available strategies. This number can be used to
diff --git a/hicn-plugin/src/strategy_node.c b/hicn-plugin/src/strategy_node.c
index ec57d76e2..66d9c2dbb 100644
--- a/hicn-plugin/src/strategy_node.c
+++ b/hicn-plugin/src/strategy_node.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,6 +25,7 @@
 #include "mgmt.h"
 #include "pcs.h"
 #include "state.h"
+#include "data_fwd.h"
 #include "strategies/strategy_mw.h"
 
 /* Registration struct for a graph node */
@@ -65,7 +66,8 @@ hicn_new_interest (hicn_strategy_runtime_t *rt, vlib_buffer_t *b0, u32 *next,
 		   f64 tnow, u8 *nameptr, u16 namelen, hicn_face_id_t outface,
 		   int nh_idx, index_t dpo_ctx_id0,
 		   const hicn_strategy_vft_t *strategy, dpo_type_t dpo_type,
-		   u8 isv6, vl_api_hicn_api_node_stats_get_reply_t *stats)
+		   u8 isv6, vl_api_hicn_api_node_stats_get_reply_t *stats,
+		   u8 is_replication)
 {
   int ret;
   hicn_hash_node_t *nodep;
@@ -80,6 +82,17 @@ hicn_new_interest (hicn_strategy_runtime_t *rt, vlib_buffer_t *b0, u32 *next,
   u8 bucket_is_overflow = 0;
   u32 bucket_id = ~0;
 
+  if (is_replication)
+    {
+      // an entry for this message alredy exists in the PIT so just send it
+      *next = isv6 ? HICN_STRATEGY_NEXT_INTEREST_FACE6 :
+			   HICN_STRATEGY_NEXT_INTEREST_FACE4;
+
+      vnet_buffer (b0)->ip.adj_index[VLIB_TX] = outface;
+      stats->pkts_interest_count++;
+      return HICN_ERROR_NONE;
+    }
+
   /* Create PIT node and init PIT entry */
   nodep = hicn_hashtb_alloc_node (rt->pitcs->pcs_table);
   if (PREDICT_FALSE (nodep == NULL))
@@ -101,6 +114,7 @@ hicn_new_interest (hicn_strategy_runtime_t *rt, vlib_buffer_t *b0, u32 *next,
     {
       imsg_lifetime = sm->pit_lifetime_max_ms;
     }
+
   pitp->shared.expire_time = hicn_pcs_get_exp_time (tnow, imsg_lifetime);
 
   /* Set up the hash node and insert it */
@@ -121,7 +135,7 @@ hicn_new_interest (hicn_strategy_runtime_t *rt, vlib_buffer_t *b0, u32 *next,
       hicn_face_db_add_face (hicnb0->face_id, &(pitp->u.pit.faces));
 
       *next = isv6 ? HICN_STRATEGY_NEXT_INTEREST_FACE6 :
-		     HICN_STRATEGY_NEXT_INTEREST_FACE4;
+			   HICN_STRATEGY_NEXT_INTEREST_FACE4;
 
       vnet_buffer (b0)->ip.adj_index[VLIB_TX] = outface;
       stats->pkts_interest_count++;
@@ -137,9 +151,15 @@ hicn_new_interest (hicn_strategy_runtime_t *rt, vlib_buffer_t *b0, u32 *next,
 				     bucket_id, bucket_is_overflow);
 	  // We need to take a lock as the lock is not taken on the hash
 	  // entry because it is a CS entry (hash_insert function).
-	  hash_entry->locks++;
-	  *next = is_cs0 ? HICN_STRATEGY_NEXT_INTEREST_HITCS :
-			   HICN_STRATEGY_NEXT_INTEREST_HITPIT;
+	  if (is_cs0)
+	    {
+	      hash_entry->locks++;
+	      *next = HICN_STRATEGY_NEXT_INTEREST_HITCS;
+	    }
+	  else
+	    {
+	      *next = HICN_STRATEGY_NEXT_INTEREST_HITPIT;
+	    }
 	}
       else
 	{
@@ -189,7 +209,8 @@ hicn_strategy_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  hicn_header_t *hicn0;
 	  vlib_buffer_t *b0;
 	  u32 bi0;
-	  hicn_face_id_t outface;
+	  hicn_face_id_t outfaces[MAX_OUT_FACES];
+	  u32 outfaces_len;
 	  int nh_idx;
 	  u32 next0 = next_index;
 	  int ret;
@@ -207,15 +228,23 @@ hicn_strategy_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  bi0 = from[0];
 	  from += 1;
 	  n_left_from -= 1;
-	  to_next[0] = bi0;
-	  to_next += 1;
-	  n_left_to_next -= 1;
 
 	  b0 = vlib_get_buffer (vm, bi0);
 	  next0 = HICN_STRATEGY_NEXT_ERROR_DROP;
 
 	  hicn_dpo_ctx_t *dpo_ctx = hicn_strategy_dpo_ctx_get (
 	    vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
+
+	  if (PREDICT_FALSE (!dpo_ctx))
+	    {
+	      to_next[0] = bi0;
+	      to_next += 1;
+	      n_left_to_next -= 1;
+	      vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
+					       n_left_to_next, bi0, next0);
+	      continue;
+	    }
+
 	  const hicn_strategy_vft_t *strategy =
 	    hicn_dpo_get_strategy_vft (dpo_ctx->dpo_type);
 
@@ -231,7 +260,7 @@ hicn_strategy_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 			    HICN_IS_NAMEHASH_CACHED (b0) &&
 			    strategy->hicn_select_next_hop (
 			      vnet_buffer (b0)->ip.adj_index[VLIB_TX], &nh_idx,
-			      &outface) == HICN_ERROR_NONE))
+			      outfaces, &outfaces_len) == HICN_ERROR_NONE))
 	    {
 	      /*
 	       * No need to check if parsing was successful
@@ -239,32 +268,72 @@ hicn_strategy_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	       * node
 	       */
 	      nameptr = (u8 *) (&name);
-	      hicn_new_interest (rt, b0, &next0, tnow, nameptr, namelen,
-				 outface, nh_idx,
-				 vnet_buffer (b0)->ip.adj_index[VLIB_TX],
-				 strategy, dpo_ctx->dpo_type, isv6, &stats);
+	      u32 clones[outfaces_len];
+	      if (outfaces_len > 1)
+		{
+		  int ret = vlib_buffer_clone (vm, bi0, clones, outfaces_len,
+					       CLIB_CACHE_LINE_BYTES * 2);
+		  ASSERT (ret == outfaces_len);
+		}
+	      else
+		{
+		  clones[0] = bi0;
+		}
+
+	      for (u32 nh = 0; nh < outfaces_len; nh++)
+		{
+		  vlib_buffer_t *local_b0 = vlib_get_buffer (vm, clones[nh]);
+
+		  to_next[0] = clones[nh];
+		  to_next += 1;
+		  n_left_to_next -= 1;
+
+		  if (nh == 0)
+		    {
+		      // send first interest
+		      hicn_new_interest (
+			rt, local_b0, &next0, tnow, nameptr, namelen,
+			outfaces[nh], nh_idx,
+			vnet_buffer (local_b0)->ip.adj_index[VLIB_TX],
+			strategy, dpo_ctx->dpo_type, isv6, &stats, 0);
+		    }
+		  else
+		    {
+		      // send duplicated interests, avoid aggregation/drop
+		      hicn_new_interest (
+			rt, local_b0, &next0, tnow, nameptr, namelen,
+			outfaces[nh], nh_idx,
+			vnet_buffer (local_b0)->ip.adj_index[VLIB_TX],
+			strategy, dpo_ctx->dpo_type, isv6, &stats, 1);
+		    }
+
+		  /* Maybe trace */
+		  if (PREDICT_FALSE (
+			(node->flags & VLIB_NODE_FLAG_TRACE) &&
+			(local_b0->flags & VLIB_BUFFER_IS_TRACED)))
+		    {
+		      hicn_strategy_trace_t *t =
+			vlib_add_trace (vm, node, local_b0, sizeof (*t));
+		      t->pkt_type = HICN_PKT_TYPE_CONTENT;
+		      t->sw_if_index =
+			vnet_buffer (local_b0)->sw_if_index[VLIB_RX];
+		      t->next_index = next0;
+		      t->dpo_type = dpo_ctx->dpo_type;
+		    }
+
+		  /*
+		   * Verify speculative enqueue, maybe switch current
+		   * next frame
+		   */
+		  /*
+		   * Fix in case of a wrong speculation. Needed for
+		   * cloning the data in the right frame
+		   */
+		  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
+						   to_next, n_left_to_next,
+						   clones[nh], next0);
+		}
 	    }
-	  /* Maybe trace */
-	  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
-			     (b0->flags & VLIB_BUFFER_IS_TRACED)))
-	    {
-	      hicn_strategy_trace_t *t =
-		vlib_add_trace (vm, node, b0, sizeof (*t));
-	      t->pkt_type = HICN_PKT_TYPE_CONTENT;
-	      t->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
-	      t->next_index = next0;
-	      t->dpo_type = dpo_ctx->dpo_type;
-	    }
-	  /*
-	   * Verify speculative enqueue, maybe switch current
-	   * next frame
-	   */
-	  /*
-	   * Fix in case of a wrong speculation. Needed for
-	   * cloning the data in the right frame
-	   */
-	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
-					   n_left_to_next, bi0, next0);
 	}
 
       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
diff --git a/hicn-plugin/src/udp_tunnels/udp_decap.h b/hicn-plugin/src/udp_tunnels/udp_decap.h
index 9ddb8a73b..7dc13f272 100644
--- a/hicn-plugin/src/udp_tunnels/udp_decap.h
+++ b/hicn-plugin/src/udp_tunnels/udp_decap.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/src/udp_tunnels/udp_decap_node.c b/hicn-plugin/src/udp_tunnels/udp_decap_node.c
index 06eb8da71..2ac1b1ecb 100644
--- a/hicn-plugin/src/udp_tunnels/udp_decap_node.c
+++ b/hicn-plugin/src/udp_tunnels/udp_decap_node.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -223,7 +223,7 @@ udp4_decap_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 				&((ip4_header_t *) outer_ptr0)->dst_address);
 	  udp0 = (udp_header_t *) (outer_ptr0 + sizeof (ip4_header_t));
 	  next0 = v0 == 0x40 ? UDP4_DECAP_NEXT_LOOKUP_IP4 :
-			       UDP4_DECAP_NEXT_LOOKUP_IP6;
+				     UDP4_DECAP_NEXT_LOOKUP_IP6;
 
 	  ip46_address_set_ip4 (&src1,
 				&((ip4_header_t *) outer_ptr1)->src_address);
@@ -231,7 +231,7 @@ udp4_decap_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 				&((ip4_header_t *) outer_ptr1)->dst_address);
 	  udp1 = (udp_header_t *) (outer_ptr1 + sizeof (ip4_header_t));
 	  next1 = v1 == 0x40 ? UDP4_DECAP_NEXT_LOOKUP_IP4 :
-			       UDP4_DECAP_NEXT_LOOKUP_IP6;
+				     UDP4_DECAP_NEXT_LOOKUP_IP6;
 
 	  ip46_address_set_ip4 (&src2,
 				&((ip4_header_t *) outer_ptr2)->src_address);
@@ -239,7 +239,7 @@ udp4_decap_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 				&((ip4_header_t *) outer_ptr2)->dst_address);
 	  udp2 = (udp_header_t *) (outer_ptr2 + sizeof (ip4_header_t));
 	  next2 = v2 == 0x40 ? UDP4_DECAP_NEXT_LOOKUP_IP4 :
-			       UDP4_DECAP_NEXT_LOOKUP_IP6;
+				     UDP4_DECAP_NEXT_LOOKUP_IP6;
 
 	  ip46_address_set_ip4 (&src3,
 				&((ip4_header_t *) outer_ptr3)->src_address);
@@ -247,7 +247,7 @@ udp4_decap_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 				&((ip4_header_t *) outer_ptr3)->dst_address);
 	  udp3 = (udp_header_t *) (outer_ptr3 + sizeof (ip4_header_t));
 	  next3 = v3 == 0x40 ? UDP4_DECAP_NEXT_LOOKUP_IP4 :
-			       UDP4_DECAP_NEXT_LOOKUP_IP6;
+				     UDP4_DECAP_NEXT_LOOKUP_IP6;
 
 	  hicn_buffer_t *hicnb0, *hicnb1, *hicnb2, *hicnb3;
 	  hicnb0 = hicn_get_buffer (b0);
@@ -257,34 +257,39 @@ udp4_decap_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 
 	  /* Udp encap-decap tunnels have dst and src addresses and port
 	   * swapped */
-	  vnet_buffer (b0)->ip.adj_index[VLIB_RX] =
-	    udp_tunnel_get (&dst0, &src0, udp0->dst_port, udp0->src_port);
-	  vnet_buffer (b1)->ip.adj_index[VLIB_RX] =
-	    udp_tunnel_get (&dst1, &src1, udp1->dst_port, udp1->src_port);
-	  vnet_buffer (b2)->ip.adj_index[VLIB_RX] =
-	    udp_tunnel_get (&dst2, &src2, udp2->dst_port, udp2->src_port);
-	  vnet_buffer (b3)->ip.adj_index[VLIB_RX] =
-	    udp_tunnel_get (&dst3, &src3, udp3->dst_port, udp3->src_port);
-
-	  if (vnet_buffer (b0)->ip.adj_index[VLIB_RX] != UDP_TUNNEL_INVALID)
-	    hicnb0->flags |=
-	      (outer_v0 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
-				  HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
-
-	  if (vnet_buffer (b1)->ip.adj_index[VLIB_RX] != UDP_TUNNEL_INVALID)
-	    hicnb1->flags |=
-	      (outer_v1 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
-				  HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
-
-	  if (vnet_buffer (b2)->ip.adj_index[VLIB_RX] != UDP_TUNNEL_INVALID)
-	    hicnb2->flags |=
-	      (outer_v2 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
-				  HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
-
-	  if (vnet_buffer (b3)->ip.adj_index[VLIB_RX] != UDP_TUNNEL_INVALID)
-	    hicnb3->flags |=
-	      (outer_v3 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
-				  HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
+	  vnet_buffer (b0)->ip.adj_index[VLIB_RX] = udp_tunnel_get_create (
+	    &dst0, &src0, udp0->dst_port, udp0->src_port);
+	  vnet_buffer (b1)->ip.adj_index[VLIB_RX] = udp_tunnel_get_create (
+	    &dst1, &src1, udp1->dst_port, udp1->src_port);
+	  vnet_buffer (b2)->ip.adj_index[VLIB_RX] = udp_tunnel_get_create (
+	    &dst2, &src2, udp2->dst_port, udp2->src_port);
+	  vnet_buffer (b3)->ip.adj_index[VLIB_RX] = udp_tunnel_get_create (
+	    &dst3, &src3, udp3->dst_port, udp3->src_port);
+
+	  ASSERT (vnet_buffer (b0)->ip.adj_index[VLIB_RX] !=
+		  UDP_TUNNEL_INVALID);
+	  ASSERT (vnet_buffer (b1)->ip.adj_index[VLIB_RX] !=
+		  UDP_TUNNEL_INVALID);
+	  ASSERT (vnet_buffer (b2)->ip.adj_index[VLIB_RX] !=
+		  UDP_TUNNEL_INVALID);
+	  ASSERT (vnet_buffer (b3)->ip.adj_index[VLIB_RX] !=
+		  UDP_TUNNEL_INVALID);
+
+	  hicnb0->flags =
+	    (outer_v0 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
+				      HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
+
+	  hicnb1->flags =
+	    (outer_v1 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
+				      HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
+
+	  hicnb2->flags =
+	    (outer_v2 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
+				      HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
+
+	  hicnb3->flags =
+	    (outer_v3 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
+				      HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
 
 	  udp_decap_trace_buffer (vm, node, 1, b0);
 	  udp_decap_trace_buffer (vm, node, 1, b1);
@@ -346,17 +351,19 @@ udp4_decap_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 				&((ip4_header_t *) outer_ptr0)->dst_address);
 	  udp0 = (udp_header_t *) (outer_ptr0 + sizeof (ip4_header_t));
 	  next0 = v0 == 0x40 ? UDP4_DECAP_NEXT_LOOKUP_IP4 :
-			       UDP4_DECAP_NEXT_LOOKUP_IP6;
+				     UDP4_DECAP_NEXT_LOOKUP_IP6;
 
 	  hicn_buffer_t *hicnb0 = hicn_get_buffer (b0);
 
-	  vnet_buffer (b0)->ip.adj_index[VLIB_RX] =
-	    udp_tunnel_get (&dst0, &src0, udp0->dst_port, udp0->src_port);
+	  vnet_buffer (b0)->ip.adj_index[VLIB_RX] = udp_tunnel_get_create (
+	    &dst0, &src0, udp0->dst_port, udp0->src_port);
 
-	  if (vnet_buffer (b0)->ip.adj_index[VLIB_RX] != UDP_TUNNEL_INVALID)
-	    hicnb0->flags |=
-	      (outer_v0 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
-				  HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
+	  ASSERT (vnet_buffer (b0)->ip.adj_index[VLIB_RX] !=
+		  UDP_TUNNEL_INVALID);
+
+	  hicnb0->flags |=
+	    (outer_v0 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
+				      HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
 
 	  udp_decap_trace_buffer (vm, node, 1, b0);
 
@@ -488,7 +495,7 @@ udp6_decap_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 				&((ip6_header_t *) outer_ptr0)->dst_address);
 	  udp0 = (udp_header_t *) (outer_ptr0 + sizeof (ip6_header_t));
 	  next0 = v0 == 0x40 ? UDP6_DECAP_NEXT_LOOKUP_IP4 :
-			       UDP6_DECAP_NEXT_LOOKUP_IP6;
+				     UDP6_DECAP_NEXT_LOOKUP_IP6;
 
 	  ip46_address_set_ip6 (&src1,
 				&((ip6_header_t *) outer_ptr1)->src_address);
@@ -496,7 +503,7 @@ udp6_decap_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 				&((ip6_header_t *) outer_ptr1)->dst_address);
 	  udp1 = (udp_header_t *) (outer_ptr1 + sizeof (ip6_header_t));
 	  next1 = v1 == 0x40 ? UDP6_DECAP_NEXT_LOOKUP_IP4 :
-			       UDP6_DECAP_NEXT_LOOKUP_IP6;
+				     UDP6_DECAP_NEXT_LOOKUP_IP6;
 
 	  ip46_address_set_ip6 (&src2,
 				&((ip6_header_t *) outer_ptr2)->src_address);
@@ -504,7 +511,7 @@ udp6_decap_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 				&((ip6_header_t *) outer_ptr2)->dst_address);
 	  udp2 = (udp_header_t *) (outer_ptr2 + sizeof (ip6_header_t));
 	  next2 = v2 == 0x40 ? UDP6_DECAP_NEXT_LOOKUP_IP4 :
-			       UDP6_DECAP_NEXT_LOOKUP_IP6;
+				     UDP6_DECAP_NEXT_LOOKUP_IP6;
 
 	  ip46_address_set_ip6 (&src3,
 				&((ip6_header_t *) outer_ptr3)->src_address);
@@ -512,7 +519,7 @@ udp6_decap_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 				&((ip6_header_t *) outer_ptr3)->dst_address);
 	  udp3 = (udp_header_t *) (outer_ptr3 + sizeof (ip6_header_t));
 	  next3 = v3 == 0x40 ? UDP6_DECAP_NEXT_LOOKUP_IP4 :
-			       UDP6_DECAP_NEXT_LOOKUP_IP6;
+				     UDP6_DECAP_NEXT_LOOKUP_IP6;
 
 	  hicn_buffer_t *hicnb0, *hicnb1, *hicnb2, *hicnb3;
 	  hicnb0 = hicn_get_buffer (b0);
@@ -534,22 +541,22 @@ udp6_decap_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  if (vnet_buffer (b0)->ip.adj_index[VLIB_RX] != UDP_TUNNEL_INVALID)
 	    hicnb0->flags |=
 	      (outer_v0 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
-				  HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
+					HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
 
 	  if (vnet_buffer (b1)->ip.adj_index[VLIB_RX] != UDP_TUNNEL_INVALID)
 	    hicnb1->flags |=
 	      (outer_v1 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
-				  HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
+					HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
 
 	  if (vnet_buffer (b2)->ip.adj_index[VLIB_RX] != UDP_TUNNEL_INVALID)
 	    hicnb2->flags |=
 	      (outer_v2 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
-				  HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
+					HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
 
 	  if (vnet_buffer (b3)->ip.adj_index[VLIB_RX] != UDP_TUNNEL_INVALID)
 	    hicnb3->flags |=
 	      (outer_v3 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
-				  HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
+					HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
 
 	  udp_decap_trace_buffer (vm, node, 0, b0);
 	  udp_decap_trace_buffer (vm, node, 0, b1);
@@ -610,7 +617,7 @@ udp6_decap_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 				&((ip6_header_t *) outer_ptr0)->dst_address);
 	  udp0 = (udp_header_t *) (outer_ptr0 + sizeof (ip6_header_t));
 	  next0 = v0 == 0x40 ? UDP6_DECAP_NEXT_LOOKUP_IP4 :
-			       UDP6_DECAP_NEXT_LOOKUP_IP6;
+				     UDP6_DECAP_NEXT_LOOKUP_IP6;
 
 	  hicn_buffer_t *hicnb0 = hicn_get_buffer (b0);
 
@@ -620,7 +627,7 @@ udp6_decap_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node,
 	  if (vnet_buffer (b0)->ip.adj_index[VLIB_RX] != UDP_TUNNEL_INVALID)
 	    hicnb0->flags |=
 	      (outer_v0 == 0x40 ? HICN_BUFFER_FLAGS_FROM_UDP4_TUNNEL :
-				  HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
+					HICN_BUFFER_FLAGS_FROM_UDP6_TUNNEL);
 
 	  udp_decap_trace_buffer (vm, node, 0, b0);
 
diff --git a/hicn-plugin/src/udp_tunnels/udp_tunnel.c b/hicn-plugin/src/udp_tunnels/udp_tunnel.c
index 8ea2cb503..d03d6a74e 100644
--- a/hicn-plugin/src/udp_tunnels/udp_tunnel.c
+++ b/hicn-plugin/src/udp_tunnels/udp_tunnel.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -156,6 +156,27 @@ udp_tunnel_get (const ip46_address_t *src_ip, const ip46_address_t *dst_ip,
   return ret == 0 ? (u32) value.value : UDP_TUNNEL_INVALID;
 }
 
+u32
+udp_tunnel_get_create (const ip46_address_t *src_ip,
+		       const ip46_address_t *dst_ip, u16 src_port,
+		       u16 dst_port)
+{
+  u32 ret = udp_tunnel_get (src_ip, dst_ip, src_port, dst_port);
+  if (ret == UDP_TUNNEL_INVALID)
+    {
+      fib_protocol_t proto =
+	ip46_address_is_ip4 (src_ip) ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
+
+      index_t fib_index = fib_table_find (proto, HICN_FIB_TABLE);
+
+      ret = udp_tunnel_add (
+	proto, fib_index, src_ip, dst_ip, clib_net_to_host_u16 (src_port),
+	clib_net_to_host_u16 (dst_port), UDP_ENCAP_FIXUP_NONE);
+    }
+
+  return ret;
+}
+
 void
 udp_tunnel_init ()
 {
@@ -255,8 +276,8 @@ udp_tunnel_command_fn (vlib_main_t *vm, unformat_input_t *main_input,
       int ret = udp_tunnel_del (fproto, fib_index, &src_ip, &dst_ip, src_port,
 				dst_port, UDP_ENCAP_FIXUP_NONE);
       error = (ret == HICN_ERROR_NONE) ?
-		0 :
-		clib_error_return (0, "%s\n", get_error_string (ret));
+		      0 :
+		      clib_error_return (0, "%s\n", get_error_string (ret));
     }
   else
     {
diff --git a/hicn-plugin/src/udp_tunnels/udp_tunnel.h b/hicn-plugin/src/udp_tunnels/udp_tunnel.h
index 2e57b7857..376adf5fa 100644
--- a/hicn-plugin/src/udp_tunnels/udp_tunnel.h
+++ b/hicn-plugin/src/udp_tunnels/udp_tunnel.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -70,6 +70,19 @@ u32 udp_tunnel_get (const ip46_address_t *src_ip, const ip46_address_t *dst_ip,
 		    u16 src_port, u16 dst_port);
 
 /**
+ * @brief Get udp tunnel UEI. Creates the tunnel if does not exist already.
+ *
+ * @param src_ip source address of the tunnel
+ * @param dst_ip destination address of the tunnel
+ * @param src_port source port
+ * @param src_port destination port
+ * @return id of the udp tunnel/encap
+ */
+u32 udp_tunnel_get_create (const ip46_address_t *src_ip,
+			   const ip46_address_t *dst_ip, u16 src_port,
+			   u16 dst_port);
+
+/**
  * @brief Delete a udp tunnel
  *
  * @param proto FIB_PROTOCOL_IP4 or FIB_PROTOCOL_IP6
diff --git a/hicn-plugin/src/utils.h b/hicn-plugin/src/utils.h
index 847f2f388..7a3492732 100644
--- a/hicn-plugin/src/utils.h
+++ b/hicn-plugin/src/utils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/hicn-plugin/vapi/CMakeLists.txt b/hicn-plugin/vapi/CMakeLists.txt
index 6c176b9f3..2005cdaf7 100644
--- a/hicn-plugin/vapi/CMakeLists.txt
+++ b/hicn-plugin/vapi/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,51 +11,102 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
-
-set(SAFE_VAPI safe_vapi CACHE INTERNAL "" FORCE)
+##############################################################
+# Libs and Bins names
+##############################################################
+set(SAFE_VAPI safevapi CACHE INTERNAL "" FORCE)
 set(SAFE_VAPI_SHARED ${SAFE_VAPI}.shared CACHE INTERNAL "" FORCE)
-set(SAFE_VAPI_STATIC ${SAFE_VAPI}.static CACHE INTERNAL "" FORCE)
+set(SAFE_VAPI_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/includes CACHE INTERNAL "" FORCE)
+set(SAFE_VAPI_LIBRARIES ${SAFE_VAPI_SHARED} CACHE INTERNAL "" FORCE)
+
+
+##############################################################
+# Dependencies and third party libs
+##############################################################
+find_package(Vpp ${VPP_DEFAULT_VERSION} EXACT REQUIRED)
 
-# Dependencies
 
-find_package(Vpp REQUIRED)
+##############################################################
+# Check if building as subproject or as root project
+##############################################################
+if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+  include(CommonSetup)
+  find_package(HicnPlugin ${CURRENT_VERSION} EXACT REQUIRED)
+else()
+  list(APPEND DEPENDENCIES
+    ${HICNPLUGIN}
+  )
+endif()
+
 
+##############################################################
+# Sources
+##############################################################
 list(APPEND HEADER_FILES
-     ${CMAKE_CURRENT_SOURCE_DIR}/include/vapi/vapi_safe.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/includes/vapi/vapi_safe.h
 )
 
 list(APPEND SOURCE_FILES
-     ${CMAKE_CURRENT_SOURCE_DIR}/vapi_safe.c
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/vapi_safe.c
 )
 
+
+##############################################################
+# Compiler Options
+##############################################################
+set(COMPILER_OPTIONS
+  ${DEFAULT_COMPILER_OPTIONS}
+  ${MARCH_COMPILER_OPTIONS}
+)
+
+
+##############################################################
+# Libraries to link
+##############################################################
 set (LIBRARIES
-    ${VPP_LIBRARY_VAPICLIENT})
+  ${VPP_LIBRARY_VAPICLIENT}
+)
+
 
+##############################################################
+# Include directories
+##############################################################
 list (APPEND INCLUDE_DIRS
-     ${VPP_INCLUDE_DIR}
-     ${CMAKE_CURRENT_SOURCE_DIR}/include)
+  PUBLIC
+    $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>
+    $<BUILD_INTERFACE:${HICNPLUGIN_INCLUDE_DIRS}>
+    $<BUILD_INTERFACE:${VPP_INCLUDE_DIR}>
+    $<BUILD_INTERFACE:${SAFE_VAPI_INCLUDE_DIRS}>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
 
-build_library(${SAFE_VAPI}
-    SHARED STATIC
-    SOURCES ${SOURCE_FILES} ${HEADER_FILES}
-    INSTALL_HEADERS ${HEADER_FILES}
-    LINK_LIBRARIES ${LIBRARIES}
-    COMPONENT ${HICN_PLUGIN}
-    INCLUDE_DIRS ${INCLUDE_DIRS}
-    HEADER_ROOT_DIR /
-    DEFINITIONS ${COMPILER_DEFINITIONS}
-  )
 
-set(SAFE_VAPI_INCLUDE_DIRS
-  ${CMAKE_CURRENT_SOURCE_DIR}/include
-  "" CACHE INTERNAL
-  "" FORCE
+##############################################################
+# Build library
+##############################################################
+build_library(${SAFE_VAPI}
+  SHARED
+  SOURCES ${SOURCE_FILES} ${HEADER_FILES}
+  INSTALL_HEADERS ${HEADER_FILES}
+  LINK_LIBRARIES PRIVATE ${LIBRARIES}
+  COMPONENT ${HICN_PLUGIN}
+  INCLUDE_DIRS ${INCLUDE_DIRS}
+  HEADER_ROOT_DIR ""
+  DEFINITIONS PUBLIC ${COMPILER_DEFINITIONS}
+  DEPENDS ${HICNPLUGIN}.shared
+  VERSION ${CURRENT_VERSION}
+  EXPORT_NAME "libsafevapi"
+  COMPILE_OPTIONS ${COMPILER_OPTIONS}
 )
 
-set(SAFE_VAPI_LIBRARIES
-  ${SAFE_VAPI_SHARED}
-  "" CACHE INTERNAL
-  "" FORCE
-)
 
+##############################################################
+# Create cmake configuration
+##############################################################
+create_cmake_config (
+  "libsafevapi"
+  INCLUDE_DIRS ${SAFE_VAPI_INCLUDE_DIRS}
+  VERSION ${CURRENT_VERSION}
+  COMPONENT ${HICN_PLUGIN}
+  NAMESPACE hicn
+)
diff --git a/hicn-plugin/vapi/include/vapi/vapi_safe.h b/hicn-plugin/vapi/include/vapi/vapi_safe.h
deleted file mode 100644
index df1114cde..000000000
--- a/hicn-plugin/vapi/include/vapi/vapi_safe.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef VAPI_SAFE
-#include <vapi/vapi.h>
-#include <pthread.h>
-
-extern pthread_mutex_t *mutex;
-
-vapi_error_e vapi_connect_safe(vapi_ctx_t * vapi_ctx_ret, int async);
-
-vapi_error_e vapi_disconnect_safe();
-void vapi_lock();
-
-void vapi_unlock();
-
-#define VAPI_SAFE (NAME, res, ...)		\
-    vapi_lock();                                \
-    res = ## NAME (__ARGS__);			\
-    vapi_unlock();
-
-#endif //VAPI_SAFE
diff --git a/hicn-light/src/hicn/config/controlAddPunting.h b/hicn-plugin/vapi/includes/vapi/vapi_safe.h
index 9cab76359..423034730 100644
--- a/hicn-light/src/hicn/config/controlAddPunting.h
+++ b/hicn-plugin/vapi/includes/vapi/vapi_safe.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,10 +13,21 @@
  * limitations under the License.
  */
 
-#ifndef controlAddPunting_h
-#define controlAddPunting_h
+#ifndef __VAPI_SAFE__
+#define __VAPI_SAFE__
+
+#include <vapi/vapi.h>
+#include <pthread.h>
+
+#include <vapi/hicn.api.vapi.h>
+#include <vapi/interface.api.vapi.h>
+#include <vapi/ip.api.vapi.h>
+#include <vapi/memif.api.vapi.h>
+#include <vapi/udp.api.vapi.h>
+
+vapi_error_e vapi_connect_safe (vapi_ctx_t *vapi_ctx_ret, int async);
+vapi_error_e vapi_disconnect_safe ();
+void vapi_lock ();
+void vapi_unlock ();
 
-#include <hicn/config/controlState.h>
-CommandOps *controlAddPunting_Create(ControlState *state);
-CommandOps *controlAddPunting_HelpCreate(ControlState *state);
 #endif
diff --git a/hicn-plugin/vapi/libsafevapi-config.cmake.in b/hicn-plugin/vapi/libsafevapi-config.cmake.in
new file mode 100644
index 000000000..feb278c1f
--- /dev/null
+++ b/hicn-plugin/vapi/libsafevapi-config.cmake.in
@@ -0,0 +1,8 @@
+@PACKAGE_INIT@
+
+set(Libsafevapi_VERSION_MAJOR "@VERSION_MAJOR@")
+set(Libsafevapi_VERSION_MINOR "@VERSION_MINOR@")
+set(Libsafevapi_VERSION_PATCH "@VERSION_PATCH@")
+
+set_and_check(Libsafe_vapi_INCLUDE_DIRS  "@PACKAGE_Libsafevapi_INCLUDE_DIRS@")
+include("${CMAKE_CURRENT_LIST_DIR}/libsafevapi-targets.cmake")
diff --git a/hicn-plugin/vapi/src/vapi_safe.c b/hicn-plugin/vapi/src/vapi_safe.c
new file mode 100644
index 000000000..a91793674
--- /dev/null
+++ b/hicn-plugin/vapi/src/vapi_safe.c
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <vapi/vapi_safe.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define APP_NAME		 "hicn_plugin"
+#define MAX_OUTSTANDING_REQUESTS 4
+#define RESPONSE_QUEUE_SIZE	 2
+
+DEFINE_VAPI_MSG_IDS_HICN_API_JSON
+DEFINE_VAPI_MSG_IDS_INTERFACE_API_JSON
+DEFINE_VAPI_MSG_IDS_IP_API_JSON
+DEFINE_VAPI_MSG_IDS_UDP_API_JSON
+DEFINE_VAPI_MSG_IDS_MEMIF_API_JSON
+
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+vapi_ctx_t g_vapi_ctx_instance = NULL;
+u32 count = 0;
+
+vapi_error_e
+vapi_connect_safe (vapi_ctx_t *vapi_ctx_ret, int async)
+{
+  vapi_error_e rv = VAPI_OK;
+
+  vapi_lock ();
+
+  if (!g_vapi_ctx_instance)
+    {
+      rv = vapi_ctx_alloc (&g_vapi_ctx_instance);
+      if (rv != VAPI_OK)
+	goto err;
+    }
+
+  if (!count)
+    {
+      rv = vapi_connect (g_vapi_ctx_instance, APP_NAME, NULL,
+			 MAX_OUTSTANDING_REQUESTS, RESPONSE_QUEUE_SIZE,
+			 async ? VAPI_MODE_NONBLOCKING : VAPI_MODE_BLOCKING,
+			 true);
+
+      if (rv != VAPI_OK)
+	goto err;
+    }
+
+  count++;
+  *vapi_ctx_ret = g_vapi_ctx_instance;
+
+  vapi_unlock ();
+  return rv;
+
+err:
+  vapi_unlock ();
+  return VAPI_ENOMEM;
+}
+
+vapi_error_e
+vapi_disconnect_safe ()
+{
+  vapi_error_e rv = VAPI_OK;
+
+  vapi_lock ();
+  count--;
+  if (count == 0)
+    {
+      rv = vapi_disconnect (g_vapi_ctx_instance);
+      vapi_ctx_free (g_vapi_ctx_instance);
+      g_vapi_ctx_instance = NULL;
+    }
+  vapi_unlock ();
+
+  return rv;
+}
+
+void
+vapi_lock ()
+{
+  pthread_mutex_lock (&mutex);
+}
+
+void
+vapi_unlock ()
+{
+  pthread_mutex_unlock (&mutex);
+}
diff --git a/hicn-plugin/vapi/vapi_safe.c b/hicn-plugin/vapi/vapi_safe.c
deleted file mode 100644
index e9353497f..000000000
--- a/hicn-plugin/vapi/vapi_safe.c
+++ /dev/null
@@ -1,73 +0,0 @@
-#include <vapi/vapi_safe.h>
-#include <stdlib.h>
-#include <stdio.h>
-
-#define APP_NAME "hicn_plugin"
-#define MAX_OUTSTANDING_REQUESTS 4
-#define RESPONSE_QUEUE_SIZE 2
-
-pthread_mutex_t *mutex = NULL;
-vapi_ctx_t g_vapi_ctx_instance = NULL;
-u32 count = 0;
-int lock = 0;
-
-vapi_error_e vapi_connect_safe(vapi_ctx_t *vapi_ctx_ret, int async) {
-  vapi_error_e rv = VAPI_OK;
-
-  while (!__sync_bool_compare_and_swap(&lock, 0, 1));
-
-  if (!g_vapi_ctx_instance && !mutex)
-    {
-      rv = vapi_ctx_alloc(&g_vapi_ctx_instance);
-      if (rv != VAPI_OK)
-	goto err;
-
-      mutex = malloc(sizeof(pthread_mutex_t));
-      if (!mutex)
-	goto err_mutex_alloc;
-
-      if (pthread_mutex_init(mutex, NULL) != 0) {
-	printf("Mutex init failed\n");
-	goto err_mutex_init;
-      }
-    }
-
-  if (!count)
-    {
-      rv = vapi_connect(g_vapi_ctx_instance, APP_NAME, NULL,
-			MAX_OUTSTANDING_REQUESTS, RESPONSE_QUEUE_SIZE,
-			async ? VAPI_MODE_NONBLOCKING : VAPI_MODE_BLOCKING, true);
-
-      if (rv != VAPI_OK)
-	goto err;
-
-      count++;
-    }
-
-  *vapi_ctx_ret = g_vapi_ctx_instance;
-
-  while (!__sync_bool_compare_and_swap(&lock, 1, 0));
-  return rv;
-
- err_mutex_init:
-  free(mutex);
- err_mutex_alloc:
- err:
-  while (!__sync_bool_compare_and_swap(&lock, 1, 0));
-  return VAPI_ENOMEM;
-}
-
-vapi_error_e vapi_disconnect_safe() {
-  pthread_mutex_lock(mutex);
-  vapi_error_e rv = VAPI_OK;
-  pthread_mutex_unlock(mutex);
-  return rv;
-}
-
-void vapi_lock() {
-  pthread_mutex_lock(mutex);
-}
-
-void vapi_unlock() {
-  pthread_mutex_unlock(mutex);
-}
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 65c1cd4ee..ca845ab48 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,41 +11,50 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+##############################################################
+# Project and cmake version
+##############################################################
 cmake_minimum_required (VERSION 3.10 FATAL_ERROR)
 project(libhicn C)
-#include(CTest)
 
+
+##############################################################
+# Cmake modules
+##############################################################
 set(CMAKE_MODULE_PATH
   ${CMAKE_MODULE_PATH}
   "${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Modules"
-  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
 )
 
-if (NOT CMAKE_BUILD_TYPE)
-	message(STATUS "${PROJECT_NAME}: No build type selected, default to Release")
-	set(CMAKE_BUILD_TYPE "Release")
+if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+  include(CommonSetup)
 endif()
 
+
+##############################################################
+# Libs and Bins names
+##############################################################
 set(LIBHICN hicn CACHE INTERNAL "" FORCE)
+set(LIBHICN_COMPONENT lib${LIBHICN} CACHE INTERNAL "" FORCE)
 set(LIBHICN_SHARED ${LIBHICN}.shared CACHE INTERNAL "" FORCE)
 set(LIBHICN_STATIC ${LIBHICN}.static CACHE INTERNAL "" FORCE)
-set(HICN_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/includes CACHE INTERNAL "" FORCE)
-
-include (Packaging)
 
-option(CMAKE_BUILD_TEST "Build unit tests" OFF)
+##############################################################
+# Dependencies
+##############################################################
 
-if (NOT CMAKE_BUILD_TYPE)
-	message(STATUS "${PROJECT_NAME}: No build type selected, default to Release")
-	set(CMAKE_BUILD_TYPE "Release")
+if(INTERNAL_ENVIRONMENT)
+  include(ImportInternal)
+  ImportInternal()
+  set(INTERNAL_ENVIRONMENT_FOUND True CACHE STRING "Internal dependency found")
 endif()
 
-if (NOT WIN32)
-  set(CMAKE_C_FLAGS -Wall)
-else ()
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4996")
-endif ()
+##############################################################
+# Packaging and versioning
+##############################################################
+include(${CMAKE_CURRENT_SOURCE_DIR}/../versions.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/packaging.cmake)
 
-add_subdirectory(includes)
-add_subdirectory (src)
 
+add_subdirectory(includes)
+add_subdirectory(src)
diff --git a/lib/cmake/Modules/Packaging.cmake b/lib/cmake/packaging.cmake
index 2ceda1426..5f1691722 100644
--- a/lib/cmake/Modules/Packaging.cmake
+++ b/lib/cmake/packaging.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -32,11 +32,21 @@ set(lib${LIBHICN}-dev_DESCRIPTION ${${LIBHICN}_DESCRIPTION}
 )
 
 set(lib${LIBHICN}-dev_DEB_DEPENDENCIES
-	"libhicn (>= stable_version)"
+	"libhicn (= stable_version)"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
+
+if (INTERNAL_ENVIRONMENT)
+  include(CheckSafeC)
+  CheckSafeC()
+  set(lib${LIBHICN}-dev_DEB_DEPENDENCIES
+    "${lib${LIBHICN}-dev_DEB_DEPENDENCIES}, ${SAFEC_DEPENDENCY}"
+    CACHE STRING "Dependencies for deb/rpm package."
+  )
+endif()
+
 set(lib${LIBHICN}-dev_RPM_DEPENDENCIES
-  "libhicn >= stable_version"
+  "libhicn = stable_version"
   CACHE STRING "Dependencies for deb/rpm package."
 )
diff --git a/lib/includes/CMakeLists.txt b/lib/includes/CMakeLists.txt
index 6c2c34b86..821feb2bb 100644
--- a/lib/includes/CMakeLists.txt
+++ b/lib/includes/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,8 +11,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-set(HICN_INCLUDE_DIRS
-  ${CMAKE_CURRENT_SOURCE_DIR} ""
+##############################################################
+# Public headers directory
+##############################################################
+set(Libhicn_INCLUDE_DIRS
+  ${CMAKE_CURRENT_SOURCE_DIR}
   CACHE INTERNAL
   "" FORCE
 )
@@ -23,12 +26,15 @@ set(LIBHICN_HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/common.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/compat.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/error.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn/face.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/header.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/mapme.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/name.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/policy.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/protocol.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/ops.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn/strategy.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn/validation.h
   PARENT_SCOPE
 )
 
@@ -40,19 +46,14 @@ set(LIBHICN_HEADER_FILES_PROTOCOL
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/protocol/ipv6.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/protocol/tcp.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/protocol/udp.h
-  PARENT_SCOPE
-)
-
-set(LIBHICN_HEADER_FILES_UTIL
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn/protocol/new.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/array.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/ip_address.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/log.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/map.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/set.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/sstrncpy.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/token.h
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/types.h
   PARENT_SCOPE
 )
-
-set_property(GLOBAL PROPERTY LIBHICN_HEADER_FILES_UTIL_PROPERTY "${LIBHICN_HEADER_FILES_UTIL}")
-
diff --git a/lib/includes/hicn/base.h b/lib/includes/hicn/base.h
index 1061724ce..844814d57 100644
--- a/lib/includes/hicn/base.h
+++ b/lib/includes/hicn/base.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -34,16 +34,17 @@ typedef u32 hicn_faceid_t;
 typedef u8 hicn_pathlabel_t;
 typedef u32 hicn_lifetime_t;
 
-#define HICN_MAX_LIFETIME_SCALED 0xFFFF
-#define HICN_MAX_LIFETIME_MULTIPLIER 0x0F	/* 4 bits */
-#define HICN_MAX_LIFETIME HICN_MAX_LIFETIME_SCALED << HICN_MAX_LIFETIME_MULTIPLIER
+#define HICN_MAX_LIFETIME_SCALED     0xFFFF
+#define HICN_MAX_LIFETIME_MULTIPLIER 0x0F /* 4 bits */
+#define HICN_MAX_LIFETIME                                                     \
+  HICN_MAX_LIFETIME_SCALED << HICN_MAX_LIFETIME_MULTIPLIER
 
 /**
  * @brief hICN packet format type
  *
- * The hICN type represents the sequence of protocols that we can find in packet
- * headers. They are represented as a quartet of u8 values, correponding to
- * IANA protocol assignment, and read from right to left. This is done to
+ * The hICN type represents the sequence of protocols that we can find in
+ * packet headers. They are represented as a quartet of u8 values, correponding
+ * to IANA protocol assignment, and read from right to left. This is done to
  * faciliate decapsulation of packet header by simple shift/mask operations.
  *
  * For instance, an IPv6/TCP packet will be identified as :
@@ -55,19 +56,19 @@ typedef u32 hicn_lifetime_t;
  */
 typedef union
 {
-    /** protocol layers representation */
+  /** protocol layers representation */
   struct
   {
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    u8 l1;     /**< First layer */
-    u8 l2;     /**< Second layer */
-    u8 l3;     /**< Third layer */
-    u8 l4;     /**< Fourth layer */
+    u8 l1; /**< First layer */
+    u8 l2; /**< Second layer */
+    u8 l3; /**< Third layer */
+    u8 l4; /**< Fourth layer */
 #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-    u8 l4;     /**< Fourth layer */
-    u8 l3;     /**< Third layer */
-    u8 l2;     /**< Second layer */
-    u8 l1;     /**< First layer */
+    u8 l4; /**< Fourth layer */
+    u8 l3; /**< Third layer */
+    u8 l2; /**< Second layer */
+    u8 l1; /**< First layer */
 #elif _WIN32 /* Windows is assumed little-endian */
     u8 l1;
     u8 l2;
@@ -77,46 +78,73 @@ typedef union
 #error "Unsupported endianness"
 #endif
   };
-    /** u32 representation */
+  /** u32 representation */
   u32 as_u32;
 } hicn_type_t;
 
 /* Common protocol layers */
 /* Common protocol layers */
 #ifndef _WIN32
-#define HICN_TYPE(x,y,z,t) (hicn_type_t) {{ .l1 = x, .l2 = y, .l3 = z, .l4 = t }}
+#define HICN_TYPE(x, y, z, t)                                                 \
+  (hicn_type_t)                                                               \
+  {                                                                           \
+    {                                                                         \
+      .l1 = x, .l2 = y, .l3 = z, .l4 = t                                      \
+    }                                                                         \
+  }
 #else
 inline hicn_type_t
-HICN_TYPE(int x, int y, int z, int t)
+HICN_TYPE (int x, int y, int z, int t)
 {
-    hicn_type_t type;
-    type.l1 = x;
-    type.l2 = y;
-    type.l3 = z;
-    type.l4 = t;
-    return type;
+  hicn_type_t type;
+  type.l1 = x;
+  type.l2 = y;
+  type.l3 = z;
+  type.l4 = t;
+  return type;
 }
 #endif
 
-#define HICN_TYPE_IPV4_TCP     HICN_TYPE(IPPROTO_IP,   IPPROTO_TCP,    IPPROTO_NONE, IPPROTO_NONE)
-#define HICN_TYPE_IPV4_ICMP    HICN_TYPE(IPPROTO_IP,   IPPROTO_ICMP,   IPPROTO_NONE, IPPROTO_NONE)
-#define HICN_TYPE_IPV6_TCP     HICN_TYPE(IPPROTO_IPV6, IPPROTO_TCP,    IPPROTO_NONE, IPPROTO_NONE)
-#define HICN_TYPE_IPV6_ICMP    HICN_TYPE(IPPROTO_IPV6, IPPROTO_ICMPV6, IPPROTO_NONE, IPPROTO_NONE)
-#define HICN_TYPE_IPV4_TCP_AH  HICN_TYPE(IPPROTO_IP,   IPPROTO_TCP,    IPPROTO_AH,   IPPROTO_NONE)
-#define HICN_TYPE_IPV4_ICMP_AH HICN_TYPE(IPPROTO_IP,   IPPROTO_ICMP,   IPPROTO_AH,   IPPROTO_NONE)
-#define HICN_TYPE_IPV6_TCP_AH  HICN_TYPE(IPPROTO_IPV6, IPPROTO_TCP,    IPPROTO_AH,   IPPROTO_NONE)
-#define HICN_TYPE_IPV6_ICMP_AH HICN_TYPE(IPPROTO_IPV6, IPPROTO_ICMPV6, IPPROTO_AH,   IPPROTO_NONE)
-#define HICN_TYPE_NONE         HICN_TYPE(IPPROTO_NONE, IPPROTO_NONE,   IPPROTO_NONE, IPPROTO_NONE)
+#define HICN_TYPE_IPV4_TCP                                                    \
+  HICN_TYPE (IPPROTO_IP, IPPROTO_TCP, IPPROTO_NONE, IPPROTO_NONE)
+#define HICN_TYPE_IPV4_ICMP                                                   \
+  HICN_TYPE (IPPROTO_IP, IPPROTO_ICMP, IPPROTO_NONE, IPPROTO_NONE)
+#define HICN_TYPE_IPV6_TCP                                                    \
+  HICN_TYPE (IPPROTO_IPV6, IPPROTO_TCP, IPPROTO_NONE, IPPROTO_NONE)
+#define HICN_TYPE_IPV6_ICMP                                                   \
+  HICN_TYPE (IPPROTO_IPV6, IPPROTO_ICMPV6, IPPROTO_NONE, IPPROTO_NONE)
+#define HICN_TYPE_NEW                                                         \
+  HICN_TYPE (IPPROTO_ENCAP, IPPROTO_NONE, IPPROTO_NONE, IPPROTO_NONE)
+#define HICN_TYPE_IPV4_UDP                                                    \
+  HICN_TYPE (IPPROTO_IP, IPPROTO_UDP, IPPROTO_ENCAP, IPPROTO_NONE)
+#define HICN_TYPE_IPV6_UDP                                                    \
+  HICN_TYPE (IPPROTO_IPV6, IPPROTO_UDP, IPPROTO_ENCAP, IPPROTO_NONE)
+#define HICN_TYPE_IPV4_TCP_AH                                                 \
+  HICN_TYPE (IPPROTO_IP, IPPROTO_TCP, IPPROTO_AH, IPPROTO_NONE)
+#define HICN_TYPE_IPV4_ICMP_AH                                                \
+  HICN_TYPE (IPPROTO_IP, IPPROTO_ICMP, IPPROTO_AH, IPPROTO_NONE)
+#define HICN_TYPE_IPV6_TCP_AH                                                 \
+  HICN_TYPE (IPPROTO_IPV6, IPPROTO_TCP, IPPROTO_AH, IPPROTO_NONE)
+#define HICN_TYPE_IPV6_ICMP_AH                                                \
+  HICN_TYPE (IPPROTO_IPV6, IPPROTO_ICMPV6, IPPROTO_AH, IPPROTO_NONE)
+#define HICN_TYPE_NEW_AH                                                      \
+  HICN_TYPE (IPPROTO_ENCAP, IPPROTO_AH, IPPROTO_NONE, IPPROTO_NONE)
+#define HICN_TYPE_IPV6_UDP_AH                                                 \
+  HICN_TYPE (IPPROTO_IPV6, IPPROTO_UDP, IPPROTO_ENCAP, IPPROTO_AH)
+#define HICN_TYPE_IPV4_UDP_AH                                                 \
+  HICN_TYPE (IPPROTO_IP, IPPROTO_UDP, IPPROTO_ENCAP, IPPROTO_AH)
+#define HICN_TYPE_NONE                                                        \
+  HICN_TYPE (IPPROTO_NONE, IPPROTO_NONE, IPPROTO_NONE, IPPROTO_NONE)
 
 /**
  * @brief Check if type is none.
  * @return 1 if none, 0 otherwise
  */
-always_inline int
-hicn_type_is_none(hicn_type_t type)
+static inline int
+hicn_type_is_none (hicn_type_t type)
 {
   return (type.l1 == IPPROTO_NONE) && (type.l2 == IPPROTO_NONE) &&
-         (type.l3 == IPPROTO_NONE) && (type.l4 == IPPROTO_NONE);
+	 (type.l3 == IPPROTO_NONE) && (type.l4 == IPPROTO_NONE);
 }
 
 /**
@@ -151,11 +179,12 @@ typedef enum
  * @param [in] face_id The face identifier to combine into the path label
  * @param [out] new_label Computed pathlabel
  *
- * This function updates the current_label based on the new face_id, and returns
+ * This function updates the current_label based on the new face_id, and
+ * returns
  */
-always_inline void
+static inline void
 update_pathlabel (hicn_pathlabel_t current_label, hicn_faceid_t face_id,
-		  hicn_pathlabel_t * new_label)
+		  hicn_pathlabel_t *new_label)
 {
   hicn_pathlabel_t pl_face_id =
     (hicn_pathlabel_t) (face_id & HICN_PATH_LABEL_MASK);
diff --git a/lib/includes/hicn/common.h b/lib/includes/hicn/common.h
index 05f8ad95f..b0898ce1f 100644
--- a/lib/includes/hicn/common.h
+++ b/lib/includes/hicn/common.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -51,13 +51,17 @@ typedef uint8_t u8;
 
 #ifndef HICN_VPP_PLUGIN
 
-#define PREDICT_FALSE(x) (x)
-#define PREDICT_TRUE(x) (x)
-#define always_inline static inline
-#define static_always_inline static inline
-#define STRUCT_SIZE_OF(type, member) sizeof(((type *)0)->member)
+#define PREDICT_FALSE(x)	     (x)
+#define PREDICT_TRUE(x)		     (x)
+#define STRUCT_SIZE_OF(type, member) sizeof (((type *) 0)->member)
 #define ASSERT
 
+#ifndef NDEBUG
+#define _ASSERT(x) assert (x)
+#else
+#define _ASSERT(x) ((void) (x))
+#endif
+
 #define STATIC_ASSERT(x)
 
 /* Architecture-dependent uword size */
@@ -82,13 +86,17 @@ typedef u32 uword;
 
 typedef uword ip_csum_t;
 
+#else
+
+#include <vppinfra/clib.h>
+
 #endif /* ! HICN_VPP_PLUGIN */
 
 /*
- * Windows compilers do not support named initilizers when .h files are included
- * inside C++ files. For readability, we either use the following macro, or
- * duplicate some code, with the intent of preserving those safeguards for
- * non-Windows platforms.
+ * Windows compilers do not support named initilizers when .h files are
+ * included inside C++ files. For readability, we either use the following
+ * macro, or duplicate some code, with the intent of preserving those
+ * safeguards for non-Windows platforms.
  */
 #ifndef _WIN32
 #define ATTR_INIT(key, value) .key = value
@@ -97,12 +105,12 @@ typedef uword ip_csum_t;
 #endif
 
 #ifdef _WIN32
- /* Endianness detection for Windows platforms */
+/* Endianness detection for Windows platforms */
 #define __ORDER_LITTLE_ENDIAN__ 0x41424344UL
-#define __ORDER_BIG_ENDIAN__    0x44434241UL
-#define __BYTE_ORDER__ ('ABCD')
+#define __ORDER_BIG_ENDIAN__	0x44434241UL
+#define __BYTE_ORDER__		('ABCD')
 
- /* Windows compatibility headers */
+/* Windows compatibility headers */
 #define WIN32_LEAN_AND_MEAN
 #ifndef NOMINMAX
 #define NOMINMAX
@@ -116,10 +124,10 @@ typedef uword ip_csum_t;
 #define strdup _strdup
 #define __attribute__(A)
 
-#ifndef  IOVEC
+#ifndef IOVEC
 #define IOVEC
 #define UIO_MAXIOV 16
-#define IOV_MAX UIO_MAXIOV
+#define IOV_MAX	   UIO_MAXIOV
 struct iovec
 {
   void *iov_base;
@@ -132,66 +140,20 @@ struct iovec
  * Portable attribute packed.
  */
 #ifndef _WIN32
-#define PACKED( __Declaration__ ) __Declaration__ __attribute__((__packed__))
+#define PACKED(__Declaration__) __Declaration__ __attribute__ ((__packed__))
 #else
-#define PACKED( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop) )
+#define PACKED(__Declaration__)                                               \
+  __pragma (pack (push, 1)) __Declaration__ __pragma (pack (pop))
 #endif
 
-
 /*
  * IP address types
  */
 
-#ifdef HICN_VPP_PLUGIN
-
-#include <vnet/ip/ip4_packet.h>	// ip4_address_t
-#include <vnet/ip/ip6_packet.h>	// ip6_address_t
-
-#if __GNUC__ >= 9
-#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
-#endif
-
-#include <vnet/ip/ip46_address.h>
-
-#if __GNUC__ >= 9
-#pragma GCC diagnostic pop
-#endif
-
-#else
-
-
 #ifndef _WIN32
 #include <netinet/in.h>
 #endif
 
-typedef union
-{
-  u32 as_u32;
-  struct in_addr as_inaddr;
-} ip4_address_t;
-
-typedef union
-{
-  u64 as_u64[2];
-  u32 as_u32[4];
-  u8 as_u8[16];
-  struct in6_addr as_in6addr;
-} ip6_address_t;
-
-typedef union
-{
-  struct
-  {
-    u32 pad[3];
-    ip4_address_t ip4;
-  };
-  ip6_address_t ip6;
-} ip46_address_t;
-
-#define ip46_address_is_ip4(ip46)       (((ip46)->pad[0] | (ip46)->pad[1] | (ip46)->pad[2]) == 0)
-
-#endif /* ! HICN_VPP_PLUGIN */
-
 /**
  * @brief Returns the family of an IP address
  * @param [in] ip_address - IP address in presentation format
@@ -215,7 +177,7 @@ int get_addr_family (const char *ip_address);
  * borrow this code here.
  */
 
-static_always_inline u16
+static inline u16
 ip_csum_fold (ip_csum_t c)
 {
   /* Reduce to 16 bits. */
@@ -227,10 +189,10 @@ ip_csum_fold (ip_csum_t c)
   c = (c & 0xffff) + (c >> 16);
   c = (c & 0xffff) + (c >> 16);
 
-  return (u16)c;
+  return (u16) c;
 }
 
-static_always_inline ip_csum_t
+static inline ip_csum_t
 ip_csum_with_carry (ip_csum_t sum, ip_csum_t x)
 {
   ip_csum_t t = sum + x;
@@ -238,7 +200,7 @@ ip_csum_with_carry (ip_csum_t sum, ip_csum_t x)
 }
 
 /* Update checksum changing field at even byte offset from x -> 0. */
-static_always_inline ip_csum_t
+static inline ip_csum_t
 ip_csum_add_even (ip_csum_t c, ip_csum_t x)
 {
   ip_csum_t d;
@@ -252,19 +214,19 @@ ip_csum_add_even (ip_csum_t c, ip_csum_t x)
 }
 
 /* Update checksum changing field at even byte offset from 0 -> x. */
-static_always_inline ip_csum_t
+static inline ip_csum_t
 ip_csum_sub_even (ip_csum_t c, ip_csum_t x)
 {
   return ip_csum_with_carry (c, x);
 }
 
+#endif /* ! HICN_VPP_PLUGIN */
+
 u32 cumulative_hash32 (const void *data, size_t len, u32 lastValue);
 u32 hash32 (const void *data, size_t len);
 u64 cumulative_hash64 (const void *data, size_t len, u64 lastValue);
 u64 hash64 (const void *data, size_t len);
-void hicn_packet_dump (const uint8_t * buffer, size_t len);
-
-#endif /* ! HICN_VPP_PLUGIN */
+void hicn_packet_dump (const uint8_t *buffer, size_t len);
 
 /**
  * @brief Computes buffer checksum
@@ -273,7 +235,7 @@ void hicn_packet_dump (const uint8_t * buffer, size_t len);
  * @param [in] init - Checksum initial value
  * @return Checksum of specified buffer
  */
-always_inline u16
+static inline u16
 csum (const void *addr, size_t size, u16 init)
 {
   u32 sum = init;
@@ -291,7 +253,7 @@ csum (const void *addr, size_t size, u16 init)
   sum = (sum >> 16) + (sum & 0xffff);
   sum += (sum >> 16);
 
-  return (u16) ~ sum;
+  return (u16) ~sum;
 }
 
 /*
@@ -305,17 +267,24 @@ csum (const void *addr, size_t size, u16 init)
  * Query IP version from packet (either 4 or 6)
  * (version is located as same offsets in both protocol headers)
  */
-#define HICN_IP_VERSION(packet) ((hicn_header_t *)packet)->v4.ip.version
+#define HICN_IP_VERSION(packet)                                               \
+  ((hicn_header_t *) packet)->protocol.ipv4.version
 
 /*
  * ntohll / htonll allows byte swapping for 64 bits integers
  */
 #ifndef htonll
-#define htonll(x) ((1==htonl(1)) ? (x) : ((uint64_t)htonl((x) & 0xFFFFFFFF) << 32) | htonl((x) >> 32))
+#define htonll(x)                                                             \
+  ((1 == htonl (1)) ?                                                         \
+	   (x) :                                                                    \
+	   ((uint64_t) htonl ((x) &0xFFFFFFFF) << 32) | htonl ((x) >> 32))
 #endif
 
 #ifndef ntohll
-#define ntohll(x) ((1==ntohl(1)) ? (x) : ((uint64_t)ntohl((x) & 0xFFFFFFFF) << 32) | ntohl((x) >> 32))
+#define ntohll(x)                                                             \
+  ((1 == ntohl (1)) ?                                                         \
+	   (x) :                                                                    \
+	   ((uint64_t) ntohl ((x) &0xFFFFFFFF) << 32) | ntohl ((x) >> 32))
 #endif
 
 #endif /* HICN_COMMON_H */
diff --git a/lib/includes/hicn/compat.h b/lib/includes/hicn/compat.h
index 486c82348..8de3f9d7e 100644
--- a/lib/includes/hicn/compat.h
+++ b/lib/includes/hicn/compat.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -35,14 +35,18 @@
 #define HFO_INET  1 << 0
 #define HFO_INET6 1 << 1
 #define HFO_TCP	  1 << 2
-#define HFO_ICMP  1 << 3
-#define HFO_AH	  1 << 4
+#define HFO_UDP	  1 << 3
+#define HFO_ICMP  1 << 4
+#define HFO_CMPR  1 << 5
+#define HFO_AH	  1 << 6
 
 #define _is_ipv4(format) ((format & HFO_INET))
 #define _is_ipv6(format) ((format & HFO_INET6) >> 1)
 #define _is_tcp(format)	 ((format & HFO_TCP) >> 2)
-#define _is_icmp(format) ((format & HFO_ICMP) >> 3)
-#define _is_ah(format)	 ((format & HFO_AH) >> 4)
+#define _is_udp(format)	 ((format & HFO_UDP) >> 3)
+#define _is_icmp(format) ((format & HFO_ICMP) >> 4)
+#define _is_cmpr(format) ((format & HFO_CMPR) >> 5)
+#define _is_ah(format)	 ((format & HFO_AH) >> 6)
 
 typedef enum
 {
@@ -51,13 +55,32 @@ typedef enum
   HF_INET6_TCP = HFO_INET6 | HFO_TCP,
   HF_INET_ICMP = HFO_INET | HFO_ICMP,
   HF_INET6_ICMP = HFO_INET6 | HFO_ICMP,
+  HF_NEW = HFO_CMPR,
+  HF_INET_UDP = HFO_INET | HFO_UDP | HFO_CMPR,
+  HF_INET6_UDP = HFO_INET6 | HFO_UDP | HFO_CMPR,
   HF_INET_TCP_AH = HFO_INET | HFO_TCP | HFO_AH,
   HF_INET6_TCP_AH = HFO_INET6 | HFO_TCP | HFO_AH,
   HF_INET_ICMP_AH = HFO_INET | HFO_ICMP | HFO_AH,
   HF_INET6_ICMP_AH = HFO_INET6 | HFO_ICMP | HFO_AH,
+  HF_NEW_AH = HFO_CMPR | HFO_AH,
+  HF_INET_UDP_AH = HFO_INET | HFO_UDP | HFO_CMPR | HFO_AH,
+  HF_INET6_UDP_AH = HFO_INET6 | HFO_UDP | HFO_CMPR | HFO_AH,
 } hicn_format_t;
 
 /**
+ * @brief Add AH header to current format. E.g. if format is IP + TCP, this
+ * will change it to IP = TCP + AH
+ *
+ * @param [in] format - The input format
+ * @return The format with the AH bit set to 1
+ */
+static inline hicn_format_t
+hicn_get_ah_format (hicn_format_t format)
+{
+  return (hicn_format_t) (format | HFO_AH);
+}
+
+/**
  * Minimum required header length to determine the type and length of a
  * supposed hICN packet. This should be equal to the maximum value over all
  * possible hICN packet formats, and less than the minimum possible IP packet
@@ -351,18 +374,49 @@ int hicn_packet_get_hoplimit (const hicn_header_t *packet, u8 *hops);
  */
 int hicn_packet_set_hoplimit (hicn_header_t *packet, u8 hops);
 
+/**
+ * @brief Check if this packet is interest
+ *
+ * @param format - hICN format
+ * @param packet - Packet header
+ * @return hICN error code
+ */
+int hicn_packet_is_interest (hicn_format_t format, const hicn_header_t *h,
+			     int *ret);
+
+/**
+ * @brief Mark this packet as interest
+ *
+ * @param format - hICN format
+ * @param packet - Packet header
+ * @return hICN error code
+ */
+int hicn_packet_set_interest (hicn_format_t format, hicn_header_t *packet);
+
+/**
+ * @brief Mark this packet as data
+ *
+ * @param format - hICN format
+ * @param packet - Packet header
+ * @return hICN error code
+ */
+int hicn_packet_set_data (hicn_format_t format, hicn_header_t *h);
+
 int hicn_packet_copy_header (hicn_format_t format, const hicn_header_t *packet,
 			     hicn_header_t *destination, bool copy_ah);
 
-int hicn_packet_get_lifetime (const hicn_header_t *packet, u32 *lifetime);
-int hicn_packet_set_lifetime (hicn_header_t *packet, u32 lifetime);
+int hicn_packet_get_lifetime (hicn_format_t format,
+			      const hicn_header_t *packet, u32 *lifetime);
+int hicn_packet_set_lifetime (hicn_format_t format, hicn_header_t *packet,
+			      u32 lifetime);
 int hicn_packet_get_reserved_bits (const hicn_header_t *packet,
 				   u8 *reserved_bits);
 int hicn_packet_set_reserved_bits (hicn_header_t *packet,
 				   const u8 reserved_bits);
-int hicn_packet_get_payload_type (const hicn_header_t *packet,
+int hicn_packet_get_payload_type (hicn_format_t format,
+				  const hicn_header_t *packet,
 				  hicn_payload_type_t *payload_type);
-int hicn_packet_set_payload_type (hicn_header_t *packet,
+int hicn_packet_set_payload_type (hicn_format_t format, hicn_header_t *packet,
 				  const hicn_payload_type_t payload_type);
 
 int hicn_packet_set_syn (hicn_format_t format, hicn_header_t *packet);
@@ -454,10 +508,14 @@ int hicn_data_get_payload_type (const hicn_header_t *data,
 int hicn_data_set_payload_type (hicn_header_t *data,
 				hicn_payload_type_t payload_type);
 int hicn_data_reset_for_hash (hicn_format_t format, hicn_header_t *packet);
-int hicn_packet_get_signature_gap (hicn_format_t format,
-				   const hicn_header_t *h, uint8_t *bytes);
-int hicn_packet_set_signature_gap (hicn_format_t format, hicn_header_t *h,
-				   uint8_t bytes);
+int hicn_data_is_last (hicn_format_t format, hicn_header_t *h, int *is_last);
+int hicn_data_set_last (hicn_format_t format, hicn_header_t *h);
+
+int hicn_packet_get_signature_padding (hicn_format_t format,
+				       const hicn_header_t *h, size_t *bytes);
+int hicn_packet_set_signature_padding (hicn_format_t format, hicn_header_t *h,
+				       size_t bytes);
+
 #endif /* HICN_COMPAT_H */
 
 /*
diff --git a/lib/includes/hicn/error.h b/lib/includes/hicn/error.h
index 9303aeb7e..d769ef693 100644
--- a/lib/includes/hicn/error.h
+++ b/lib/includes/hicn/error.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -24,21 +24,22 @@
  * Error definitions
  ******************************************************************************/
 
-#define foreach_libhicn_error                                                   		\
-_(NONE,                 	0,      "OK")                                           	\
-_(UNSPECIFIED,          	128,    "Unspecified Error")                            	\
-_(NOT_IMPLEMENTED,      	180,    "Function not yet implemented")                 	\
-_(NOT_HICN,             	202,    "Non hICN packet")                              	\
-_(UNKNOWN_ADDRESS,      	210,    "Unknown address")                              	\
-_(INVALID_PARAMETER,    	220,    "Invalid parameter")                            	\
-_(INVALID_IP_ADDRESS,   	221,    "Invalid IP address")                           	\
-_(CORRUPTED_PACKET,     	222,    "Corrupted packet ")                            	\
-_(REWRITE_CKSUM_REQUIRED,	223,    "Incremental csum calculation error: cksum required.")	\
-_(UNEXPECTED,           	298,    "Unexpected error")
+#define foreach_libhicn_error                                                 \
+  _ (NONE, 0, "OK")                                                           \
+  _ (UNSPECIFIED, 128, "Unspecified Error")                                   \
+  _ (NOT_IMPLEMENTED, 180, "Function not yet implemented")                    \
+  _ (NOT_HICN, 202, "Non hICN packet")                                        \
+  _ (UNKNOWN_ADDRESS, 210, "Unknown address")                                 \
+  _ (INVALID_PARAMETER, 220, "Invalid parameter")                             \
+  _ (INVALID_IP_ADDRESS, 221, "Invalid IP address")                           \
+  _ (CORRUPTED_PACKET, 222, "Corrupted packet ")                              \
+  _ (REWRITE_CKSUM_REQUIRED, 223,                                             \
+     "Incremental csum calculation error: cksum required.")                   \
+  _ (UNEXPECTED, 298, "Unexpected error")
 
 typedef enum
 {
-#define _(a,b,c) HICN_LIB_ERROR_##a = (-b),
+#define _(a, b, c) HICN_LIB_ERROR_##a = (-b),
   foreach_libhicn_error
 #undef _
     HICN_LIB_N_ERROR,
@@ -46,7 +47,7 @@ typedef enum
 
 extern const char *HICN_LIB_ERROR_STRING[];
 
-#define hicn_strerror(errno) (char *)(HICN_LIB_ERROR_STRING[-errno])
+#define hicn_strerror(errno) (char *) (HICN_LIB_ERROR_STRING[-errno])
 
 #endif /* HICN_ERROR_H */
 
diff --git a/lib/includes/hicn/face.h b/lib/includes/hicn/face.h
new file mode 100644
index 000000000..31906afab
--- /dev/null
+++ b/lib/includes/hicn/face.h
@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \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 <hicn/policy.h>
+
+#include <hicn/util/ip_address.h>
+
+/* Netdevice type */
+
+#include <net/if.h> // IFNAMSIZ
+
+#define foreach_netdevice_type                                                \
+  _ (UNDEFINED)                                                               \
+  _ (LOOPBACK)                                                                \
+  _ (WIRED)                                                                   \
+  _ (WIFI)                                                                    \
+  _ (CELLULAR)                                                                \
+  _ (VPN)                                                                     \
+  _ (MEMIF)                                                                   \
+  _ (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[];
+#define netdevice_type_str(x) _netdevice_type_str[x]
+
+#define NETDEVICE_INVALID_INDEX ~0
+
+/* Netdevice */
+
+/**
+ * \brief Netdevice type
+ *
+ * NOTE
+ *  - This struct cannot be made opaque as it is currently part of face_t
+ *  - We recommand using the API as to keep redundant attributes consistent
+ */
+
+typedef struct
+{
+  u32 index;
+  char name[IFNAMSIZ];
+} netdevice_t;
+
+#define NETDEVICE_EMPTY                                                       \
+  (netdevice_t)                                                               \
+  {                                                                           \
+    .index = 0, .name = { 0 }                                                 \
+  }
+
+netdevice_t *netdevice_create_from_index (u32 index);
+netdevice_t *netdevice_create_from_name (const char *name);
+#define netdevice_initialize_from_index netdevice_set_index
+#define netdevice_initialize_from_name	netdevice_set_name
+void netdevice_free (netdevice_t *netdevice);
+int netdevice_get_index (const netdevice_t *netdevice, u32 *index);
+int netdevice_set_index (netdevice_t *netdevice, u32 index);
+int netdevice_get_name (const netdevice_t *netdevice, const char **name);
+int netdevice_set_name (netdevice_t *netdevice, const char *name);
+int netdevice_update_index (netdevice_t *netdevice);
+int netdevice_update_name (netdevice_t *netdevice);
+int netdevice_cmp (const netdevice_t *nd1, const netdevice_t *nd2);
+
+#define NETDEVICE_UNDEFINED_INDEX 0
+
+/* Face state */
+
+#define foreach_face_state                                                    \
+  _ (UNDEFINED)                                                               \
+  _ (DOWN)                                                                    \
+  _ (UP)                                                                      \
+  _ (N)
+
+#define MAXSZ_FACE_STATE_ 9
+#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[];
+
+#define face_state_str(x) _face_state_str[x]
+
+/* 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;
+
+typedef enum
+{
+  FACE_PROTOCOL_HICN,
+  FACE_PROTOCOL_UDP,
+  FACE_PROTOCOL_TCP,
+  FACE_PROTOCOL_UNKNOWN,
+} face_protocol_t;
+
+#define face_type_is_valid(face_type)                                         \
+  (((face_type) >= FACE_TYPE_UNDEFINED) && (face_type < FACE_TYPE_N))
+#define face_type_is_defined(face_type)                                       \
+  (((face_type) > FACE_TYPE_UNDEFINED) && (face_type < FACE_TYPE_N))
+
+extern const char *_face_type_str[];
+#define face_type_str(x) _face_type_str[x]
+
+face_type_t face_type_from_str (const char *str);
+
+#ifdef WITH_POLICY
+#define MAXSZ_FACE_                                                           \
+  MAXSZ_FACE_TYPE_ + 2 * MAXSZ_URL_ + 2 * MAXSZ_FACE_STATE_ +                 \
+    MAXSZ_POLICY_TAGS_ + 7
+#else
+#define MAXSZ_FACE_                                                           \
+  MAXSZ_FACE_TYPE_ + 2 * MAXSZ_URL_ + 2 * MAXSZ_FACE_STATE_ + 4
+#endif /* WITH_POLICY */
+#define MAXSZ_FACE MAXSZ_FACE_ + 1
+
+/* Face */
+
+typedef u32 face_id_t;
+
+typedef struct
+{
+  face_type_t type;
+  face_state_t admin_state;
+  face_state_t state;
+#ifdef WITH_POLICY
+  uint32_t priority;
+  policy_tags_t tags; /**< \see policy_tag_t */
+#endif		      /* WITH_POLICY */
+
+  /*
+   * Depending on the face type, some of the following fields will be unused
+   */
+  netdevice_t netdevice;
+  int family; /* To access family independently of face type */
+  ip_address_t local_addr;
+  ip_address_t remote_addr;
+  u16 local_port;
+  u16 remote_port;
+} face_t;
+
+int face_initialize (face_t *face);
+int face_initialize_udp (face_t *face, const char *interface_name,
+			 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 char *interface_name,
+			    const struct sockaddr *local_addr,
+			    const struct sockaddr *remote_addr);
+
+face_t *face_create ();
+face_t *face_create_udp (const char *interface_name,
+			 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 char *interface_name,
+			    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);
+
+size_t face_snprintf (char *s, size_t size, const face_t *face);
+
+policy_tags_t face_get_tags (const face_t *face);
+int face_set_tags (face_t *face, policy_tags_t tags);
+
+face_protocol_t get_protocol (face_type_t face_type);
+
+#endif /* HICN_FACE_H */
diff --git a/lib/includes/hicn/header.h b/lib/includes/hicn/header.h
index b21fe5c84..8af9170f8 100644
--- a/lib/includes/hicn/header.h
+++ b/lib/includes/hicn/header.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -20,8 +20,8 @@
  * NOTE: These structures are used as convenient facade for accessing
  * the encapsulated headers. They are not written taking compiler padding
  * into account, then a sizeof() on these struct could not give the expected
- * result. For accessing the size of the hicn headers use the macros at the end of
- * this file.
+ * result. For accessing the size of the hicn headers use the macros at the end
+ * of this file.
  */
 
 #ifndef HICN_HEADER_H
@@ -36,6 +36,11 @@ typedef struct
   union
   {
     _tcp_header_t tcp;
+    struct
+    {
+      _udp_header_t udp;
+      _new_header_t newhdr;
+    };
     _icmp_header_t icmp;
     _icmp_wldr_header_t wldr;
   };
@@ -53,25 +58,36 @@ typedef struct
     };
     struct
     {
+      _udp_header_t udp;
+      _new_header_t newhdr;
+      _ah_header_t udp_ah;
+    };
+    struct
+    {
       _icmp_header_t icmp;
       _ah_header_t icmp_ah;
     };
   };
 } hicn_v6ah_hdr_t;
 
-typedef struct
-{
+// For ipv4 we need to use packed structs as fields may be aligned to 64 bits
+// (So for instance tcp header may start at byte #24 instead of byte 20)
+typedef PACKED (struct {
   _ipv4_header_t ip;
   union
   {
     _tcp_header_t tcp;
+    struct
+    {
+      _udp_header_t udp;
+      _new_header_t newhdr;
+    };
     _icmp_header_t icmp;
     _icmp_wldr_header_t wldr;
   };
-} hicn_v4_hdr_t;
+}) hicn_v4_hdr_t;
 
-typedef struct
-{
+typedef PACKED (struct {
   _ipv4_header_t ip;
   union
   {
@@ -82,11 +98,17 @@ typedef struct
     };
     struct
     {
+      _udp_header_t udp;
+      _new_header_t newhdr;
+      _ah_header_t udp_ah;
+    };
+    struct
+    {
       _icmp_header_t icmp;
       _ah_header_t icmp_ah;
     };
   };
-} hicn_v4ah_hdr_t;
+}) hicn_v4ah_hdr_t;
 
 typedef union
 {
@@ -99,24 +121,19 @@ typedef union
   hicn_protocol_t protocol;
 } hicn_header_t;
 
+#define HICN_V6_TCP_HDRLEN  (IPV6_HDRLEN + TCP_HDRLEN)
+#define HICN_V6_ICMP_HDRLEN (IPV6_HDRLEN + ICMP_HDRLEN)
+#define HICN_V6_WLDR_HDRLEN (IPV6_HDRLEN + ICMPWLDR_HDRLEN)
 
-#define HICN_V6_TCP_HDRLEN   (IPV6_HDRLEN + TCP_HDRLEN)
-#define HICN_V6_ICMP_HDRLEN  (IPV6_HDRLEN + ICMP_HDRLEN)
-#define HICN_V6_WLDR_HDRLEN  (IPV6_HDRLEN + ICMPWLDR_HDRLEN)
-
-#define HICN_V6_TCP_AH_HDRLEN   (HICN_V6_TCP_HDRLEN + AH_HDRLEN)
-#define HICN_V6_ICMP_AH_HDRLEN   (HICN_V6_ICMP_HDRLEN + AH_HDRLEN)
-
-
-#define HICN_V4_TCP_HDRLEN   (IPV4_HDRLEN + TCP_HDRLEN)
-#define HICN_V4_ICMP_HDRLEN  (IPV4_HDRLEN + ICMP_HDRLEN)
-#define HICN_V4_WLDR_HDRLEN  (IPV4_HDRLEN + ICMPWLDR_HDRLEN)
-
-#define HICN_V4_TCP_AH_HDRLEN   (HICN_V4_TCP_HDRLEN + AH_HDRLEN)
-#define HICN_V4_ICMP_AH_HDRLEN   (HICN_V4_ICMP_HDRLEN + AH_HDRLEN)
-
+#define HICN_V6_TCP_AH_HDRLEN  (HICN_V6_TCP_HDRLEN + AH_HDRLEN)
+#define HICN_V6_ICMP_AH_HDRLEN (HICN_V6_ICMP_HDRLEN + AH_HDRLEN)
 
+#define HICN_V4_TCP_HDRLEN  (IPV4_HDRLEN + TCP_HDRLEN)
+#define HICN_V4_ICMP_HDRLEN (IPV4_HDRLEN + ICMP_HDRLEN)
+#define HICN_V4_WLDR_HDRLEN (IPV4_HDRLEN + ICMPWLDR_HDRLEN)
 
+#define HICN_V4_TCP_AH_HDRLEN  (HICN_V4_TCP_HDRLEN + AH_HDRLEN)
+#define HICN_V4_ICMP_AH_HDRLEN (HICN_V4_ICMP_HDRLEN + AH_HDRLEN)
 
 #endif /* HICN_HEADER_H */
 
diff --git a/lib/includes/hicn/hicn.h b/lib/includes/hicn/hicn.h
index 749fd4247..4a5b4dd56 100644
--- a/lib/includes/hicn/hicn.h
+++ b/lib/includes/hicn/hicn.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -31,15 +31,17 @@
  *
  *  [1] Hybrid Information-Centric Networking
  *      L. Muscariello, G. Carofiglio, J. Augé, M. Papalini
- *      IETF draft (intarea) @ https://tools.ietf.org/html/draft-muscariello-intarea-hicn
+ *      IETF draft (intarea) @
+ * https://tools.ietf.org/html/draft-muscariello-intarea-hicn
  *
- *  [2] Leveraging ICN in-network control for loss detection and recovery in wireless mobile networks
- *      G. Carofiglio, L. Muscariello, M. Papalini, N. Rozhnova, X. Zeng
- *      In proc. ICN'2016, Kyoto, JP
+ *  [2] Leveraging ICN in-network control for loss detection and recovery in
+ * wireless mobile networks G. Carofiglio, L. Muscariello, M. Papalini, N.
+ * Rozhnova, X. Zeng In proc. ICN'2016, Kyoto, JP
  *
  *  [3] Anchorless mobility through hICN
  *      J. Augé, G. Carofiglio, L. Muscariello, M. Papalini
- *      IETF draft (DMM) @ https://tools.ietf.org/html/draft-auge-dmm-hicn-mobility
+ *      IETF draft (DMM) @
+ * https://tools.ietf.org/html/draft-auge-dmm-hicn-mobility
  *
  *
  *  [4] MAP-Me : Managing Anchorless Mobility in Content Centric Networking
diff --git a/lib/includes/hicn/mapme.h b/lib/includes/hicn/mapme.h
index 8fae44530..63a5cd77e 100644
--- a/lib/includes/hicn/mapme.h
+++ b/lib/includes/hicn/mapme.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -20,7 +20,7 @@
 #ifndef HICN_MAPME_H
 #define HICN_MAPME_H
 
-#include <stdint.h>		// u32
+#include <stdint.h> // u32
 #include <stdbool.h>
 
 #include "common.h"
@@ -32,16 +32,16 @@
  */
 typedef struct
 {
-    /** MAP-Me enabled flag (default: false) */
+  /** MAP-Me enabled flag (default: false) */
   bool enabled;
-    /** timescale (T_U parameter) in ms (default: 0 for no notifications) */
+  /** timescale (T_U parameter) in ms (default: 0 for no notifications) */
   u32 timescale;
-    /** retransmission timer in ms (default: 50) */
+  /** retransmission timer in ms (default: 50) */
   u32 retx;
-    /**
-     * Discovery enabled flag (default: true, should be true if mandatory is
-     * notifications are enabled)
-     */
+  /**
+   * Discovery enabled flag (default: true, should be true if mandatory is
+   * notifications are enabled)
+   */
   bool discovery;
 } hicn_mapme_conf_t;
 
@@ -74,37 +74,45 @@ typedef struct
   seq_t seq;
 } mapme_params_t;
 
-
 /* MAP-Me API */
-size_t hicn_mapme_create_packet (u8 * buf, const hicn_prefix_t * prefix,
-				 const mapme_params_t * params);
-size_t hicn_mapme_create_ack (u8 * buf, const mapme_params_t * params);
-int hicn_mapme_parse_packet (const u8 * packet, hicn_prefix_t * prefix,
-			     mapme_params_t * params);
+size_t hicn_mapme_create_packet (u8 *buf, const hicn_prefix_t *prefix,
+				 const mapme_params_t *params);
+size_t hicn_mapme_create_ack (u8 *buf, const mapme_params_t *params);
+int hicn_mapme_parse_packet (const u8 *packet, hicn_prefix_t *prefix,
+			     mapme_params_t *params);
 
 /* Implementation & parsing : ICMP Redirect */
 
 #define HICN_MAPME_ACK_FLAG (0x20 | 0x60)
 
-#define HICN_MAPME_ICMP_TYPE_IPV4     5
-#define HICN_MAPME_ICMP_TYPE_IPV6     137
-#define HICN_MAPME_ICMP_TYPE_ACK_IPV4 (HICN_MAPME_ICMP_TYPE_IPV4 | HICN_MAPME_ACK_FLAG)
-#define HICN_MAPME_ICMP_TYPE_ACK_IPV6 (HICN_MAPME_ICMP_TYPE_IPV6 | HICN_MAPME_ACK_FLAG)
-#define HICN_MAPME_ICMP_CODE 0	/* Redirect Datagrams for the Network (or subnet) */
-
-#define HICN_MAPME_TYPE_IS_IU(type)     ((type == HICN_MAPME_ICMP_TYPE_IPV4)     || (type == HICN_MAPME_ICMP_TYPE_IPV6))
-#define HICN_MAPME_TYPE_IS_IU_ACK(type) ((type == HICN_MAPME_ICMP_TYPE_ACK_IPV4) || (type == HICN_MAPME_ICMP_TYPE_ACK_IPV6))
-
-#define HICN_MAPME_IS_IU(type, code) (HICN_MAPME_TYPE_IS_IU(type) && (code == HICN_MAPME_ICMP_CODE))
-#define HICN_MAPME_IS_ACK(type, code) (HICN_MAPME_TYPE_IS_IU_ACK(type) && (code == HICN_MAPME_ICMP_CODE))
-
-#define HICN_IS_MAPME(type, code) (HICN_MAPME_IS_IU(type, code) || HICN_MAPME_IS_ACK(type, code))
+#define HICN_MAPME_ICMP_TYPE_IPV4 5
+#define HICN_MAPME_ICMP_TYPE_IPV6 137
+#define HICN_MAPME_ICMP_TYPE_ACK_IPV4                                         \
+  (HICN_MAPME_ICMP_TYPE_IPV4 | HICN_MAPME_ACK_FLAG)
+#define HICN_MAPME_ICMP_TYPE_ACK_IPV6                                         \
+  (HICN_MAPME_ICMP_TYPE_IPV6 | HICN_MAPME_ACK_FLAG)
+#define HICN_MAPME_ICMP_CODE                                                  \
+  0 /* Redirect Datagrams for the Network (or subnet) */
+
+#define HICN_MAPME_TYPE_IS_IU(type)                                           \
+  ((type == HICN_MAPME_ICMP_TYPE_IPV4) || (type == HICN_MAPME_ICMP_TYPE_IPV6))
+#define HICN_MAPME_TYPE_IS_IU_ACK(type)                                       \
+  ((type == HICN_MAPME_ICMP_TYPE_ACK_IPV4) ||                                 \
+   (type == HICN_MAPME_ICMP_TYPE_ACK_IPV6))
+
+#define HICN_MAPME_IS_IU(type, code)                                          \
+  (HICN_MAPME_TYPE_IS_IU (type) && (code == HICN_MAPME_ICMP_CODE))
+#define HICN_MAPME_IS_ACK(type, code)                                         \
+  (HICN_MAPME_TYPE_IS_IU_ACK (type) && (code == HICN_MAPME_ICMP_CODE))
+
+#define HICN_IS_MAPME(type, code)                                             \
+  (HICN_MAPME_IS_IU (type, code) || HICN_MAPME_IS_ACK (type, code))
 
 /* Fast check for ACK flag */
 #define HICN_MAPME_IS_ACK_FAST(icmp_type) (icmp_type & HICN_MAPME_ACK_FLAG)
 
 /* Default TTL */
-#define HICN_MAPME_TTL 255	// typical for redirect (ref?)
+#define HICN_MAPME_TTL 255 // typical for redirect (ref?)
 
 /*
  * The length of the MAPME4 header struct must be 120 bytes.
@@ -143,8 +151,8 @@ typedef union
   hicn_mapme_v6_header_t v6;
 } hicn_mapme_header_t;
 
-#define HICN_MAPME_V4_HDRLEN sizeof(hicn_mapme_v4_header_t)
-#define HICN_MAPME_V6_HDRLEN sizeof(hicn_mapme_v6_header_t)
+#define HICN_MAPME_V4_HDRLEN sizeof (hicn_mapme_v4_header_t)
+#define HICN_MAPME_V6_HDRLEN sizeof (hicn_mapme_v6_header_t)
 
 static_assert (EXPECTED_MAPME_V4_HDRLEN == HICN_MAPME_V4_HDRLEN,
 	       "Size of MAPME_V4 struct does not match its expected size.");
diff --git a/lib/includes/hicn/name.h b/lib/includes/hicn/name.h
index d5202068b..f85b0bc3f 100644
--- a/lib/includes/hicn/name.h
+++ b/lib/includes/hicn/name.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -26,7 +26,7 @@
 
 #include <stdbool.h>
 #ifndef _WIN32
-#include <netinet/in.h>        // struct sockadd
+#include <netinet/in.h> // struct sockadd
 #endif
 #include <hicn/util/ip_address.h>
 #include "common.h"
@@ -35,12 +35,16 @@
  * hICN names
  ******************************************************************************/
 
-#define TCP_SEQNO_LEN 4        /* bytes */
+#define TCP_SEQNO_LEN	   4 /* bytes */
 #define HICN_V4_PREFIX_LEN IPV4_ADDR_LEN
 #define HICN_V6_PREFIX_LEN IPV6_ADDR_LEN
-#define HICN_SEGMENT_LEN TCP_SEQNO_LEN
-#define HICN_V6_NAME_LEN (HICN_V6_PREFIX_LEN + HICN_SEGMENT_LEN)    /* 20 bytes */
-#define HICN_V4_NAME_LEN (HICN_V4_PREFIX_LEN + HICN_SEGMENT_LEN)    /*  8 bytes */
+#define HICN_SEGMENT_LEN   TCP_SEQNO_LEN
+#define HICN_V6_NAME_LEN                                                      \
+  (HICN_V6_PREFIX_LEN + HICN_SEGMENT_LEN) /* 20 bytes                         \
+					   */
+#define HICN_V4_NAME_LEN                                                      \
+  (HICN_V4_PREFIX_LEN + HICN_SEGMENT_LEN) /*  8 bytes                         \
+					   */
 
 /* Prefix */
 
@@ -48,7 +52,7 @@ typedef u32 hicn_name_suffix_t;
 
 typedef struct
 {
-  ip46_address_t name;
+  ip_address_t name;
   u8 len;
 } hicn_prefix_t;
 
@@ -58,85 +62,17 @@ typedef struct
  * A name is a prefix + a segment name (suffix)
  */
 
-typedef union
-{
-  struct
-  {
-    union
-    {
-      u32 prefix;
-      u8 prefix_as_u8[4];
-      ip4_address_t prefix_as_ip4;
-    };
-    hicn_name_suffix_t suffix;
-  };
-  u8 buffer[HICN_V4_NAME_LEN];
-} hicn_v4_name_t;
-
-typedef union
-{
-  struct
-  {
-    union
-    {
-      u64 prefix[2];
-      u8 prefix_as_u8[16];
-      ip6_address_t prefix_as_ip6;
-    };
-    hicn_name_suffix_t suffix;
-  };
-  u8 buffer[HICN_V6_NAME_LEN];
-} hicn_v6_name_t;
-
-#ifndef HICN_VPP_PLUGIN
-#define HICN_NAME_COMPONENT_SIZE 2
-
-typedef struct
-{
-  struct iovec buffers[HICN_NAME_COMPONENT_SIZE];
-} hicn_iov_name_t;
-
-#define UNSPEC            1 << 0
-#define HNT_CONTIGUOUS    1 << 1
-#define HNT_IOV           1 << 2
-#define HNT_INET          1 << 3
-#define HNT_INET6         1 << 4
-
-typedef enum
-{
-  HNT_UNSPEC = UNSPEC,
-  HNT_CONTIGUOUS_V4 = HNT_CONTIGUOUS | HNT_INET,
-  HNT_CONTIGUOUS_V6 = HNT_CONTIGUOUS | HNT_INET6,
-  HNT_IOV_V4 = HNT_IOV | HNT_INET,
-  HNT_IOV_V6 = HNT_IOV | HNT_INET6,
-} hicn_name_type_t;
-#endif /* HICN_VPP_PLUGIN */
-
 typedef struct
 {
-#ifndef HICN_VPP_PLUGIN
-  hicn_name_type_t type;
-  u8 len;
-#endif                /* HICN_VPP_PLUGIN */
-  union
-  {
-    hicn_v4_name_t ip4;
-    hicn_v6_name_t ip6;
-    ip46_address_t ip46;
-#ifndef HICN_VPP_PLUGIN
-    hicn_iov_name_t iov;
-    u8 buffer[HICN_V6_NAME_LEN];
-#endif                /* HICN_VPP_PLUGIN */
-  };
+  ip_address_t prefix;
+  hicn_name_suffix_t suffix;
 } hicn_name_t;
 
-#ifndef HICN_VPP_PLUGIN
-#define _is_unspec(name)     ((name->type & UNSPEC))
-#define _is_contiguous(name) ((name->type & HNT_CONTIGUOUS) >> 1)
-#define _is_iov(name)        ((name->type & HNT_IOV) >> 2)
-#define _is_inet4(name)      ((name->type & HNT_INET) >> 3)
-#define _is_inet6(name)      ((name->type & HNT_INET6) >> 4)
-#endif /* HICN_VPP_PLUGIN */
+#define _is_unspec(name)                                                      \
+  (((name)->prefix.pad[0] | (name)->prefix.pad[1] | (name)->prefix.pad[2] |   \
+    (name)->prefix.v4.as_u32) == 0)
+#define _is_inet4(name) (ip_address_is_v4 (&name->prefix))
+#define _is_inet6(name) (!_is_inet4 (name))
 
 /**
  * @brief Create an hICN name from IP address in presentation format
@@ -145,7 +81,7 @@ typedef struct
  * @param [out] Resulting hICN name
  * @return hICN error code
  */
-int hicn_name_create (const char *ip_address, u32 id, hicn_name_t * name);
+int hicn_name_create (const char *ip_address, u32 id, hicn_name_t *name);
 
 /**
  * @brief Create an hICN name from IP address
@@ -154,28 +90,21 @@ int hicn_name_create (const char *ip_address, u32 id, hicn_name_t * name);
  * @param [out] Resulting - hICN name
  * @return hICN error code
  */
-int hicn_name_create_from_ip_prefix (const ip_prefix_t * prefix, u32 id,
-                      hicn_name_t * name);
-
-/**
- * @brief Returns the length of an hICN name
- * @param [in] name - hICN name
- * @return Name length
- */
-u8 hicn_name_get_length (const hicn_name_t * name);
+int hicn_name_create_from_ip_prefix (const ip_prefix_t *prefix, u32 id,
+				     hicn_name_t *name);
 
 /**
  * @brief Compare two hICN names
  * @param [in] name_1 - First name to compare
  * @param [in] name_2 - Second name to compare
- * @param [in] consider_segment - Flag indicating whether the segment part has to be
- *   considered
+ * @param [in] consider_segment - Flag indicating whether the segment part has
+ * to be considered
  * @return An integer less than, equal to, or greater than zero if name_1 is
  *   found, respectively, to be lest than, to match, or be greater than name_2
  *   based on numeric order.
  */
-int hicn_name_compare (const hicn_name_t * name_1, const hicn_name_t * name_2,
-               bool consider_segment);
+int hicn_name_compare (const hicn_name_t *name_1, const hicn_name_t *name_2,
+		       bool consider_segment);
 
 /**
  * @brief Provides a 32-bit hash of an hICN name
@@ -184,7 +113,7 @@ int hicn_name_compare (const hicn_name_t * name_1, const hicn_name_t * name_2,
  * @param [in] consider_suffix - Consider the suffix in the hash computation
  * @return hICN error code
  */
-int hicn_name_hash (const hicn_name_t * name, u32 * hash, bool consider_suffix);
+int hicn_name_hash (const hicn_name_t *name, u32 *hash, bool consider_suffix);
 
 /**
  * @brief Test whether an hICN name is empty
@@ -192,7 +121,7 @@ int hicn_name_hash (const hicn_name_t * name, u32 * hash, bool consider_suffix);
  * @return 0 if the name is empty, any other value otherwise (implementation
  *   returns 1)
  */
-int hicn_name_empty (hicn_name_t * name);
+int hicn_name_empty (hicn_name_t *name);
 
 /**
  * @brief Copy an hICN name
@@ -200,7 +129,7 @@ int hicn_name_empty (hicn_name_t * name);
  * @param [in] src - Source name to copy
  * @return hICN error code
  */
-int hicn_name_copy (hicn_name_t * dst, const hicn_name_t * src);
+int hicn_name_copy (hicn_name_t *dst, const hicn_name_t *src);
 
 /**
  * @brief Copy an hICN name to a buffer
@@ -209,8 +138,7 @@ int hicn_name_copy (hicn_name_t * dst, const hicn_name_t * src);
  * @param [in] copy_suffix - Flag indicating whether the suffix has to be
  *   considered
  */
-int hicn_name_copy_to_destination (u8 * dst, const hicn_name_t * src,
-                   bool copy_suffix);
+int hicn_name_copy_prefix_to_destination (u8 *dst, const hicn_name_t *src);
 
 /**
  * @brief Sets the segment part of an hICN name
@@ -218,7 +146,7 @@ int hicn_name_copy_to_destination (u8 * dst, const hicn_name_t * src,
  * @param [in] seq_number - Segment identifier
  * @return hICN error code
  */
-int hicn_name_set_seq_number (hicn_name_t * name, u32 seq_number);
+int hicn_name_set_seq_number (hicn_name_t *name, u32 seq_number);
 
 /**
  * @brief Retrieves the segment part of an hICN name
@@ -226,7 +154,7 @@ int hicn_name_set_seq_number (hicn_name_t * name, u32 seq_number);
  * @param [in] seq_number - Segment identifier
  * @return hICN error code
  */
-int hicn_name_get_seq_number (const hicn_name_t * name, u32 * seq_number);
+int hicn_name_get_seq_number (const hicn_name_t *name, u32 *seq_number);
 
 /**
  * @brief Convert an hICN name to a socket address
@@ -234,8 +162,8 @@ int hicn_name_get_seq_number (const hicn_name_t * name, u32 * seq_number);
  * @param [out] ip_address - Resulting socket address
  * @return hICN error code
  */
-int hicn_name_to_sockaddr_address (const hicn_name_t * name,
-                   struct sockaddr *ip_address);
+int hicn_name_to_sockaddr_address (const hicn_name_t *name,
+				   struct sockaddr *ip_address);
 
 /**
  * @brief Convert an hICN name to an IP address
@@ -243,8 +171,7 @@ int hicn_name_to_sockaddr_address (const hicn_name_t * name,
  * @param [out] ip_address - Resulting IP address
  * @return hICN error code
  */
-int hicn_name_to_ip_prefix (const hicn_name_t * name,
-                 ip_prefix_t * ip_prefix);
+int hicn_name_to_ip_prefix (const hicn_name_t *name, ip_prefix_t *ip_prefix);
 
 /**
  * @brief Convert an hICN name to presentation format
@@ -253,7 +180,7 @@ int hicn_name_to_ip_prefix (const hicn_name_t * name,
  * @param [in] len - Number of bytes available in the buffer
  * @return hICN error code
  */
-int hicn_name_ntop (const hicn_name_t * src, char *dst, size_t len);
+int hicn_name_ntop (const hicn_name_t *src, char *dst, size_t len);
 
 /**
  * @brief Convert an hICN name from presentation format
@@ -261,7 +188,7 @@ int hicn_name_ntop (const hicn_name_t * src, char *dst, size_t len);
  * @param [out] dst - Resulting name
  * @return hICN error code
  */
-int hicn_name_pton (const char *src, hicn_name_t * dst);
+int hicn_name_pton (const char *src, hicn_name_t *dst);
 
 /**
  * @brief Returns the IP address family of an hICN name
@@ -269,7 +196,7 @@ int hicn_name_pton (const char *src, hicn_name_t * dst);
  * @param [out] family - Resulting IP address family (AF_INET or AF_INET6)
  * @return hICN error code
  */
-int hicn_name_get_family (const hicn_name_t * name, int *family);
+int hicn_name_get_family (const hicn_name_t *name, int *family);
 
 /**
  * @brief Creates an hICN prefix from an IP address
@@ -277,8 +204,8 @@ int hicn_name_get_family (const hicn_name_t * name, int *family);
  * @param [out] prefix - Resulting prefix
  * @return hICN error code
  */
-int hicn_prefix_create_from_ip_prefix (const ip_prefix_t * ip_prefix,
-                    hicn_prefix_t * prefix);
+int hicn_prefix_create_from_ip_prefix (const ip_prefix_t *ip_prefix,
+				       hicn_prefix_t *prefix);
 
 #endif /* HICN_NAME_H */
 
diff --git a/lib/includes/hicn/ops.h b/lib/includes/hicn/ops.h
index e5b1c088c..e9eebc76c 100644
--- a/lib/includes/hicn/ops.h
+++ b/lib/includes/hicn/ops.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -23,6 +23,7 @@
 
 #include <stdlib.h>
 
+#include "common.h"
 #include "error.h"
 #include "header.h"
 #include "name.h"
@@ -52,7 +53,7 @@ typedef struct hicn_ops_s
    * @return hICN error code
    */
   int (*get_interest_locator) (hicn_type_t type, const hicn_protocol_t *h,
-			       ip46_address_t *ip_address);
+			       ip_address_t *ip_address);
 
   /**
    * @brief Sets an Interest locator
@@ -62,7 +63,7 @@ typedef struct hicn_ops_s
    * @return hICN error code
    */
   int (*set_interest_locator) (hicn_type_t type, hicn_protocol_t *h,
-			       const ip46_address_t *ip_address);
+			       const ip_address_t *ip_address);
 
   /**
    * @brief Retrieves an Interest name
@@ -105,6 +106,15 @@ typedef struct hicn_ops_s
 				   const hicn_name_suffix_t *suffix);
 
   /**
+   * @brief Check if packet is an interest
+   * @param [in] type - hICN packet type
+   * @param [in] h - Buffer holding the Interest packet
+   * @param [out] h - 1 if interest, 0 otherwise
+   * @return hICN error code
+   */
+  int (*is_interest) (hicn_type_t type, const hicn_protocol_t *h, int *ret);
+
+  /**
    * @brief Set flag to mark current packet as interest
    * @param [in] type - hICN packet type
    * @param [in,out] h - Buffer holding the Interest packet
@@ -136,7 +146,7 @@ typedef struct hicn_ops_s
    * @return hICN error code
    */
   int (*get_data_locator) (hicn_type_t type, const hicn_protocol_t *h,
-			   ip46_address_t *ip_address);
+			   ip_address_t *ip_address);
 
   /**
    * @brief Sets a Data locator
@@ -146,7 +156,7 @@ typedef struct hicn_ops_s
    * @return hICN error code
    */
   int (*set_data_locator) (hicn_type_t type, hicn_protocol_t *h,
-			   const ip46_address_t *ip_address);
+			   const ip_address_t *ip_address);
 
   /**
    * @brief Retrieves a Data name
@@ -282,8 +292,8 @@ typedef struct hicn_ops_s
    * @return hICN error code
    */
   int (*rewrite_interest) (hicn_type_t type, hicn_protocol_t *h,
-			   const ip46_address_t *addr_new,
-			   ip46_address_t *addr_old);
+			   const ip_address_t *addr_new,
+			   ip_address_t *addr_old);
 
   /**
    * @brief Rewrite a Data packet header (locator + pathlabel)
@@ -298,9 +308,8 @@ typedef struct hicn_ops_s
    * @return hICN error code
    */
   int (*rewrite_data) (hicn_type_t type, hicn_protocol_t *h,
-		       const ip46_address_t *addr_new,
-		       ip46_address_t *addr_old, const hicn_faceid_t face_id,
-		       u8 reset_pl);
+		       const ip_address_t *addr_new, ip_address_t *addr_old,
+		       const hicn_faceid_t face_id, u8 reset_pl);
 
   /**
    * @brief Return the packet length
@@ -373,27 +382,27 @@ typedef struct hicn_ops_s
 			     size_t signature_size);
 
   /**
-   * @brief Sets an Interest or Data signature gap between maximum size and
+   * @brief Sets an Interest or Data signature padding between maximum size and
    * real size
    * @param [in] type - hICN packet type
    * @param [in,out] h - Buffer holding the Interest or Data packet
    * @param [in] signature_size - Signature size to set
    * @return hICN error code
    */
-  int (*set_signature_gap) (hicn_type_t type, hicn_protocol_t *h,
-			    uint8_t signature_gap);
+  int (*set_signature_padding) (hicn_type_t type, hicn_protocol_t *h,
+				size_t signature_padding);
 
   /**
-   * @brief gets an Interest or Data signature gap between maximum size and
+   * @brief gets an Interest or Data signature padding between maximum size and
    * real size
    * @param [in] type - hICN packet type
    * @param [in,out] h - Buffer holding the Interest or Data packet
-   * @param [in] signature_size - retrieve the gap between maximum size and
+   * @param [in] signature_size - retrieve the padding between maximum size and
    * real size
    * @return hICN error code
    */
-  int (*get_signature_gap) (hicn_type_t type, const hicn_protocol_t *h,
-			    uint8_t *signature_gap);
+  int (*get_signature_padding) (hicn_type_t type, const hicn_protocol_t *h,
+				size_t *signature_padding);
 
   /**
    * @brief Gets the signature timestamp
@@ -464,6 +473,44 @@ typedef struct hicn_ops_s
    */
   int (*get_signature) (hicn_type_t type, hicn_protocol_t *h,
 			uint8_t **signature);
+
+  /**
+   * @brief Set payload type of the packet
+   * @param [in] type - hICN packet type
+   * @param [in,out] h - Buffer holding the Interest or Data packet
+   * @param [in] payload_type - The payload type of this packet
+   * @return hICN error code
+   */
+  int (*set_payload_type) (hicn_type_t type, hicn_protocol_t *h,
+			   hicn_payload_type_t payload_type);
+
+  /**
+   * @brief Get payload type from the packet
+   * @param [in] type - hICN packet type
+   * @param [in] h - Buffer holding the Interest or Data packet
+   * @param [out] payload_type - The payload type of this packet
+   * @return hICN error code
+   */
+  int (*get_payload_type) (hicn_type_t type, const hicn_protocol_t *h,
+			   hicn_payload_type_t *payload_type);
+
+  /**
+   * @brief Check if data packet is last one.
+   * @param [in] type - hICN packet type
+   * @param [in] h - Buffer holding the Interest or Data packet
+   * @param [out] is_last - 1 if last data, 0 otherwise
+   * @return hICN error code
+   */
+  int (*is_last_data) (hicn_type_t type, const hicn_protocol_t *h,
+		       int *is_last);
+
+  /**
+   * @brief Mark data packet as last
+   * @param [in] type - hICN packet type
+   * @param [in, out] h - Buffer holding the Interest or Data packet
+   * @return hICN error code
+   */
+  int (*set_last_data) (hicn_type_t type, hicn_protocol_t *h);
 } hicn_ops_t;
 
 #define DECLARE_HICN_OPS(protocol)                                            \
@@ -477,6 +524,7 @@ typedef struct hicn_ops_s
 	       protocol##_get_interest_name_suffix),                          \
     ATTR_INIT (set_interest_name_suffix,                                      \
 	       protocol##_set_interest_name_suffix),                          \
+    ATTR_INIT (is_interest, protocol##_is_interest),                          \
     ATTR_INIT (mark_packet_as_interest, protocol##_mark_packet_as_interest),  \
     ATTR_INIT (mark_packet_as_data, protocol##_mark_packet_as_data),          \
     ATTR_INIT (reset_interest_for_hash, protocol##_reset_interest_for_hash),  \
@@ -502,6 +550,8 @@ typedef struct hicn_ops_s
     ATTR_INIT (get_header_length, protocol##_get_header_length),              \
     ATTR_INIT (get_payload_length, protocol##_get_payload_length),            \
     ATTR_INIT (set_payload_length, protocol##_set_payload_length),            \
+    ATTR_INIT (get_payload_type, protocol##_get_payload_type),                \
+    ATTR_INIT (set_payload_type, protocol##_set_payload_type),                \
     ATTR_INIT (get_signature_size, protocol##_get_signature_size),            \
     ATTR_INIT (get_signature_timestamp, protocol##_get_signature_timestamp),  \
     ATTR_INIT (set_signature_timestamp, protocol##_set_signature_timestamp),  \
@@ -512,9 +562,11 @@ typedef struct hicn_ops_s
     ATTR_INIT (get_key_id, protocol##_get_key_id),                            \
     ATTR_INIT (set_key_id, protocol##_set_key_id),                            \
     ATTR_INIT (get_signature, protocol##_get_signature),                      \
-    ATTR_INIT (set_signature_gap, protocol##_set_signature_gap),              \
+    ATTR_INIT (set_signature_padding, protocol##_set_signature_padding),      \
     ATTR_INIT (set_signature_size, protocol##_set_signature_size),            \
-    ATTR_INIT (get_signature_gap, protocol##_get_signature_gap),              \
+    ATTR_INIT (get_signature_padding, protocol##_get_signature_padding),      \
+    ATTR_INIT (is_last_data, protocol##_is_last_data),                        \
+    ATTR_INIT (set_last_data, protocol##_set_last_data),                      \
   }
 
 /**
@@ -529,7 +581,7 @@ extern const hicn_ops_t *const hicn_ops_vft[];
  * NOTE : we cannot use a shift operation as IPPROTO_NONE != 0 (and 0 is
  * IPv4...)
  */
-always_inline hicn_type_t
+static inline hicn_type_t
 TYPE_POP (hicn_type_t type)
 {
 #ifndef _WIN32
@@ -544,7 +596,7 @@ TYPE_POP (hicn_type_t type)
 #endif
 }
 
-always_inline hicn_protocol_t *
+static inline hicn_protocol_t *
 PAYLOAD (hicn_type_t type, const hicn_protocol_t *h)
 {
   size_t header_length;
@@ -573,14 +625,14 @@ PAYLOAD (hicn_type_t type, const hicn_protocol_t *h)
 
 #define DECLARE_get_interest_locator(protocol, error)                         \
   int protocol##_get_interest_locator (                                       \
-    hicn_type_t type, const hicn_protocol_t *h, ip46_address_t *ip_address)   \
+    hicn_type_t type, const hicn_protocol_t *h, ip_address_t *ip_address)     \
   {                                                                           \
     return HICN_LIB_ERROR_##error;                                            \
   }
 
 #define DECLARE_set_interest_locator(protocol, error)                         \
   int protocol##_set_interest_locator (hicn_type_t type, hicn_protocol_t *h,  \
-				       const ip46_address_t *ip_address)      \
+				       const ip_address_t *ip_address)        \
   {                                                                           \
     return HICN_LIB_ERROR_##error;                                            \
   }
@@ -613,6 +665,13 @@ PAYLOAD (hicn_type_t type, const hicn_protocol_t *h)
     return HICN_LIB_ERROR_##error;                                            \
   }
 
+#define DECLARE_is_interest(protocol, error)                                  \
+  int protocol##_is_interest (hicn_type_t type, const hicn_protocol_t *h,     \
+			      int *ret)                                       \
+  {                                                                           \
+    return HICN_LIB_ERROR_##error;                                            \
+  }
+
 #define DECLARE_mark_packet_as_interest(protocol, error)                      \
   int protocol##_mark_packet_as_interest (hicn_type_t type,                   \
 					  hicn_protocol_t *h)                 \
@@ -635,14 +694,14 @@ PAYLOAD (hicn_type_t type, const hicn_protocol_t *h)
 
 #define DECLARE_get_data_locator(protocol, error)                             \
   int protocol##_get_data_locator (                                           \
-    hicn_type_t type, const hicn_protocol_t *h, ip46_address_t *ip_address)   \
+    hicn_type_t type, const hicn_protocol_t *h, ip_address_t *ip_address)     \
   {                                                                           \
     return HICN_LIB_ERROR_##error;                                            \
   }
 
 #define DECLARE_set_data_locator(protocol, error)                             \
   int protocol##_set_data_locator (hicn_type_t type, hicn_protocol_t *h,      \
-				   const ip46_address_t *ip_address)          \
+				   const ip_address_t *ip_address)            \
   {                                                                           \
     return HICN_LIB_ERROR_##error;                                            \
   }
@@ -732,16 +791,16 @@ PAYLOAD (hicn_type_t type, const hicn_protocol_t *h)
 
 #define DECLARE_rewrite_interest(protocol, error)                             \
   int protocol##_rewrite_interest (hicn_type_t type, hicn_protocol_t *h,      \
-				   const ip46_address_t *addr_new,            \
-				   ip46_address_t *addr_old)                  \
+				   const ip_address_t *addr_new,              \
+				   ip_address_t *addr_old)                    \
   {                                                                           \
     return HICN_LIB_ERROR_##error;                                            \
   }
 
 #define DECLARE_rewrite_data(protocol, error)                                 \
   int protocol##_rewrite_data (                                               \
-    hicn_type_t type, hicn_protocol_t *h, const ip46_address_t *addr_new,     \
-    ip46_address_t *addr_old, const hicn_faceid_t face_id, u8 reset_pl)       \
+    hicn_type_t type, hicn_protocol_t *h, const ip_address_t *addr_new,       \
+    ip_address_t *addr_old, const hicn_faceid_t face_id, u8 reset_pl)         \
   {                                                                           \
     return HICN_LIB_ERROR_##error;                                            \
   }
@@ -781,6 +840,21 @@ PAYLOAD (hicn_type_t type, const hicn_protocol_t *h)
     return HICN_LIB_ERROR_##error;                                            \
   }
 
+#define DECLARE_get_payload_type(protocol, error)                             \
+  int protocol##_get_payload_type (hicn_type_t type,                          \
+				   const hicn_protocol_t *h,                  \
+				   hicn_payload_type_t *payload_type)         \
+  {                                                                           \
+    return HICN_LIB_ERROR_##error;                                            \
+  }
+
+#define DECLARE_set_payload_type(protocol, error)                             \
+  int protocol##_set_payload_type (hicn_type_t type, hicn_protocol_t *h,      \
+				   hicn_payload_type_t payload_type)          \
+  {                                                                           \
+    return HICN_LIB_ERROR_##error;                                            \
+  }
+
 #define DECLARE_get_signature_size(protocol, error)                           \
   int protocol##_get_signature_size (                                         \
     hicn_type_t type, const hicn_protocol_t *h, size_t *signature_size)       \
@@ -795,16 +869,16 @@ PAYLOAD (hicn_type_t type, const hicn_protocol_t *h)
     return HICN_LIB_ERROR_##error;                                            \
   }
 
-#define DECLARE_set_signature_gap(protocol, error)                            \
-  int protocol##_set_signature_gap (hicn_type_t type, hicn_protocol_t *h,     \
-				    uint8_t signature_size)                   \
+#define DECLARE_set_signature_padding(protocol, error)                        \
+  int protocol##_set_signature_padding (hicn_type_t type, hicn_protocol_t *h, \
+					size_t padding)                       \
   {                                                                           \
     return HICN_LIB_ERROR_##error;                                            \
   }
 
-#define DECLARE_get_signature_gap(protocol, error)                            \
-  int protocol##_get_signature_gap (                                          \
-    hicn_type_t type, const hicn_protocol_t *h, uint8_t *signature_size)      \
+#define DECLARE_get_signature_padding(protocol, error)                        \
+  int protocol##_get_signature_padding (                                      \
+    hicn_type_t type, const hicn_protocol_t *h, size_t *padding)              \
   {                                                                           \
     return HICN_LIB_ERROR_##error;                                            \
   }
@@ -860,6 +934,19 @@ PAYLOAD (hicn_type_t type, const hicn_protocol_t *h)
     return HICN_LIB_ERROR_##error;                                            \
   }
 
+#define DECLARE_is_last_data(protocol, error)                                 \
+  int protocol##_is_last_data (hicn_type_t type, const hicn_protocol_t *h,    \
+			       int *is_last)                                  \
+  {                                                                           \
+    return HICN_LIB_ERROR_##error;                                            \
+  }
+
+#define DECLARE_set_last_data(protocol, error)                                \
+  int protocol##_set_last_data (hicn_type_t type, hicn_protocol_t *h)         \
+  {                                                                           \
+    return HICN_LIB_ERROR_##error;                                            \
+  }
+
 #endif /* HICN_OPS_H */
 
 /*
diff --git a/lib/includes/hicn/policy.h b/lib/includes/hicn/policy.h
index e29888bd2..f39fa9272 100644
--- a/lib/includes/hicn/policy.h
+++ b/lib/includes/hicn/policy.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -30,37 +30,44 @@
 
 /* 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
+#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 IS_VALID_POLICY_TAG(x) (x != POLICY_TAG_N)
+
 #define MAXSZ_POLICY_TAG_ 11
-#define MAXSZ_POLICY_TAG MAXSZ_POLICY_TAG_ + 1
+#define MAXSZ_POLICY_TAG  MAXSZ_POLICY_TAG_ + 1
 
-extern const char * policy_tag_str[];
+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)
+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
+#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;
 }
@@ -69,182 +76,188 @@ foreach_policy_tag
 
 typedef int policy_tags_t;
 
-static inline
-void policy_tags_add(policy_tags_t * tags, policy_tag_t tag)
+static inline void
+policy_tags_add (policy_tags_t *tags, policy_tag_t tag)
 {
-    *tags |= (1 << tag);
+  *tags |= (1 << tag);
 }
 
-static inline
-void policy_tags_remove(policy_tags_t * tags, policy_tag_t tag)
+static inline void
+policy_tags_remove (policy_tags_t *tags, policy_tag_t tag)
 {
-    *tags &= ~(1 << tag);
+  *tags &= ~(1 << tag);
 }
 
-static inline
-int policy_tags_has(policy_tags_t tags, policy_tag_t tag)
+static inline int
+policy_tags_has (policy_tags_t tags, policy_tag_t tag)
 {
-    return tags & (1 << tag);
+  return tags & (1 << tag);
 }
 
-static inline
-void policy_tags_union(policy_tags_t * tags, policy_tags_t * tags_to_union)
+static inline void
+policy_tags_union (policy_tags_t *tags, policy_tags_t *tags_to_union)
 {
-#define _(x, y) *tags |= policy_tags_has(*tags_to_union, POLICY_TAG_ ## x) ? (1 << POLICY_TAG_ ## x) : 0;
-foreach_policy_tag
+#define _(x, y)                                                               \
+  *tags |= policy_tags_has (*tags_to_union, POLICY_TAG_##x) ?                 \
+		   (1 << POLICY_TAG_##x) :                                          \
+		   0;
+  foreach_policy_tag
 #undef _
 }
 
 #define POLICY_TAGS_EMPTY 0
 
-static inline
-int
-policy_tags_snprintf(char * s, size_t size, policy_tags_t tags)
+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
+#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;
+  return POLICY_TAG_N + 1;
 }
 
 #define MAXSZ_POLICY_TAGS_ POLICY_TAG_N + 1
-#define MAXSZ_POLICY_TAGS MAXSZ_POLICY_TAGS_ + 1
+#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
+#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
+#define MAXSZ_POLICY_STATE  MAXSZ_POLICY_STATE_ + 1
+
+extern const char *policy_state_str[];
 
-extern const char * policy_state_str[];
+#define policy_state_str(x) policy_state_str[x]
 
+policy_state_t policy_state_from_str (const char *str);
 
 /* POLICY TAG STATE */
 
-typedef struct {
-    policy_state_t state;
-    uint8_t disabled;
+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);
+#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;
+typedef struct
+{
+  float throughput;
+  float latency;
+  float loss_rate;
 } interface_stats_t;
 
-#define INTERFACE_STATS_NONE {                          \
-    .throughput = 0,                                    \
-    .latency = 0,                                       \
-    .loss_rate = 0,                                     \
-}
-
+#define INTERFACE_STATS_EMPTY                                                 \
+  {                                                                           \
+    .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;
+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,           \
-}
+#define POLICY_STATS_EMPTY                                                    \
+  (policy_stats_t)                                                            \
+  {                                                                           \
+    .wired = INTERFACE_STATS_EMPTY, .wifi = INTERFACE_STATS_EMPTY,            \
+    .cellular = INTERFACE_STATS_EMPTY, .all = INTERFACE_STATS_EMPTY,          \
+  }
 
-typedef struct {
-    uint32_t num_packets;
-    uint32_t num_bytes;
-    uint32_t num_losses;
-    uint32_t latency_idle;
+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,                          \
-}
+#define INTERFACE_COUNTERS_EMPTY                                              \
+  {                                                                           \
+    .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;
+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,                                   \
-}
+#define POLICY_COUNTERS_EMPTY                                                 \
+  (policy_counters_t)                                                         \
+  {                                                                           \
+    .wired = INTERFACE_COUNTERS_EMPTY, .wifi = INTERFACE_COUNTERS_EMPTY,      \
+    .cellular = INTERFACE_COUNTERS_EMPTY, .all = INTERFACE_COUNTERS_EMPTY,    \
+    .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;
+typedef struct
+{
+  char app_name[APP_NAME_LEN];
+  policy_tag_state_t tags[POLICY_TAG_N];
+  policy_stats_t stats;
 } hicn_policy_t;
 
-static const hicn_policy_t POLICY_NONE = {
+static const hicn_policy_t POLICY_EMPTY = {
     .app_name = { 0 },
     .tags = {
-#ifdef __ANDROID__
 #define _(x, y) { POLICY_STATE_NEUTRAL, 0 },
-#else
-#define _(x, y) [POLICY_TAG_ ## x] = { POLICY_STATE_NEUTRAL, 0 },
-#endif
 foreach_policy_tag
 #undef _
     },
-    .stats = POLICY_STATS_NONE,
+    .stats = POLICY_STATS_EMPTY,
 };
 
-
 /* 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];
-    };
-    hicn_policy_t policy;
+typedef struct
+{
+  int family;
+  union
+  {
+    char ipv4_prefix[INET_ADDRSTRLEN + PFX_STRLEN];
+    char ipv6_prefix[INET6_ADDRSTRLEN + PFX_STRLEN];
+  };
+  hicn_policy_t policy;
 } policy_description_t;
 
 #endif /* HICN_POLICY_H */
diff --git a/lib/includes/hicn/protocol.h b/lib/includes/hicn/protocol.h
index a97cc99cf..fb142e4c3 100644
--- a/lib/includes/hicn/protocol.h
+++ b/lib/includes/hicn/protocol.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -27,9 +27,11 @@
 #include "protocol/icmprd.h"
 #include "protocol/tcp.h"
 #include "protocol/udp.h"
+#include "protocol/new.h"
 
 typedef union
 {
+  _new_header_t newhdr;
   _ipv4_header_t ipv4;
   _ipv6_header_t ipv6;
   _tcp_header_t tcp;
diff --git a/lib/includes/hicn/protocol/ah.h b/lib/includes/hicn/protocol/ah.h
index 575da80d7..36fd7d509 100644
--- a/lib/includes/hicn/protocol/ah.h
+++ b/lib/includes/hicn/protocol/ah.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -35,19 +35,19 @@
 
 typedef struct
 {
-  u8 nh;	 // (to match with reserved in IPSEC AH)
-  u8 payloadlen; // Len of signature/HMAC in 4-bytes words (maximum size)
+  u8 nh; // To match with reserved in IPSEC AH
+  // Length of the signature field. Note that the signature might be smaller
+  // than the field: the actual size is computed from the field size and
+  // signaturePadding.
+  u8 payloadlen;
   union
   {
     u16 reserved;
 
     struct
     {
-      u8 validationAlgorithm; // As defined in parc_SignerAlgorithm.h
-      u8 signatureGap;	      // used to match IPSEC specification and to
-			      // have the real size of the signature(without
-			      // padding). It is the result of Maximum
-			      // signature size - real size
+      u8 validationAlgorithm;
+      u8 signaturePadding;
     };
   };
   union
diff --git a/lib/includes/hicn/protocol/icmp.h b/lib/includes/hicn/protocol/icmp.h
index 36954bb6d..9315e1e56 100644
--- a/lib/includes/hicn/protocol/icmp.h
+++ b/lib/includes/hicn/protocol/icmp.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -34,7 +34,7 @@ typedef struct
   u16 csum;
 } _icmp_header_t;
 
-#define ICMP_HDRLEN sizeof(_icmp_header_t)
+#define ICMP_HDRLEN sizeof (_icmp_header_t)
 static_assert (EXPECTED_ICMP_HDRLEN == ICMP_HDRLEN,
 	       "Size of ICMP struct does not match its expected size.");
 
@@ -54,13 +54,13 @@ typedef struct
     {
       u16 id;
       u16 sequence;
-    } echo;			/* echo datagram */
-    u32 gateway;		/* gateway address */
+    } echo;	 /* echo datagram */
+    u32 gateway; /* gateway address */
     struct
     {
       u16 _unused;
       u16 mtu;
-    } frag;			/* path mtu discovery */
+    } frag; /* path mtu discovery */
     struct
     {
       u16 expected_lbl;
@@ -69,7 +69,7 @@ typedef struct
   };
 } _icmp_wldr_header_t;
 
-#define ICMPWLDR_HDRLEN sizeof(_icmp_wldr_header_t)
+#define ICMPWLDR_HDRLEN sizeof (_icmp_wldr_header_t)
 static_assert (EXPECTED_ICMPWLDR_HDRLEN == ICMPWLDR_HDRLEN,
 	       "Size of ICMPWLDR struct does not match its expected size.");
 
diff --git a/lib/includes/hicn/protocol/icmprd.h b/lib/includes/hicn/protocol/icmprd.h
index aa1fa01ae..897e7969e 100644
--- a/lib/includes/hicn/protocol/icmprd.h
+++ b/lib/includes/hicn/protocol/icmprd.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -38,7 +38,7 @@ typedef struct
   u8 data[64];
 } _icmprd4_header_t;
 
-#define ICMPRD4_HDRLEN sizeof(_icmprd4_header_t)
+#define ICMPRD4_HDRLEN sizeof (_icmprd4_header_t)
 static_assert (EXPECTED_ICMPRD4_HDRLEN == ICMPRD4_HDRLEN,
 	       "Size of ICMPWLDR struct does not match its expected size.");
 
@@ -57,7 +57,7 @@ typedef struct
   ip6_address_t dst;
 } _icmprd_header_t;
 
-#define ICMPRD_HDRLEN sizeof(_icmprd_header_t)
+#define ICMPRD_HDRLEN sizeof (_icmprd_header_t)
 static_assert (EXPECTED_ICMPRD_HDRLEN == ICMPRD_HDRLEN,
 	       "Size of ICMPWLDR struct does not match its expected size.");
 
diff --git a/lib/includes/hicn/protocol/ipv4.h b/lib/includes/hicn/protocol/ipv4.h
index 8a5b6683b..44e95c1e3 100644
--- a/lib/includes/hicn/protocol/ipv4.h
+++ b/lib/includes/hicn/protocol/ipv4.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,9 +16,10 @@
 #ifndef HICN_PROTOCOL_IPV4
 #define HICN_PROTOCOL_IPV4
 
+#include <hicn/util/ip_address.h>
+
 #include "../base.h"
 #include "../common.h"
-#include "../protocol.h"
 
 /* Headers were adapted from linux' definitions in netinet/ip.h */
 
@@ -34,11 +35,11 @@ typedef struct
     struct
     {
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-      u8 ihl:4;
-      u8 version:4;
+      u8 ihl : 4;
+      u8 version : 4;
 #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-      u8 version:4;
-      u8 ihl:4;
+      u8 version : 4;
+      u8 ihl : 4;
 #else
 #error "Unsupported endianness"
 #endif
@@ -57,9 +58,10 @@ typedef struct
   ip4_address_t daddr;
 } _ipv4_header_t;
 
-#define ipv4_header_bytes(ipv4_header) (sizeof(u32) * (ipv4_header->version_ihl & 0xf))
+#define ipv4_header_bytes(ipv4_header)                                        \
+  (sizeof (u32) * (ipv4_header->version_ihl & 0xf))
 
-#define IPV4_HDRLEN sizeof(_ipv4_header_t)
+#define IPV4_HDRLEN sizeof (_ipv4_header_t)
 static_assert (EXPECTED_IPV4_HDRLEN == IPV4_HDRLEN,
 	       "Size of IPV4 struct does not match its expected size.");
 
@@ -77,22 +79,21 @@ typedef struct
   u16 size;
 } ipv4_pseudo_header_t;
 
-#define IPV4_PSHDRLEN sizeof(ipv4_pseudo_header_t)
+#define IPV4_PSHDRLEN sizeof (ipv4_pseudo_header_t)
 static_assert (EXPECTED_IPV4_PSHDRLEN == IPV4_PSHDRLEN,
 	       "Size of IPV4_PSHDR struct does not match its expected size.");
 
 /* Default field values */
-#define IPV4_DEFAULT_VERSION         4
-#define IPV4_DEFAULT_IHL             5
-#define IPV4_DEFAULT_TOS             0
-#define IPV4_DEFAULT_PAYLOAD_LENGTH  0
-#define IPV4_DEFAULT_ID              300
-#define IPV4_DEFAULT_FRAG_OFF        0x000
-#define IPV4_DEFAULT_TTL             64
-#define IPV4_DEFAULT_PROTOCOL        IPPROTO_TCP
-#define IPV4_DEFAULT_SRC_IP          0, 0, 0, 0
-#define IPV4_DEFAULT_DST_IP          0, 0, 0, 0
-
+#define IPV4_DEFAULT_VERSION	    4
+#define IPV4_DEFAULT_IHL	    5
+#define IPV4_DEFAULT_TOS	    0
+#define IPV4_DEFAULT_PAYLOAD_LENGTH 0
+#define IPV4_DEFAULT_ID		    300
+#define IPV4_DEFAULT_FRAG_OFF	    0x000
+#define IPV4_DEFAULT_TTL	    64
+#define IPV4_DEFAULT_PROTOCOL	    IPPROTO_TCP
+#define IPV4_DEFAULT_SRC_IP	    0, 0, 0, 0
+#define IPV4_DEFAULT_DST_IP	    0, 0, 0, 0
 
 #endif /* HICN_PROTOCOL_IPV4 */
 
diff --git a/lib/includes/hicn/protocol/ipv6.h b/lib/includes/hicn/protocol/ipv6.h
index 5a83abcae..86301e7d1 100644
--- a/lib/includes/hicn/protocol/ipv6.h
+++ b/lib/includes/hicn/protocol/ipv6.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,6 +16,8 @@
 #ifndef HICN_PROTOCOL_IPV6_H
 #define HICN_PROTOCOL_IPV6_H
 
+#include <hicn/util/ip_address.h>
+
 #include "../common.h"
 
 /*
@@ -25,22 +27,26 @@
 
 typedef struct
 {
+#if 0 // TEMPORARY FIX
   union
   {
     struct
     {
-      u32 version_class_flow;	/* version, traffic class and 20 bits of flow-ID */
-      u16 len;			/* payload length */
-      u8 nxt;			/* next header */
-      u8 hlim;			/* hop limit */
+#endif
+  u32 version_class_flow; /* version, traffic class and 20 bits of flow-ID */
+  u16 len;		  /* payload length */
+  u8 nxt;		  /* next header */
+  u8 hlim;		  /* hop limit */
+#if 0
     };
     u8 vfc;			/* 4 bits version, top 4 bits class */
   };
-  ip6_address_t saddr;		/* source address */
-  ip6_address_t daddr;		/* destination address */
+#endif
+  ip6_address_t saddr; /* source address */
+  ip6_address_t daddr; /* destination address */
 } _ipv6_header_t;
 
-#define IPV6_HDRLEN sizeof(_ipv6_header_t)
+#define IPV6_HDRLEN sizeof (_ipv6_header_t)
 static_assert (EXPECTED_IPV6_HDRLEN == IPV6_HDRLEN,
 	       "Size of IPV6 struct does not match its expected size.");
 
@@ -59,15 +65,15 @@ typedef struct
   u8 protocol;
 } ipv6_pseudo_header_t;
 
-#define IPV6_PSHDRLEN sizeof(ipv6_pseudo_header_t)
+#define IPV6_PSHDRLEN sizeof (ipv6_pseudo_header_t)
 static_assert (EXPECTED_IPV6_PSHDRLEN == IPV6_PSHDRLEN,
 	       "Size of IPV6_PSHDR struct does not match its expected size.");
 
 /* Default field values */
-#define IPV6_DEFAULT_VERSION         6
-#define IPV6_DEFAULT_TRAFFIC_CLASS   0
-#define IPV6_DEFAULT_FLOW_LABEL      0
-#define IPV6_DEFAULT_PAYLOAD_LENGTH  0
+#define IPV6_DEFAULT_VERSION	    6
+#define IPV6_DEFAULT_TRAFFIC_CLASS  0
+#define IPV6_DEFAULT_FLOW_LABEL	    0
+#define IPV6_DEFAULT_PAYLOAD_LENGTH 0
 
 #endif
 
diff --git a/lib/includes/hicn/protocol/new.h b/lib/includes/hicn/protocol/new.h
new file mode 100644
index 000000000..47f7758d2
--- /dev/null
+++ b/lib/includes/hicn/protocol/new.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file protocol/ah.h
+ * @brief AH packet header
+ */
+#ifndef HICN_PROTOCOL_NEW_H
+#define HICN_PROTOCOL_NEW_H
+
+#include "../common.h"
+#include "../name.h"
+
+/*
+ * The length of the new header struct must be 28 bytes.
+ */
+#define EXPECTED_NEW_HDRLEN 32
+
+typedef struct
+{
+  u8 version_reserved;
+  u8 flags;
+  u16 payload_length;
+  u32 lifetime;
+  ip_address_t prefix;
+  u32 suffix;
+  u32 path_label;
+} _new_header_t;
+
+#define NEW_HDRLEN sizeof (_new_header_t)
+static_assert (EXPECTED_NEW_HDRLEN == NEW_HDRLEN,
+	       "Size of new_header Struct does not match its expected size.");
+
+/* TCP flags bit 0 first. */
+#define foreach_hicn_new_flag                                                 \
+  _ (SIG) /**< Signature header after. */                                     \
+  _ (MAN) /**< Payload type is manifest. */                                   \
+  _ (INT) /**< Packet is interest. */                                         \
+  _ (LST) /**< Last data. */
+
+enum
+{
+#define _(f) HICN_NEW_FLAG_BIT_##f,
+  foreach_hicn_new_flag
+#undef _
+    HICN_NEW_N_FLAG_BITS,
+};
+
+enum
+{
+#define _(f) HICN_NEW_FLAG_##f = 1 << HICN_NEW_FLAG_BIT_##f,
+  foreach_hicn_new_flag
+#undef _
+};
+
+static inline int
+_get_new_header_version (const _new_header_t *new_hdr)
+{
+  return ((new_hdr->version_reserved >> 4) & 0x0F);
+}
+
+static inline void
+_set_new_header_version (_new_header_t *new_hdr)
+{
+  new_hdr->version_reserved = (0x9 << 4) & 0xF0;
+}
+
+#endif /* HICN_PROTOCOL_NEW_H */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/includes/hicn/protocol/tcp.h b/lib/includes/hicn/protocol/tcp.h
index 347682299..1731f0c24 100644
--- a/lib/includes/hicn/protocol/tcp.h
+++ b/lib/includes/hicn/protocol/tcp.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -59,55 +59,55 @@ typedef struct
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
     struct
     {
-      u16 reserved:4;
-      u16 doff:4;
-      u16 fin:1;
-      u16 syn:1;
-      u16 rst:1;
-      u16 psh:1;
-      u16 ack:1;
-      u16 urg:1;
-      u16 ece:1;
-      u16 cwr:1;
+      u16 reserved : 4;
+      u16 doff : 4;
+      u16 fin : 1;
+      u16 syn : 1;
+      u16 rst : 1;
+      u16 psh : 1;
+      u16 ack : 1;
+      u16 urg : 1;
+      u16 ece : 1;
+      u16 cwr : 1;
     };
     struct
-    {				/* __ denotes unchanged bitfields */
-      u16 timescale:4;
-      u16 __doff:4;
-      u16 __fin:1;
-      u16 __syn:1;
-      u16 __rst:1;
-      u16 sig:1;
-      u16 __ack:1;
-      u16 man:1;
-      u16 id:1;
-      u16 __cwr:1;
+    { /* __ denotes unchanged bitfields */
+      u16 timescale : 4;
+      u16 __doff : 4;
+      u16 __fin : 1;
+      u16 __syn : 1;
+      u16 __rst : 1;
+      u16 sig : 1;
+      u16 __ack : 1;
+      u16 man : 1;
+      u16 id : 1;
+      u16 __cwr : 1;
     };
 #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
     struct
     {
-      u16 doff:4;
-      u16 reserved:4;
-      u16 cwr:1;
-      u16 ece:1;
-      u16 urg:1;
-      u16 ack:1;
-      u16 psh:1;
-      u16 rst:1;
-      u16 syn:1;
-      u16 fin:1;
+      u16 doff : 4;
+      u16 reserved : 4;
+      u16 cwr : 1;
+      u16 ece : 1;
+      u16 urg : 1;
+      u16 ack : 1;
+      u16 psh : 1;
+      u16 rst : 1;
+      u16 syn : 1;
+      u16 fin : 1;
     };
     struct
     {
-      u16 __doff:4;
-      u16 timescale:4;
-      u16 __cwr:1;
-      u16 id:1 u16 man:1;
-      u16 __ack:1;
-      u16 sig:1;
-      u16 __rst:1;
-      u16 __syn:1;
-      u16 __fin:1;
+      u16 __doff : 4;
+      u16 timescale : 4;
+      u16 __cwr : 1;
+      u16 id : 1 u16 man : 1;
+      u16 __ack : 1;
+      u16 sig : 1;
+      u16 __rst : 1;
+      u16 __syn : 1;
+      u16 __fin : 1;
     };
 #endif
   };
@@ -124,20 +124,20 @@ typedef struct
   };
 } _tcp_header_t;
 
-#define TCP_HDRLEN sizeof(_tcp_header_t)
+#define TCP_HDRLEN sizeof (_tcp_header_t)
 static_assert (EXPECTED_TCP_HDRLEN == TCP_HDRLEN,
 	       "Size of TCP struct does not match its expected size.");
 
 /* TCP flags bit 0 first. */
-#define foreach_tcp_flag                                \
-          _ (FIN) /**< No more data from sender. */             \
-      _ (SYN) /**< Synchronize sequence numbers. */         \
-      _ (RST) /**< Reset the connection. */                 \
-      _ (PSH) /**< Push function. */                        \
-      _ (ACK) /**< Ack field significant. */                \
-      _ (URG) /**< Urgent pointer field significant. */     \
-      _ (ECE) /**< ECN-echo. Receiver got CE packet */      \
-      _ (CWR) /**< Sender reduced congestion window */
+#define foreach_tcp_flag                                                      \
+  _ (FIN) /**< No more data from sender. */                                   \
+  _ (SYN) /**< Synchronize sequence numbers. */                               \
+  _ (RST) /**< Reset the connection. */                                       \
+  _ (PSH) /**< Push function. */                                              \
+  _ (ACK) /**< Ack field significant. */                                      \
+  _ (URG) /**< Urgent pointer field significant. */                           \
+  _ (ECE) /**< ECN-echo. Receiver got CE packet */                            \
+  _ (CWR) /**< Sender reduced congestion window */
 
 enum
 {
diff --git a/lib/includes/hicn/protocol/udp.h b/lib/includes/hicn/protocol/udp.h
index 75d1ea98c..0e0dddd2c 100644
--- a/lib/includes/hicn/protocol/udp.h
+++ b/lib/includes/hicn/protocol/udp.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -29,7 +29,7 @@ typedef struct
   u16 checksum;
 } _udp_header_t;
 
-#define UDP_HDRLEN sizeof(_udp_header_t)
+#define UDP_HDRLEN sizeof (_udp_header_t)
 static_assert (EXPECTED_UDP_HDRLEN == UDP_HDRLEN,
 	       "Size of UDP struct does not match its expected size.");
 
diff --git a/lib/includes/hicn/strategy.h b/lib/includes/hicn/strategy.h
new file mode 100644
index 000000000..c71db451a
--- /dev/null
+++ b/lib/includes/hicn/strategy.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file strategy.h
+ * \brief hICN forwarding strategy
+ */
+#ifndef HICN_STRATEGY_H
+#define HICN_STRATEGY_H
+
+#include <string.h>
+
+#define foreach_strategy_type                                                 \
+  _ (UNDEFINED)                                                               \
+  _ (LOADBALANCER)                                                            \
+  _ (LOW_LATENCY)                                                             \
+  _ (RANDOM)                                                                  \
+  _ (REPLICATION)                                                             \
+  _ (BESTPATH)                                                                \
+  _ (N)
+
+typedef enum
+{
+#define _(x) STRATEGY_TYPE_##x,
+  foreach_strategy_type
+#undef _
+} strategy_type_t;
+
+extern const char *strategy_str[];
+#define strategy_str(x) strategy_str[x]
+
+#define IS_VALID_STRATEGY_TYPE(x) IS_VALID_ENUM_TYPE (STRATEGY_TYPE, x)
+
+static inline strategy_type_t
+strategy_type_from_str (const char *strategy_str)
+{
+#define _(x)                                                                  \
+  if (strcasecmp (strategy_str, #x) == 0)                                     \
+    return STRATEGY_TYPE_##x;                                                 \
+  else
+  foreach_strategy_type
+#undef _
+    return STRATEGY_TYPE_UNDEFINED;
+}
+
+#define STRATEGY_TYPE_VALID(type)                                             \
+  ((type != STRATEGY_TYPE_UNDEFINED) && (type != STRATEGY_TYPE_N))
+
+#define MAX_FWD_STRATEGY_RELATED_PREFIXES 10
+
+#endif /* HICN_STRATEGY_H */
diff --git a/lib/includes/hicn/util/array.h b/lib/includes/hicn/util/array.h
index 56cfcad8b..46d60976e 100644
--- a/lib/includes/hicn/util/array.h
+++ b/lib/includes/hicn/util/array.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -23,178 +23,169 @@
 
 #include <assert.h>
 #include <hicn/util/log.h>
-#include <math.h> // log2
+#include <math.h>   // log2
 #include <string.h> // memmove
 
 #define BUFSIZE 1024
 
-typedef int(*cmp_t)(const void * x, const void * y);
-
-#define TYPEDEF_ARRAY_H(NAME, T)                                                \
-                                                                                \
-typedef struct {                                                                \
-    size_t size;                                                                \
-    size_t max_size_log;                                                        \
-    T * elements;                                                               \
-} NAME ## _t;                                                                   \
-                                                                                \
-int NAME ## _initialize(NAME ## _t * array);                                    \
-                                                                                \
-int NAME ## _finalize(NAME ## _t * array);                                      \
-                                                                                \
-NAME ## _t * NAME ## _create();                                                 \
-                                                                                \
-void NAME ## _free(NAME ## _t * array);                                         \
-                                                                                \
-int NAME ## _add(NAME ## _t * array, T element);                                \
-                                                                                \
-int NAME ## _remove_index(NAME ## _t * array, int index, T * element);          \
-                                                                                \
-int NAME ## _remove(NAME ## _t * array, const T search, T * element);           \
-                                                                                \
-int NAME ## _get(const NAME ## _t * array, const T search, T * element);        \
-                                                                                \
-int NAME ## _get_index(const NAME ## _t * array, int index, T * element);       \
-                                                                                \
-int NAME ## _get_elements(const NAME ## _t * array, T ** elements);             \
-                                                                                \
-size_t NAME ## _len(const NAME ## _t * array);
+typedef int (*cmp_t) (const void *x, const void *y);
 
+#define TYPEDEF_ARRAY_H(NAME, T)                                              \
+                                                                              \
+  typedef struct                                                              \
+  {                                                                           \
+    size_t size;                                                              \
+    size_t max_size_log;                                                      \
+    T *elements;                                                              \
+  } NAME##_t;                                                                 \
+                                                                              \
+  int NAME##_initialize (NAME##_t *array);                                    \
+                                                                              \
+  int NAME##_finalize (NAME##_t *array);                                      \
+                                                                              \
+  NAME##_t *NAME##_create ();                                                 \
+                                                                              \
+  void NAME##_free (NAME##_t *array);                                         \
+                                                                              \
+  int NAME##_add (NAME##_t *array, T element);                                \
+                                                                              \
+  int NAME##_remove_index (NAME##_t *array, int index, T *element);           \
+                                                                              \
+  int NAME##_remove (NAME##_t *array, const T search, T *element);            \
+                                                                              \
+  int NAME##_get (const NAME##_t *array, const T search, T *element);         \
+                                                                              \
+  int NAME##_get_index (const NAME##_t *array, int index, T *element);        \
+                                                                              \
+  int NAME##_get_elements (const NAME##_t *array, T **elements);              \
+                                                                              \
+  size_t NAME##_len (const NAME##_t *array);
 
 #define ARRAY_MAX_SIZE_LOG_INIT 0
 
-#define TYPEDEF_ARRAY(NAME, T, CMP, SNPRINTF)                                   \
-int                                                                             \
-NAME ## _initialize(NAME ## _t * array)                                         \
-{                                                                               \
-    array->max_size_log = ARRAY_MAX_SIZE_LOG_INIT;                              \
-    array->size = 0;                                                            \
-    if (array->max_size_log == 0) {                                             \
-        array->elements = NULL;                                                 \
-        return 0;                                                               \
-    }                                                                           \
-    array->elements = malloc((1 << array->max_size_log) * sizeof(T));           \
-    if (!array->elements)                                                       \
-        return -1;                                                              \
-    return 0;                                                                   \
-}                                                                               \
-                                                                                \
-int                                                                             \
-NAME ## _finalize(NAME ## _t * array)                                           \
-{                                                                               \
-    for (unsigned i = 0; i < array->size; i++) {                                \
-        NAME ## _remove_index(array, i, NULL);                                  \
-    }                                                                           \
-    return 0;                                                                   \
-}                                                                               \
-                                                                                \
-NAME ## _t *                                                                    \
-NAME ## _create()                                                               \
-{                                                                               \
-    NAME ## _t * array = malloc(sizeof(NAME ## _t));                            \
-    if (!array)                                                                 \
-        goto ERR_MALLOC;                                                        \
-                                                                                \
-    if (NAME ## _initialize(array) < 0)                                         \
-        goto ERR_INITIALIZE;                                                    \
-                                                                                \
-    return array;                                                               \
-                                                                                \
-ERR_INITIALIZE:                                                                 \
-    free(array);                                                                \
-ERR_MALLOC:                                                                     \
-    return NULL;                                                                \
-}                                                                               \
-                                                                                \
-void                                                                            \
-NAME ## _free(NAME ## _t * array)                                               \
-{                                                                               \
-    NAME ## _finalize(array);                                                   \
-    free(array->elements);                                                      \
-    free(array);                                                                \
-}                                                                               \
-                                                                                \
-int                                                                             \
-NAME ## _add(NAME ## _t * array, T element)                                     \
-{                                                                               \
-    /* Ensure sufficient space for next addition */                             \
-    size_t new_size_log = (array->size > 0) ? log2(array->size)+1 : 1;          \
-    if (new_size_log > array->max_size_log) {                                   \
-        array->max_size_log = new_size_log;                                     \
-        array->elements = realloc(array->elements,                              \
-                (1 << new_size_log) * sizeof(T));                               \
-    }                                                                           \
-                                                                                \
-    if (!array->elements)                                                       \
-        goto ERR_REALLOC;                                                       \
-                                                                                \
-    array->elements[array->size++] = element;                                   \
-    return 0;                                                                   \
-                                                                                \
-ERR_REALLOC:                                                                    \
-    return -1;                                                                  \
-}                                                                               \
-                                                                                \
-int                                                                             \
-NAME ## _remove_index(NAME ## _t * array, int index, T * element)               \
-{                                                                               \
-    if (index > NAME ## _len(array))                                            \
-        return -1;                                                              \
-    if (element)                                                                \
-        *element = array->elements[index];                                      \
-    if (index < array->size)                                                    \
-        memmove(array->elements + index, array->elements + index + 1,           \
-                array->size - index);                                           \
-    array->size--;                                                              \
-    return 0;                                                                   \
-}                                                                               \
-                                                                                \
-int                                                                             \
-NAME ## _remove(NAME ## _t * array, const T search, T * element)                \
-{                                                                               \
-    for (unsigned i = 0; i < array->size; i++) {                                \
-        if (CMP(search, array->elements[i]) == 0)                               \
-            return facelet_array_remove_index(array, i, element);               \
-    }                                                                           \
-    /* Not found */                                                             \
-    if (element)                                                                \
-        *element = NULL;                                                        \
-    return 0;                                                                   \
-}                                                                               \
-                                                                                \
-int                                                                             \
-NAME ## _get(const NAME ## _t * array, const T search, T * element)             \
-{                                                                               \
-    assert(element);                                                            \
-    for (unsigned i = 0; i < array->size; i++)                                  \
-        if (CMP(search, array->elements[i]) == 0) {                             \
-            *element = array->elements[i];                                      \
-            return 0;                                                           \
-        }                                                                       \
-    /* Not found */                                                             \
-    *element = NULL;                                                            \
-    return 0;                                                                   \
-}                                                                               \
-                                                                                \
-int                                                                             \
-NAME ## _get_index(const NAME ## _t * array, int index, T * element)            \
-{                                                                               \
-    assert(element);                                                            \
-    *element = array->elements[index];                                          \
-    return 0;                                                                   \
-}                                                                               \
-                                                                                \
-int                                                                             \
-NAME ## _get_elements(const NAME ## _t * array, T ** elements)                  \
-{                                                                               \
-    *elements = array->elements;                                                \
-    return 0;                                                                   \
-}                                                                               \
-                                                                                \
-size_t                                                                          \
-NAME ## _len(const NAME ## _t * array)                                          \
-{                                                                               \
-    return array->size;                                                         \
-}
+#define TYPEDEF_ARRAY(NAME, T, CMP, SNPRINTF)                                 \
+  int NAME##_initialize (NAME##_t *array)                                     \
+  {                                                                           \
+    array->max_size_log = ARRAY_MAX_SIZE_LOG_INIT;                            \
+    array->size = 0;                                                          \
+    if (array->max_size_log == 0)                                             \
+      {                                                                       \
+	array->elements = NULL;                                               \
+	return 0;                                                             \
+      }                                                                       \
+    array->elements = malloc ((1 << array->max_size_log) * sizeof (T));       \
+    if (!array->elements)                                                     \
+      return -1;                                                              \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  int NAME##_finalize (NAME##_t *array)                                       \
+  {                                                                           \
+    for (unsigned i = 0; i < array->size; i++)                                \
+      {                                                                       \
+	NAME##_remove_index (array, i, NULL);                                 \
+      }                                                                       \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  NAME##_t *NAME##_create ()                                                  \
+  {                                                                           \
+    NAME##_t *array = malloc (sizeof (NAME##_t));                             \
+    if (!array)                                                               \
+      goto ERR_MALLOC;                                                        \
+                                                                              \
+    if (NAME##_initialize (array) < 0)                                        \
+      goto ERR_INITIALIZE;                                                    \
+                                                                              \
+    return array;                                                             \
+                                                                              \
+  ERR_INITIALIZE:                                                             \
+    free (array);                                                             \
+  ERR_MALLOC:                                                                 \
+    return NULL;                                                              \
+  }                                                                           \
+                                                                              \
+  void NAME##_free (NAME##_t *array)                                          \
+  {                                                                           \
+    NAME##_finalize (array);                                                  \
+    free (array->elements);                                                   \
+    free (array);                                                             \
+  }                                                                           \
+                                                                              \
+  int NAME##_add (NAME##_t *array, T element)                                 \
+  {                                                                           \
+    /* Ensure sufficient space for next addition */                           \
+    size_t new_size_log = (array->size > 0) ? log2 (array->size) + 1 : 1;     \
+    if (new_size_log > array->max_size_log)                                   \
+      {                                                                       \
+	array->max_size_log = new_size_log;                                   \
+	array->elements =                                                     \
+	  realloc (array->elements, (1 << new_size_log) * sizeof (T));        \
+      }                                                                       \
+                                                                              \
+    if (!array->elements)                                                     \
+      goto ERR_REALLOC;                                                       \
+                                                                              \
+    array->elements[array->size++] = element;                                 \
+    return 0;                                                                 \
+                                                                              \
+  ERR_REALLOC:                                                                \
+    return -1;                                                                \
+  }                                                                           \
+                                                                              \
+  int NAME##_remove_index (NAME##_t *array, int index, T *element)            \
+  {                                                                           \
+    if (index > NAME##_len (array))                                           \
+      return -1;                                                              \
+    if (element)                                                              \
+      *element = array->elements[index];                                      \
+    if (index < array->size)                                                  \
+      memmove (array->elements + index, array->elements + index + 1,          \
+	       array->size - index);                                          \
+    array->size--;                                                            \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  int NAME##_remove (NAME##_t *array, const T search, T *element)             \
+  {                                                                           \
+    for (unsigned i = 0; i < array->size; i++)                                \
+      {                                                                       \
+	if (CMP (search, array->elements[i]) == 0)                            \
+	  return facelet_array_remove_index (array, i, element);              \
+      }                                                                       \
+    /* Not found */                                                           \
+    if (element)                                                              \
+      *element = NULL;                                                        \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  int NAME##_get (const NAME##_t *array, const T search, T *element)          \
+  {                                                                           \
+    assert (element);                                                         \
+    for (unsigned i = 0; i < array->size; i++)                                \
+      if (CMP (search, array->elements[i]) == 0)                              \
+	{                                                                     \
+	  *element = array->elements[i];                                      \
+	  return 0;                                                           \
+	}                                                                     \
+    /* Not found */                                                           \
+    *element = NULL;                                                          \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  int NAME##_get_index (const NAME##_t *array, int index, T *element)         \
+  {                                                                           \
+    assert (element);                                                         \
+    *element = array->elements[index];                                        \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  int NAME##_get_elements (const NAME##_t *array, T **elements)               \
+  {                                                                           \
+    *elements = array->elements;                                              \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  size_t NAME##_len (const NAME##_t *array) { return array->size; }
 
 #endif /* UTIL_ARRAY_H */
diff --git a/lib/includes/hicn/util/ip_address.h b/lib/includes/hicn/util/ip_address.h
index 4facd9ad0..89a4c11e0 100644
--- a/lib/includes/hicn/util/ip_address.h
+++ b/lib/includes/hicn/util/ip_address.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -20,10 +20,9 @@
 #ifndef UTIL_IP_ADDRESS_H
 #define UTIL_IP_ADDRESS_H
 
-
 #ifdef __APPLE__
 #include <libkern/OSByteOrder.h>
-#define __bswap_constant_32(x) OSSwapInt32(x)
+#define __bswap_constant_32(x) OSSwapInt32 (x)
 #include <machine/endian.h>
 #else
 #ifdef __ANDROID__
@@ -34,8 +33,8 @@
 #include <errno.h>
 
 #ifndef _WIN32
-#include <netinet/in.h>        // struct sockadd
-#include <arpa/inet.h>  // inet_ntop
+#include <netinet/in.h> // struct sockadd
+#include <arpa/inet.h>
 #include <netdb.h> // struct addrinfo
 #endif
 #include <stdbool.h>
@@ -45,11 +44,12 @@
 
 #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 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 MAX_IPV6_PREFIX_LEN 128
 
 /* Presentation format */
 #ifndef INET_ADDRSTRLEN
@@ -65,25 +65,34 @@
 
 #define DUMMY_PORT 1234
 
-typedef union {
-    struct {
-        u32 pad[3];
-        union {
-                struct in_addr as_inaddr;
-                u8 buffer[4];
-                u8 as_u8[4];
-                u16 as_u16[2];
-                u32 as_u32;
-        } v4;
-    };
-    union {
-        struct in6_addr as_in6addr;
-        u8 buffer[16];
-        u8 as_u8[16];
-        u16 as_u16[8];
-        u32 as_u32[4];
-        u64 as_u64[2];
-    } v6;
+#ifndef HICN_VPP_PLUGIN
+typedef union
+{
+  struct in_addr as_inaddr;
+  u8 buffer[4];
+  u8 as_u8[4];
+  u16 as_u16[2];
+  u32 as_u32;
+} ip4_address_t;
+
+typedef union
+{
+  struct in6_addr as_in6addr;
+  u8 buffer[16];
+  u8 as_u8[16];
+  u16 as_u16[8];
+  u32 as_u32[4];
+  u64 as_u64[2];
+} ip6_address_t;
+
+typedef union
+{
+  struct
+  {
+    u32 pad[3];
+    ip4_address_t v4;
+  };
+  ip6_address_t v6;
 #if 0 /* removed as prone to error due to IPv4 padding */
     u8 buffer[IP_MAX_ADDR_LEN];
     u8 as_u8[IP_MAX_ADDR_LEN];
@@ -93,77 +102,105 @@ typedef union {
 #endif
 } ip_address_t;
 
+#else
+
+#include <vnet/ip/ip4_packet.h> // ip4_address_t
+#include <vnet/ip/ip6_packet.h> // ip6_address_t
+
+#if __GNUC__ >= 9
+#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
+#endif
+
+#include <vnet/ip/ip46_address.h>
+
+#if __GNUC__ >= 9
+#pragma GCC diagnostic pop
+#endif
+
+typedef ip46_address_t ip_address_t;
+
+#endif /* HICN_VPP_PLUGIN */
+
+#define ip_address_is_v4(ip)                                                  \
+  (((ip)->pad[0] | (ip)->pad[1] | (ip)->pad[2]) == 0)
+
 #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
+#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 {
+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
+#define MAXSZ_IP_PREFIX_ MAXSZ_IP_ADDRESS_ + 1 + 3
+#define MAXSZ_IP_PREFIX	 MAXSZ_IP_PREFIX_ + 1
 
 extern const ip_address_t IPV4_LOOPBACK;
 extern const ip_address_t IPV6_LOOPBACK;
 extern const ip_address_t IPV4_ANY;
 extern const ip_address_t IPV6_ANY;
+
+extern const ip4_address_t IP4_ADDRESS_EMPTY;
+extern const ip6_address_t IP6_ADDRESS_EMPTY;
 extern const ip_address_t IP_ADDRESS_EMPTY;
 
 #define IP_ANY(family) (family == AF_INET) ? IPV4_ANY : IPV6_ANY
 
-
-#define MAX_PORT 1 << (8 * sizeof(u16))
-#define IS_VALID_PORT(x) ((x > 0) && ((int)x < MAX_PORT))
+#define MAX_PORT	 1 << (8 * sizeof (u16))
+#define IS_VALID_PORT(x) ((x > 0) && ((int) x < MAX_PORT))
 
 #define MAXSZ_PORT_ 5
-#define MAXSZ_PORT MAXSZ_PORT_ + 1
+#define MAXSZ_PORT  MAXSZ_PORT_ + 1
 
 #define IS_VALID_FAMILY(x) ((x == AF_INET) || (x == AF_INET6))
 
 /* IP address */
 
-int ip_address_get_family (const char * ip_address);
+int ip_address_get_family (const char *ip_address);
 int ip_address_len (int family);
-const u8 * ip_address_get_buffer(const ip_address_t * ip_address, int family);
-int ip_address_ntop (const ip_address_t * ip_address, char *dst,
-        const size_t len, int family);
-int ip_address_pton (const char *ip_address_str, ip_address_t * ip_address);
-int ip_address_snprintf(char * s, size_t size, const ip_address_t * ip_address,
-        int family);
-int ip_address_to_sockaddr(const ip_address_t * ip_address, struct sockaddr *sa,
-        int family);
-int ip_address_cmp(const ip_address_t * ip1, const ip_address_t * ip2, int family);
-int ip_address_empty(const ip_address_t * ip);
+const u8 *ip_address_get_buffer (const ip_address_t *ip_address, int family);
+int ip_address_ntop (const ip_address_t *ip_address, char *dst,
+		     const size_t len, int family);
+int ip_address_pton (const char *ip_address_str, ip_address_t *ip_address);
+int ip_address_snprintf (char *s, size_t size, const ip_address_t *ip_address,
+			 int family);
+int ip_address_to_sockaddr (const ip_address_t *ip_address,
+			    struct sockaddr *sa, int family);
+int ip_address_cmp (const ip_address_t *ip1, const ip_address_t *ip2,
+		    int family);
+int ip_address_empty (const ip_address_t *ip);
 
 /* Prefix */
 
-int ip_prefix_pton (const char *ip_address_str, ip_prefix_t * ip_prefix);
-int ip_prefix_ntop_short (const ip_prefix_t * ip_prefix, char *dst, size_t size);
-int ip_prefix_ntop (const ip_prefix_t * ip_prefix, char *dst, size_t size);
-int ip_prefix_len (const ip_prefix_t * prefix);
-bool ip_prefix_empty (const ip_prefix_t * prefix);
-int ip_prefix_to_sockaddr(const ip_prefix_t * prefix, struct sockaddr *sa);
-int ip_prefix_cmp(const ip_prefix_t * prefix1, const ip_prefix_t * prefix2);
+int ip_prefix_pton (const char *ip_address_str, ip_prefix_t *ip_prefix);
+int ip_prefix_ntop_short (const ip_prefix_t *ip_prefix, char *dst,
+			  size_t size);
+int ip_prefix_ntop (const ip_prefix_t *ip_prefix, char *dst, size_t size);
+int ip_prefix_snprintf (char *s, size_t size, const ip_prefix_t *prefix);
+int ip_prefix_len (const ip_prefix_t *prefix);
+bool ip_prefix_empty (const ip_prefix_t *prefix);
+int ip_prefix_to_sockaddr (const ip_prefix_t *prefix, struct sockaddr *sa);
+int ip_prefix_cmp (const ip_prefix_t *prefix1, const ip_prefix_t *prefix2);
 
 /* URL */
 
 #define MAXSZ_PROTO_ 8 /* inetX:// */
-#define MAXSZ_PROTO MAXSZ_PROTO_ + NULLTERM
+#define MAXSZ_PROTO  MAXSZ_PROTO_ + NULLTERM
 
 #define MAXSZ_URL4_ MAXSZ_PROTO_ + MAXSZ_IP4_ADDRESS_ + MAXSZ_PORT_
 #define MAXSZ_URL6_ MAXSZ_PROTO_ + MAXSZ_IP6_ADDRESS_ + MAXSZ_PORT_
-#define MAXSZ_URL_ MAXSZ_URL6_
-#define MAXSZ_URL4 MAXSZ_URL4_ + NULLTERM
-#define MAXSZ_URL6 MAXSZ_URL6_ + NULLTERM
-#define MAXSZ_URL MAXSZ_URL_ + NULLTERM
+#define MAXSZ_URL_  MAXSZ_URL6_
+#define MAXSZ_URL4  MAXSZ_URL4_ + NULLTERM
+#define MAXSZ_URL6  MAXSZ_URL6_ + NULLTERM
+#define MAXSZ_URL   MAXSZ_URL_ + NULLTERM
 
-int url_snprintf(char * s, size_t size, int family,
-        const ip_address_t * ip_address, u16 port);
+int url_snprintf (char *s, size_t size, int family,
+		  const ip_address_t *ip_address, u16 port);
 
 #endif /* UTIL_IP_ADDRESS_H */
diff --git a/lib/includes/hicn/util/log.h b/lib/includes/hicn/util/log.h
index 6763d464f..6b35d1fef 100644
--- a/lib/includes/hicn/util/log.h
+++ b/lib/includes/hicn/util/log.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -17,8 +17,8 @@
 #define UTIL_LOG_H
 
 #include <stdarg.h> // va_*
-#include <stdio.h> // FILE
-#include <time.h> // time, localtime
+#include <stdio.h>  // FILE
+#include <time.h>   // time, localtime
 
 #define LOG_FATAL 0
 #define LOG_ERROR 1
@@ -27,43 +27,59 @@
 #define LOG_DEBUG 4
 #define LOG_TRACE 5
 
-typedef struct {
+typedef struct
+{
   int log_level;
   int debug;
-  FILE * log_file;
+  FILE *log_file;
 } log_conf_t;
 
-#define DEFAULT_LOG_CONF {      \
-    .log_level = LOG_INFO,      \
-    .debug = 0,                 \
-    .log_file = NULL,           \
-};
+#define DEFAULT_LOG_CONF                                                      \
+  {                                                                           \
+    .log_level = LOG_INFO,                                                    \
+    .debug = 0,                                                               \
+    .log_file = NULL,                                                         \
+  };
 
 extern log_conf_t log_conf;
 
-#define WITH_DEBUG(BLOCK)                       \
-    if (log_conf.log_level >= LOG_DEBUG)        \
-        BLOCK
+#define WITH_ERROR(BLOCK)                                                     \
+  if (log_conf.log_level >= LOG_ERROR)                                        \
+  BLOCK
+#define WITH_WARN(BLOCK)                                                      \
+  if (log_conf.log_level >= LOG_WARN)                                         \
+  BLOCK
+#define WITH_INFO(BLOCK)                                                      \
+  if (log_conf.log_level >= LOG_INFO)                                         \
+  BLOCK
+#define WITH_DEBUG(BLOCK)                                                     \
+  if (log_conf.log_level >= LOG_DEBUG)                                        \
+  BLOCK
+#define WITH_TRACE(BLOCK)                                                     \
+  if (log_conf.log_level >= LOG_TRACE)                                        \
+  BLOCK
 
-#define FATAL(fmt, ...) (_log(LOG_FATAL, fmt, ##__VA_ARGS__ ))
+#define FATAL(fmt, ...) (_log (LOG_FATAL, fmt, ##__VA_ARGS__))
 #ifdef ERROR
 #undef ERROR
 #endif
-#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__ ))
+#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_va (int level, const char *fmt, va_list ap);
 
-void _log(int level, const char *fmt, ...);
+void _log (int level, const char *fmt, ...);
 
-void fatal(char *fmt, ...);
+void fatal (char *fmt, ...);
+
+int loglevel_from_str (const char *loglevel);
 
 #ifdef HAVE_BACKTRACE
 #include <execinfo.h>
-void print_trace(void);
+void print_trace (void);
 #endif
 
 #endif // UTIL_LOG_H
diff --git a/lib/includes/hicn/util/map.h b/lib/includes/hicn/util/map.h
index 01195865e..6e23f222f 100644
--- a/lib/includes/hicn/util/map.h
+++ b/lib/includes/hicn/util/map.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -20,231 +20,227 @@
 
 #include "set.h"
 
-#define ERR_MAP_EXISTS -2
+#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;                                                              \
-                                                                                \
-NAME ## _pair_t * NAME ## _pair_create(KEY_T key, VAL_T value);                 \
-                                                                                \
-void NAME ## _pair_free(NAME ## _pair_t * pair);                                \
-                                                                                \
-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, 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_H(NAME, KEY_T, VAL_T)                                     \
+                                                                              \
+  typedef struct                                                              \
+  {                                                                           \
+    KEY_T key;                                                                \
+    VAL_T value;                                                              \
+  } NAME##_pair_t;                                                            \
+                                                                              \
+  NAME##_pair_t *NAME##_pair_create (KEY_T key, VAL_T value);                 \
+                                                                              \
+  void NAME##_pair_free (NAME##_pair_t *pair);                                \
+                                                                              \
+  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, 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);                                           \
+                                                                              \
+  int NAME##_get_key_array (NAME##_t *map, KEY_T **array);                    \
+                                                                              \
+  int NAME##_get_value_array (NAME##_t *map, VAL_T **array);
 
-
-
-
-#define TYPEDEF_MAP(NAME, KEY_T, VAL_T, CMP, KEY_SNPRINTF, VALUE_SNPRINTF)      \
-                                                                                \
-NAME ## _pair_t * NAME ## _pair_create(KEY_T key, VAL_T value)                  \
-{                                                                               \
-    /* Create pair */                                                           \
-    NAME ## _pair_t * pair = malloc(sizeof(NAME ## _pair_t));                   \
-    if (!pair)                                                                  \
-        return NULL;                                                            \
-                                                                                \
-    pair->key = key;                                                            \
-    pair->value = value;                                                        \
-                                                                                \
-    return pair;                                                                \
-}                                                                               \
-                                                                                \
-void NAME ## _pair_free(NAME ## _pair_t * pair)                                 \
-{                                                                               \
-    free(pair);                                                                 \
-}                                                                               \
-                                                                                \
-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 (int)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)                                             \
-{                                                                               \
-    NAME ## _pair_t ** array;                                                   \
-    int n = NAME ## _pair_set_get_array(&map->pair_set, &array);                \
-    if (n < 0)                                                                  \
-        return -1;                                                              \
-    for (unsigned i = 0; i < n; i++) {                                          \
-        NAME ## _pair_t * pair = array[i];                                      \
-        NAME ## _pair_set_remove(&map->pair_set, pair, NULL);                   \
-        NAME ## _pair_free(pair);                                               \
-    }                                                                           \
-    free(array);                                                                \
-    return NAME ## _pair_set_finalize(&map->pair_set);                          \
-}                                                                               \
-                                                                                \
-NAME ## _t *                                                                    \
-NAME ## _create()                                                               \
-{                                                                               \
-    NAME ## _t * map = malloc(sizeof(NAME ## _t));                              \
-    if (!map)                                                                   \
-        goto ERR_MALLOC;                                                        \
-                                                                                \
-    if (NAME ## _initialize(map) < 0)                                           \
-        goto ERR_INITIALIZE;                                                    \
-                                                                                \
-    return map;                                                                 \
-                                                                                \
-ERR_INITIALIZE:                                                                 \
-    free(map);                                                                  \
-ERR_MALLOC:                                                                     \
-    return NULL;                                                                \
-}                                                                               \
-                                                                                \
-void                                                                            \
-NAME ## _free(NAME ## _t * map)                                                 \
-{                                                                               \
-    NAME ## _finalize(map);                                                     \
-    free(map);                                                                  \
-}                                                                               \
-                                                                                \
-int                                                                             \
-NAME ## _add(NAME ## _t * map, KEY_T key, VAL_T value)                          \
-{                                                                               \
-    int rc;                                                                     \
-    NAME ## _pair_t * found = NULL;                                             \
-                                                                                \
-    NAME ## _pair_t * pair = NAME ## _pair_create(key, value);                  \
-    if (!pair)                                                                  \
-        return -1;                                                              \
-                                                                                \
-    rc = NAME ## _pair_set_get(&map->pair_set, pair, &found);                   \
-    if (rc < 0)                                                                 \
-        return -1;                                                              \
-    if (found) {                                                                \
-        NAME ## _pair_free(pair);                                               \
-        return ERR_MAP_EXISTS;                                                  \
-    }                                                                           \
-                                                                                \
-    rc = NAME ## _pair_set_add(&map->pair_set, pair);                           \
-    if (rc < 0) {                                                               \
-        NAME ## _pair_free(pair);                                               \
-        return -1;                                                              \
-    }                                                                           \
-    return 0;                                                                   \
-}                                                                               \
-                                                                                \
-int                                                                             \
-NAME ## _remove(NAME ## _t * map, KEY_T key, VAL_T * value)                     \
-{                                                                               \
-    NAME ## _pair_t * found = NULL;                                             \
-    NAME ## _pair_t search = { .key = key };                                    \
-    int rc = NAME ## _pair_set_remove(&map->pair_set, &search, &found);         \
-    if (rc < 0)                                                                 \
-        return ERR_MAP_NOT_FOUND;                                               \
-    if (value)                                                                  \
-        *value = found->value;                                                  \
-    NAME ## _pair_free(found);                                                  \
-    return 0;                                                                   \
-}                                                                               \
-                                                                                \
-int                                                                             \
-NAME ## _get(NAME ## _t * map, KEY_T key, VAL_T * value)                        \
-{                                                                               \
-    NAME ## _pair_t * found = NULL, search = { .key = key };                    \
-    int rc = NAME ## _pair_set_get(&map->pair_set, &search, &found);            \
-    if (rc < 0)                                                                 \
-        return -1;                                                              \
-    if (found)                                                                  \
-        *value = found->value;                                                  \
-    return 0;                                                                   \
-}                                                                               \
-                                                                                \
-void                                                                            \
-NAME ## _dump(NAME ## _t * map) {                                               \
-    NAME ## _pair_set_dump(&map->pair_set);                                     \
-}                                                                               \
-                                                                                \
-int                                                                             \
-NAME ## _get_key_array(NAME ## _t * map, KEY_T **array) {                       \
-    NAME ## _pair_t ** pair_array;                                              \
-    int n = NAME ## _pair_set_get_array(&map->pair_set, &pair_array);           \
-    if (n < 0)                                                                  \
-        return -1;                                                              \
-    if (!array)                                                                 \
-        goto END;                                                               \
-    /* Allocate result array */                                                 \
-    *array = malloc(n * sizeof(KEY_T));                                         \
-    if (!array) {                                                               \
-        free(pair_array);                                                       \
-        return -1;                                                              \
-    }                                                                           \
-    /* Copy keys */                                                             \
-    for (int i = 0; i < n; i++)                                                 \
-        (*array)[i] = pair_array[i]->key;                                       \
-    free(pair_array);                                                           \
-END:                                                                            \
-    return n;                                                                   \
-}                                                                               \
-                                                                                \
-int                                                                             \
-NAME ## _get_value_array(NAME ## _t * map, VAL_T **array) {                     \
-    NAME ## _pair_t ** pair_array;                                              \
-    int n = NAME ## _pair_set_get_array(&map->pair_set, &pair_array);           \
-    if (n < 0)                                                                  \
-        return -1;                                                              \
-    if (!array)                                                                 \
-        goto END;                                                               \
-    /* Allocate result array */                                                 \
-    *array = malloc(n * sizeof(VAL_T));                                         \
-    if (!array) {                                                               \
-        free(pair_array);                                                       \
-        return -1;                                                              \
-    }                                                                           \
-    /* Copy values */                                                           \
-    for (int i = 0; i < n; i++)                                                 \
-        (*array)[i] = pair_array[i]->value;                                     \
-    free(pair_array);                                                           \
-END:                                                                            \
-    return n;                                                                   \
-}
+#define TYPEDEF_MAP(NAME, KEY_T, VAL_T, CMP, KEY_SNPRINTF, VALUE_SNPRINTF)    \
+                                                                              \
+  NAME##_pair_t *NAME##_pair_create (KEY_T key, VAL_T value)                  \
+  {                                                                           \
+    /* Create pair */                                                         \
+    NAME##_pair_t *pair = malloc (sizeof (NAME##_pair_t));                    \
+    if (!pair)                                                                \
+      return NULL;                                                            \
+                                                                              \
+    pair->key = key;                                                          \
+    pair->value = value;                                                      \
+                                                                              \
+    return pair;                                                              \
+  }                                                                           \
+                                                                              \
+  void NAME##_pair_free (NAME##_pair_t *pair) { free (pair); }                \
+                                                                              \
+  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 (int) 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)                                         \
+  {                                                                           \
+    NAME##_pair_t **array;                                                    \
+    int n = NAME##_pair_set_get_array (&map->pair_set, &array);               \
+    if (n < 0)                                                                \
+      return -1;                                                              \
+    for (unsigned i = 0; i < n; i++)                                          \
+      {                                                                       \
+	NAME##_pair_t *pair = array[i];                                       \
+	NAME##_pair_set_remove (&map->pair_set, pair, NULL);                  \
+	NAME##_pair_free (pair);                                              \
+      }                                                                       \
+    free (array);                                                             \
+    return NAME##_pair_set_finalize (&map->pair_set);                         \
+  }                                                                           \
+                                                                              \
+  NAME##_t *NAME##_create ()                                                  \
+  {                                                                           \
+    NAME##_t *map = malloc (sizeof (NAME##_t));                               \
+    if (!map)                                                                 \
+      goto ERR_MALLOC;                                                        \
+                                                                              \
+    if (NAME##_initialize (map) < 0)                                          \
+      goto ERR_INITIALIZE;                                                    \
+                                                                              \
+    return map;                                                               \
+                                                                              \
+  ERR_INITIALIZE:                                                             \
+    free (map);                                                               \
+  ERR_MALLOC:                                                                 \
+    return NULL;                                                              \
+  }                                                                           \
+                                                                              \
+  void NAME##_free (NAME##_t *map)                                            \
+  {                                                                           \
+    NAME##_finalize (map);                                                    \
+    free (map);                                                               \
+  }                                                                           \
+                                                                              \
+  int NAME##_add (NAME##_t *map, KEY_T key, VAL_T value)                      \
+  {                                                                           \
+    int rc;                                                                   \
+    NAME##_pair_t *found = NULL;                                              \
+                                                                              \
+    NAME##_pair_t *pair = NAME##_pair_create (key, value);                    \
+    if (!pair)                                                                \
+      return -1;                                                              \
+                                                                              \
+    rc = NAME##_pair_set_get (&map->pair_set, pair, &found);                  \
+    if (rc < 0)                                                               \
+      return -1;                                                              \
+    if (found)                                                                \
+      {                                                                       \
+	NAME##_pair_free (pair);                                              \
+	return ERR_MAP_EXISTS;                                                \
+      }                                                                       \
+                                                                              \
+    rc = NAME##_pair_set_add (&map->pair_set, pair);                          \
+    if (rc < 0)                                                               \
+      {                                                                       \
+	NAME##_pair_free (pair);                                              \
+	return -1;                                                            \
+      }                                                                       \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  int NAME##_remove (NAME##_t *map, KEY_T key, VAL_T *value)                  \
+  {                                                                           \
+    NAME##_pair_t *found = NULL;                                              \
+    NAME##_pair_t search = { .key = key };                                    \
+    int rc = NAME##_pair_set_remove (&map->pair_set, &search, &found);        \
+    if (rc < 0)                                                               \
+      return ERR_MAP_NOT_FOUND;                                               \
+    if (value)                                                                \
+      *value = found->value;                                                  \
+    NAME##_pair_free (found);                                                 \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  int NAME##_get (NAME##_t *map, KEY_T key, VAL_T *value)                     \
+  {                                                                           \
+    NAME##_pair_t *found = NULL, search = { .key = key };                     \
+    int rc = NAME##_pair_set_get (&map->pair_set, &search, &found);           \
+    if (rc < 0)                                                               \
+      return -1;                                                              \
+    if (found)                                                                \
+      *value = found->value;                                                  \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  void NAME##_dump (NAME##_t *map) { NAME##_pair_set_dump (&map->pair_set); } \
+                                                                              \
+  int NAME##_get_key_array (NAME##_t *map, KEY_T **array)                     \
+  {                                                                           \
+    NAME##_pair_t **pair_array;                                               \
+    int n = NAME##_pair_set_get_array (&map->pair_set, &pair_array);          \
+    if (n < 0)                                                                \
+      return -1;                                                              \
+    if (!array)                                                               \
+      goto END;                                                               \
+    /* Allocate result array */                                               \
+    *array = malloc (n * sizeof (KEY_T));                                     \
+    if (!array)                                                               \
+      {                                                                       \
+	free (pair_array);                                                    \
+	return -1;                                                            \
+      }                                                                       \
+    /* Copy keys */                                                           \
+    for (int i = 0; i < n; i++)                                               \
+      (*array)[i] = pair_array[i]->key;                                       \
+    free (pair_array);                                                        \
+  END:                                                                        \
+    return n;                                                                 \
+  }                                                                           \
+                                                                              \
+  int NAME##_get_value_array (NAME##_t *map, VAL_T **array)                   \
+  {                                                                           \
+    NAME##_pair_t **pair_array;                                               \
+    int n = NAME##_pair_set_get_array (&map->pair_set, &pair_array);          \
+    if (n < 0)                                                                \
+      return -1;                                                              \
+    if (!array)                                                               \
+      goto END;                                                               \
+    /* Allocate result array */                                               \
+    *array = malloc (n * sizeof (VAL_T));                                     \
+    if (!array)                                                               \
+      {                                                                       \
+	free (pair_array);                                                    \
+	return -1;                                                            \
+      }                                                                       \
+    /* Copy values */                                                         \
+    for (int i = 0; i < n; i++)                                               \
+      (*array)[i] = pair_array[i]->value;                                     \
+    free (pair_array);                                                        \
+  END:                                                                        \
+    return n;                                                                 \
+  }
 
 #endif /* UTIL_MAP_H */
diff --git a/lib/includes/hicn/util/set.h b/lib/includes/hicn/util/set.h
index bc2e3caac..0a5ff6777 100644
--- a/lib/includes/hicn/util/set.h
+++ b/lib/includes/hicn/util/set.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,214 +25,196 @@
 #define thread_local _Thread_local
 //#endif /* ! __ANDROID__ */
 
-#define ERR_SET_EXISTS -2
+#define ERR_SET_EXISTS	  -2
 #define ERR_SET_NOT_FOUND -3
 
 /* FIXME: buffer overflow when this is too small... investigate */
 #define BUFSIZE 1024
 
-static inline
-int
-int_cmp(const int x, const int y)
+static inline int
+int_cmp (const int x, const int y)
 {
-    return x - y;
+  return x - y;
 }
 
-static inline
-int
-int_snprintf(char * buf, size_t size, int value) {
-    return snprintf(buf, size, "%d", value);
+static inline int
+int_snprintf (char *buf, size_t size, int value)
+{
+  return snprintf (buf, size, "%d", value);
 }
 
-static inline
-int
-string_snprintf(char * buf, size_t size, const char * s) {
-    return snprintf(buf, size, "%s", s);
+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, const void * value) {
-    return snprintf(buf, BUFSIZE, "%p", value);
+static inline int
+generic_snprintf (char *buf, size_t size, const void *value)
+{
+  return snprintf (buf, BUFSIZE, "%p", value);
 }
 
-typedef int(*cmp_t)(const void * x, const void * y);
-
-#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 ## _clear(NAME ## _t * set);                                   \
-                                                                        \
-int NAME ## _get(const NAME ## _t * set, const T search, T * element);  \
-                                                                        \
-int NAME ## _get_array(const NAME ## _t * set, T ** element);           \
-                                                                        \
-void NAME ## _dump(NAME ## _t * set);
+typedef int (*cmp_t) (const void *x, const void *y);
 
+#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##_clear (NAME##_t *set);                                           \
+                                                                              \
+  int NAME##_get (const NAME##_t *set, const T search, T *element);           \
+                                                                              \
+  int NAME##_get_array (const NAME##_t *set, 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 0;                                                           \
-}                                                                       \
-                                                                        \
-int                                                                     \
-NAME ## _finalize(NAME ## _t * set)                                     \
-{                                                                       \
-    return NAME ## _clear(set);                                         \
-}                                                                       \
-                                                                        \
-NAME ## _t *                                                            \
-NAME ## _create()                                                       \
-{                                                                       \
-    NAME ## _t * set = malloc(sizeof(NAME ## _t));                      \
-    if (!set)                                                           \
-        goto ERR_MALLOC;                                                \
-                                                                        \
-    if (NAME ## _initialize(set) < 0)                                   \
-        goto ERR_INITIALIZE;                                            \
-                                                                        \
-    return set;                                                         \
-                                                                        \
-ERR_INITIALIZE:                                                         \
-    free(set);                                                          \
-ERR_MALLOC:                                                             \
-    return NULL;                                                        \
-}                                                                       \
-                                                                        \
-void                                                                    \
-NAME ## _free(NAME ## _t * set)                                         \
-{                                                                       \
-    NAME ## _finalize(set);                                             \
-    free(set);                                                          \
-}                                                                       \
-                                                                        \
-int                                                                     \
-NAME ## _add(NAME ## _t * set, const T element)                         \
-{                                                                       \
-    T * found = tfind(element, &set->root, (cmp_t)CMP);                 \
-    void * ptr = tsearch(element, &set->root, (cmp_t)CMP);              \
-    if (!ptr)                                                           \
-        return -1;                                                      \
-    if (!found)                                                         \
-        set->size++;                                                    \
-    return 0;                                                           \
-}                                                                       \
-                                                                        \
-int                                                                     \
-NAME ## _remove(NAME ## _t * set, const T search, T * element)          \
-{                                                                       \
-    T * found = tfind(search, &set->root, (cmp_t)CMP);                  \
-    if (!found)                                                         \
-        return ERR_SET_NOT_FOUND;                                       \
-    if (element)                                                        \
-        *element = *found;                                              \
-    tdelete(search, &set->root, (cmp_t)CMP);                            \
-    set->size--;                                                        \
-    return 0;                                                           \
-}                                                                       \
-                                                                        \
-int                                                                     \
-NAME ## _clear(NAME ## _t * set)                                        \
-{                                                                       \
-    T * array;                                                          \
-    int n = NAME ## _get_array(set, &array);                            \
-    if (n < 0)                                                          \
-        return -1;                                                      \
-    for (unsigned i = 0; i < n; i++) {                                  \
-        T element = array[i];                                           \
-        NAME ## _remove(set, element, NULL);                            \
-    }                                                                   \
-    free(array);                                                        \
-    return 0;                                                           \
-}                                                                       \
-                                                                        \
-int                                                                     \
-NAME ## _get(const NAME ## _t * set, const T search, T * element)       \
-{                                                                       \
-    T * found = tfind(search, &set->root, (cmp_t)CMP);                  \
-    if (element)                                                        \
-        *element = found ? *found : NULL;                               \
-    return 0;                                                           \
-}                                                                       \
-                                                                        \
-static void                                                             \
-NAME ## _dump_node(const void *nodep, const VISIT which,                \
-        const int depth)                                                \
-{                                                                       \
-    char buf[BUFSIZE];                                                  \
-    switch (which) {                                                    \
-    case preorder:                                                      \
-    case endorder:                                                      \
-        break;                                                          \
-    case postorder:                                                     \
-    case leaf:                                                          \
-        SNPRINTF(buf, BUFSIZE, *(T*)nodep);                             \
-        INFO("%s", buf);                                                \
-        break;                                                          \
-    }                                                                   \
-}                                                                       \
-                                                                        \
-void                                                                    \
-NAME ## _dump(NAME ## _t * set) {                                       \
-    twalk(set->root, NAME ## _dump_node);                               \
-}                                                                       \
-                                                                        \
-thread_local                                                            \
-T * NAME ## _array_pos = NULL;                                          \
-                                                                        \
-static void                                                             \
-NAME ## _add_node_to_array(const void *nodep, const VISIT which,        \
-        const int depth)                                                \
-{                                                                       \
-    if (!NAME ## _array_pos)                                            \
-        return;                                                         \
-    switch (which) {                                                    \
-        case preorder:                                                  \
-        case endorder:                                                  \
-            break;                                                      \
-        case postorder:                                                 \
-        case leaf:                                                      \
-            *NAME ## _array_pos = *(T*)nodep;                           \
-            NAME ## _array_pos++;                                       \
-            break;                                                      \
-    }                                                                   \
-}                                                                       \
-                                                                        \
-int                                                                     \
-NAME ## _get_array(const NAME ## _t * set, T ** element)                \
-{                                                                       \
-    if (!element)                                                       \
-        goto END;                                                       \
-    *element = malloc(set->size * sizeof(T));                           \
-    if (!*element)                                                      \
-        return -1;                                                      \
-    NAME ## _array_pos = *element;                                      \
-    twalk(set->root, NAME ## _add_node_to_array);                       \
-    NAME ## _array_pos = NULL;                                          \
-END:                                                                    \
-    return (int)(set->size);                                                   \
-}
+#define TYPEDEF_SET(NAME, T, CMP, SNPRINTF)                                   \
+  int NAME##_initialize (NAME##_t *set)                                       \
+  {                                                                           \
+    set->root = NULL;                                                         \
+    set->size = 0;                                                            \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  int NAME##_finalize (NAME##_t *set) { return NAME##_clear (set); }          \
+                                                                              \
+  NAME##_t *NAME##_create ()                                                  \
+  {                                                                           \
+    NAME##_t *set = malloc (sizeof (NAME##_t));                               \
+    if (!set)                                                                 \
+      goto ERR_MALLOC;                                                        \
+                                                                              \
+    if (NAME##_initialize (set) < 0)                                          \
+      goto ERR_INITIALIZE;                                                    \
+                                                                              \
+    return set;                                                               \
+                                                                              \
+  ERR_INITIALIZE:                                                             \
+    free (set);                                                               \
+  ERR_MALLOC:                                                                 \
+    return NULL;                                                              \
+  }                                                                           \
+                                                                              \
+  void NAME##_free (NAME##_t *set)                                            \
+  {                                                                           \
+    NAME##_finalize (set);                                                    \
+    free (set);                                                               \
+  }                                                                           \
+                                                                              \
+  int NAME##_add (NAME##_t *set, const T element)                             \
+  {                                                                           \
+    T *found = tfind (element, &set->root, (cmp_t) CMP);                      \
+    void *ptr = tsearch (element, &set->root, (cmp_t) CMP);                   \
+    if (!ptr)                                                                 \
+      return -1;                                                              \
+    if (!found)                                                               \
+      set->size++;                                                            \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  int NAME##_remove (NAME##_t *set, const T search, T *element)               \
+  {                                                                           \
+    T *found = tfind (search, &set->root, (cmp_t) CMP);                       \
+    if (!found)                                                               \
+      return ERR_SET_NOT_FOUND;                                               \
+    if (element)                                                              \
+      *element = *found;                                                      \
+    tdelete (search, &set->root, (cmp_t) CMP);                                \
+    set->size--;                                                              \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  int NAME##_clear (NAME##_t *set)                                            \
+  {                                                                           \
+    T *array;                                                                 \
+    int n = NAME##_get_array (set, &array);                                   \
+    if (n < 0)                                                                \
+      return -1;                                                              \
+    for (unsigned i = 0; i < n; i++)                                          \
+      {                                                                       \
+	T element = array[i];                                                 \
+	NAME##_remove (set, element, NULL);                                   \
+      }                                                                       \
+    free (array);                                                             \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  int NAME##_get (const NAME##_t *set, const T search, T *element)            \
+  {                                                                           \
+    T *found = tfind (search, &set->root, (cmp_t) CMP);                       \
+    if (element)                                                              \
+      *element = found ? *found : NULL;                                       \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  static void NAME##_dump_node (const void *nodep, const VISIT which,         \
+				const int depth)                              \
+  {                                                                           \
+    char buf[BUFSIZE];                                                        \
+    switch (which)                                                            \
+      {                                                                       \
+      case preorder:                                                          \
+      case endorder:                                                          \
+	break;                                                                \
+      case postorder:                                                         \
+      case leaf:                                                              \
+	SNPRINTF (buf, BUFSIZE, *(T *) nodep);                                \
+	INFO ("%s", buf);                                                     \
+	break;                                                                \
+      }                                                                       \
+  }                                                                           \
+                                                                              \
+  void NAME##_dump (NAME##_t *set) { twalk (set->root, NAME##_dump_node); }   \
+                                                                              \
+  thread_local T *NAME##_array_pos = NULL;                                    \
+                                                                              \
+  static void NAME##_add_node_to_array (const void *nodep, const VISIT which, \
+					const int depth)                      \
+  {                                                                           \
+    if (!NAME##_array_pos)                                                    \
+      return;                                                                 \
+    switch (which)                                                            \
+      {                                                                       \
+      case preorder:                                                          \
+      case endorder:                                                          \
+	break;                                                                \
+      case postorder:                                                         \
+      case leaf:                                                              \
+	*NAME##_array_pos = *(T *) nodep;                                     \
+	NAME##_array_pos++;                                                   \
+	break;                                                                \
+      }                                                                       \
+  }                                                                           \
+                                                                              \
+  int NAME##_get_array (const NAME##_t *set, T **element)                     \
+  {                                                                           \
+    if (!element)                                                             \
+      goto END;                                                               \
+    *element = calloc (set->size, sizeof (T));                                \
+    if (!*element)                                                            \
+      return -1;                                                              \
+    NAME##_array_pos = *element;                                              \
+    twalk (set->root, NAME##_add_node_to_array);                              \
+    NAME##_array_pos = NULL;                                                  \
+  END:                                                                        \
+    return (int) (set->size);                                                 \
+  }
 
 #endif /* UTIL_SET_H */
diff --git a/lib/includes/hicn/util/sstrncpy.h b/lib/includes/hicn/util/sstrncpy.h
new file mode 100644
index 000000000..b316201be
--- /dev/null
+++ b/lib/includes/hicn/util/sstrncpy.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UTIL_SSTRNCPY_H
+#define UTIL_SSTRNCPY_H
+
+#define __STDC_WANT_LIB_EXT1__ 1
+#include <string.h>
+
+#ifdef __STDC_LIB_EXT1__
+// If safe string functions already available in the system, use them
+#elif ENABLE_SAFEC
+// If safe string functions not available and SafeC is enabled,
+// use SafeC
+#include <safe_string.h>
+#else
+// Use custom safe string functions
+typedef int errno_t;
+#define EOK 0
+
+/**
+ * @brief This function assures a null byte at the end of the buffer.
+ */
+static inline errno_t
+strcpy_s (char *dst, size_t n, const char *src)
+{
+  if (!dst || !src || !n)
+    {
+      fprintf (stderr, "[strncpy] invalid input received");
+      return EINVAL;
+    }
+
+  dst[n - 1] = 0;
+  strncpy (dst, src, n);
+
+  if (dst[n - 1] != 0)
+    {
+      fprintf (stderr, "[strncpy] '%s' has been trucated\n", src);
+      dst[n - 1] = 0;
+      return EINVAL;
+    }
+
+  return EOK;
+}
+
+static inline size_t
+strnlen_s (const char *s, size_t maxlen)
+{
+  if (s == NULL)
+    return 0;
+
+  return strnlen (s, maxlen);
+}
+
+#endif /* __STDC_LIB_EXT1__ */
+#endif /* UTIL_SSTRNCPY_H */
diff --git a/lib/includes/hicn/util/token.h b/lib/includes/hicn/util/token.h
index 43e0a77b2..c62c294bc 100644
--- a/lib/includes/hicn/util/token.h
+++ b/lib/includes/hicn/util/token.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -19,12 +19,12 @@
  * 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
+#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)
+#define PPCAT(A, B) PPCAT_NX (A, B)
 
 /* Token stringification */
 
@@ -37,4 +37,4 @@
 /*
  * Turn A into a string literal after macro-expanding it.
  */
-#define STRINGIZE(A) STRINGIZE_NX(A)
+#define STRINGIZE(A) STRINGIZE_NX (A)
diff --git a/lib/includes/hicn/util/types.h b/lib/includes/hicn/util/types.h
index 017e85b72..50c5362d3 100644
--- a/lib/includes/hicn/util/types.h
+++ b/lib/includes/hicn/util/types.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,15 +25,19 @@ 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)
+#define UNION_CAST(x, destType)                                               \
+  (((union {                                                                  \
+     __typeof__ (x) a;                                                        \
+     destType b;                                                              \
+   }) x)                                                                      \
+     .b)
 
-//typedef unsigned int hash_t;
+// typedef unsigned int hash_t;
 
-typedef int (*cmp_t)(const void *, const void *);
+typedef int (*cmp_t) (const void *, const void *);
 
 /* Enums */
 
-#define IS_VALID_ENUM_TYPE(NAME, x) ((x > NAME ## _UNDEFINED) && (x < NAME ## _N))
+#define IS_VALID_ENUM_TYPE(NAME, x) ((x > NAME##_UNDEFINED) && (x < NAME##_N))
 
 #endif /* UTIL_TYPES */
diff --git a/lib/includes/hicn/util/win_portability.h b/lib/includes/hicn/util/win_portability.h
index 5f30cfbb2..609203afc 100644
--- a/lib/includes/hicn/util/win_portability.h
+++ b/lib/includes/hicn/util/win_portability.h
@@ -1,45 +1,45 @@
-/*

- * Copyright (c) 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.

- */

-

-#pragma once

-#include <hicn/util/windows/windows_Utils.h>

-#include <afunix.h>

-#include <io.h>

-#include <iphlpapi.h>

-#include <process.h>

-#include <stdio.h>

-#pragma comment(lib, "IPHLPAPI.lib")

-

-#ifndef in_port_t

-#define in_port_t uint16_t

-#endif

-

-#ifndef in_addr_t

-#define in_addr_t uint32_t

-#endif

-

-#ifndef strncasecmp

-#define strncasecmp _strnicmp

-#endif

-

-#ifndef strcasecmp

-#define strcasecmp _stricmp

-#endif

-

-#define HAVE_STRUCT_TIMESPEC

-

-#ifndef getline

-int getline(char **lineptr, size_t *n, FILE *stream);

+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <hicn/util/windows/windows_Utils.h>
+#include <afunix.h>
+#include <io.h>
+#include <iphlpapi.h>
+#include <process.h>
+#include <stdio.h>
+#pragma comment(lib, "IPHLPAPI.lib")
+
+#ifndef in_port_t
+#define in_port_t uint16_t
+#endif
+
+#ifndef in_addr_t
+#define in_addr_t uint32_t
+#endif
+
+#ifndef strncasecmp
+#define strncasecmp _strnicmp
+#endif
+
+#ifndef strcasecmp
+#define strcasecmp _stricmp
+#endif
+
+#define HAVE_STRUCT_TIMESPEC
+
+#ifndef getline
+int getline (char **lineptr, size_t *n, FILE *stream);
 #endif
\ No newline at end of file
diff --git a/lib/includes/hicn/util/windows/dlfcn.h b/lib/includes/hicn/util/windows/dlfcn.h
index 7775226cd..f1457964e 100644
--- a/lib/includes/hicn/util/windows/dlfcn.h
+++ b/lib/includes/hicn/util/windows/dlfcn.h
@@ -5,8 +5,8 @@
 #define RTLD_GLOBAL 0x100 /* do not hide entries in this module */
 #define RTLD_LOCAL  0x000 /* hide entries in this module */
 
-#define RTLD_LAZY   0x000 /* accept unresolved externs */
-#define RTLD_NOW    0x001 /* abort if module has unresolved externs */
+#define RTLD_LAZY 0x000 /* accept unresolved externs */
+#define RTLD_NOW  0x001 /* abort if module has unresolved externs */
 
 /*
    How to call in Windows:
@@ -16,15 +16,16 @@
 */
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-      void *dlopen  (const char *filename, int flag);
-      int   dlclose (void *handle);
+  void *dlopen (const char *filename, int flag);
+  int dlclose (void *handle);
 
-      void *dlsym   (void *handle, const char *name);
+  void *dlsym (void *handle, const char *name);
 
-const char *dlerror (void);
+  const char *dlerror (void);
 
 #ifdef __cplusplus
 }
diff --git a/lib/includes/hicn/util/windows/windows_utils.h b/lib/includes/hicn/util/windows/windows_utils.h
index d24aaadbf..e15c0d752 100755..100644
--- a/lib/includes/hicn/util/windows/windows_utils.h
+++ b/lib/includes/hicn/util/windows/windows_utils.h
@@ -1,162 +1,166 @@
-/*

- * Copyright (c) 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 WINDOWS_UTILS_H

-#define WINDOWS_UTILS_H

-#define WIN32_LEAN_AND_MEAN

-#define HAVE_STRUCT_TIMESPEC

-#ifndef NOMINMAX

-#define NOMINMAX

-#endif

-#include <Windows.h>

-#include <stdint.h>

-#include <io.h>

-#include <stdlib.h>

-#include <winsock2.h>

-#include <WS2tcpip.h>

-#include "dlfcn.h"

-

-#ifndef IOVEC

-#define IOVEC

-struct iovec {

-	void* iov_base;

-	size_t iov_len;

-};

-#endif

-

-typedef uint16_t in_port_t;

-

-#ifndef SLEEP

-#define SLEEP

-#define sleep Sleep

-#endif

-

-#ifndef USLEEP

-#define USLEEP

-void usleep(__int64 usec);

-#endif

-

-#ifndef S_ISDIR

-#define S_ISDIR(mode)  (((mode) & S_IFMT) == S_IFDIR)

-#endif

-

-#define PARCLibrary_DISABLE_ATOMICS

-#include <BaseTsd.h>

-typedef SSIZE_T ssize_t;

-

-#ifndef __ATTRIBUTE__

-#define __ATTRIBUTE__

-#define __attribute__(A)

-#endif

-

-#ifndef RESTRICT

-#define RESTRICT

-#define restrict __restrict

-#endif

-

-#ifndef GETTIMEOFDAY

-#define GETTIMEOFDAY

-int gettimeofday(struct timeval * tp, struct timezone * tzp);

-#endif

-

-#ifndef timersub

-#define timersub(a, b, result) \

-        do { \

-                (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \

-                (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \

-                if ((result)->tv_usec < 0) { \

-                        --(result)->tv_sec; \

-                        (result)->tv_usec += 1000000; \

-                } \

-        } while (0)

-#endif // timersub

-

-#ifndef dup

-#define dup _dup

-#endif

-

-#ifndef access

-#define access _access

-#endif

-

-#ifndef __cplusplus

-

-#ifndef read

-#define read _read

-#endif

-

-#ifndef close

-#define close _close

-#endif

-

-#ifndef write

-#define write _write

-#endif

-

-#ifndef open

-#define open _open

-#endif

-

-#endif

-

-#ifndef unlink

-#define unlink _unlink

-#endif

-

-#ifndef strcasecmp

-#define strncasecmp _strnicmp

-#endif

-

-#ifndef strcasecmp

-

-#define strcasecmp _stricmp

-#endif

-

-#ifndef S_ISREG

-#define S_ISREG(mode)  (((mode) & S_IFMT) == S_IFREG)

-#endif

-#ifndef R_OK

-#define R_OK    4       /* Test for read permission.  */

-#endif

-#ifndef  W_OK

-#define W_OK    2       /* Test for write permission.  */

-#endif

-#ifndef F_OK

-#define F_OK    0

-#endif

-

-#ifndef STDIN_FILENO

-#define STDIN_FILENO _fileno(stdin)

-#endif

-

-#ifndef STDOUT_FILENO

-#define STDOUT_FILENO _fileno(stdout)

-#endif

-

-#ifndef STDERR_FILENO

-#define STDERR_FILENO _fileno(stderr)

-#endif

-

-#endif

-

-#ifndef __bswap_constant_32

-#define __bswap_constant_32(x)					\

-  ((((x) & 0xff000000u) >> 24) | (((x) & 0x00ff0000u) >> 8)	\

-   | (((x) & 0x0000ff00u) << 8) | (((x) & 0x000000ffu) << 24))

-#endif

-

-#ifndef bzero

-#define bzero(b,len) (memset((b), '\0', (len)), (void) 0)

+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WINDOWS_UTILS_H
+#define WINDOWS_UTILS_H
+#define WIN32_LEAN_AND_MEAN
+#define HAVE_STRUCT_TIMESPEC
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <Windows.h>
+#include <stdint.h>
+#include <io.h>
+#include <stdlib.h>
+#include <winsock2.h>
+#include <WS2tcpip.h>
+#include "dlfcn.h"
+
+#ifndef IOVEC
+#define IOVEC
+struct iovec
+{
+  void *iov_base;
+  size_t iov_len;
+};
+#endif
+
+typedef uint16_t in_port_t;
+
+#ifndef SLEEP
+#define SLEEP
+#define sleep Sleep
+#endif
+
+#ifndef USLEEP
+#define USLEEP
+void usleep (__int64 usec);
+#endif
+
+#ifndef S_ISDIR
+#define S_ISDIR(mode) (((mode) &S_IFMT) == S_IFDIR)
+#endif
+
+#define PARCLibrary_DISABLE_ATOMICS
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+
+#ifndef __ATTRIBUTE__
+#define __ATTRIBUTE__
+#define __attribute__(A)
+#endif
+
+#ifndef RESTRICT
+#define RESTRICT
+#define restrict __restrict
+#endif
+
+#ifndef GETTIMEOFDAY
+#define GETTIMEOFDAY
+int gettimeofday (struct timeval *tp, struct timezone *tzp);
+#endif
+
+#ifndef timersub
+#define timersub(a, b, result)                                                \
+  do                                                                          \
+    {                                                                         \
+      (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;                           \
+      (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;                        \
+      if ((result)->tv_usec < 0)                                              \
+	{                                                                     \
+	  --(result)->tv_sec;                                                 \
+	  (result)->tv_usec += 1000000;                                       \
+	}                                                                     \
+    }                                                                         \
+  while (0)
+#endif // timersub
+
+#ifndef dup
+#define dup _dup
+#endif
+
+#ifndef access
+#define access _access
+#endif
+
+#ifndef __cplusplus
+
+#ifndef read
+#define read _read
+#endif
+
+#ifndef close
+#define close _close
+#endif
+
+#ifndef write
+#define write _write
+#endif
+
+#ifndef open
+#define open _open
+#endif
+
+#endif
+
+#ifndef unlink
+#define unlink _unlink
+#endif
+
+#ifndef strcasecmp
+#define strncasecmp _strnicmp
+#endif
+
+#ifndef strcasecmp
+
+#define strcasecmp _stricmp
+#endif
+
+#ifndef S_ISREG
+#define S_ISREG(mode) (((mode) &S_IFMT) == S_IFREG)
+#endif
+#ifndef R_OK
+#define R_OK 4 /* Test for read permission.  */
+#endif
+#ifndef W_OK
+#define W_OK 2 /* Test for write permission.  */
+#endif
+#ifndef F_OK
+#define F_OK 0
+#endif
+
+#ifndef STDIN_FILENO
+#define STDIN_FILENO _fileno (stdin)
+#endif
+
+#ifndef STDOUT_FILENO
+#define STDOUT_FILENO _fileno (stdout)
+#endif
+
+#ifndef STDERR_FILENO
+#define STDERR_FILENO _fileno (stderr)
+#endif
+
+#endif
+
+#ifndef __bswap_constant_32
+#define __bswap_constant_32(x)                                                \
+  ((((x) &0xff000000u) >> 24) | (((x) &0x00ff0000u) >> 8) |                   \
+   (((x) &0x0000ff00u) << 8) | (((x) &0x000000ffu) << 24))
+#endif
+
+#ifndef bzero
+#define bzero(b, len) (memset ((b), '\0', (len)), (void) 0)
 #endif
\ No newline at end of file
diff --git a/lib/includes/hicn/validation.h b/lib/includes/hicn/validation.h
new file mode 100644
index 000000000..05be6d306
--- /dev/null
+++ b/lib/includes/hicn/validation.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2022 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file validation.h
+ * \brief Functions for input validation
+ */
+#include <ctype.h>
+#include <hicn/util/sstrncpy.h>
+
+static inline bool
+is_number (const char *string, size_t maxlen)
+{
+  size_t len = strnlen_s (string, maxlen);
+  for (size_t i = 0; i < len; i++)
+    {
+      if (!isdigit (string[i]))
+	return false;
+    }
+  return len != 0;
+}
+
+/**
+ * A symbolic name must be at least 1 character and must begin with an alpha.
+ * The remainder must be an alphanum.
+ */
+static inline bool
+is_symbolic_name (const char *name, size_t maxlen)
+{
+  size_t len = strnlen_s (name, maxlen);
+  if (len <= 0)
+    return false;
+  if (!isalpha (name[0]))
+    return false;
+
+  for (size_t i = 1; i < len; i++)
+    {
+      if (!isalnum (name[i]) && name[i] != '_' && name[i] != '-')
+	return false;
+    }
+
+  return true;
+}
diff --git a/lib/src/CMakeLists.txt b/lib/src/CMakeLists.txt
index 2588bde8b..ef74127cc 100644
--- a/lib/src/CMakeLists.txt
+++ b/lib/src/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,53 +11,117 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+##############################################################
+# Source and Header files
+##############################################################
 list(APPEND LIBHICN_SOURCE_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/common.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/compat.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/error.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/mapme.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/name.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/ops.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/policy.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/protocol/ah.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/protocol/icmp.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/protocol/ipv4.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/protocol/ipv6.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/protocol/tcp.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/util/ip_address.c
-  ${CMAKE_CURRENT_SOURCE_DIR}/util/log.c
+  common.c
+  compat.c
+  error.c
+  face.c
+  mapme.c
+  name.c
+  ops.c
+  policy.c
+  strategy.c
+  protocol/ah.c
+  protocol/icmp.c
+  protocol/ipv4.c
+  protocol/ipv6.c
+  protocol/tcp.c
+  protocol/udp.c
+  protocol/new.c
+  util/ip_address.c
+  util/log.c
 )
 
 if (WIN32)
   list(APPEND LIBHICN_SOURCE_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/util/windows/dlfcn.c
+    util/windows/dlfcn.c
   )
 endif ()
-set (COMPILER_DEFINITIONS "-DWITH_MAPME")
+
+##############################################################
+# Compiler definitions
+##############################################################
+set (COMPILER_DEFINITIONS
+  PUBLIC "-DWITH_MAPME"
+  PUBLIC "-DWITH_POLICY"
+)
 
 include(BuildMacros)
 include(WindowsMacros)
 
-if (DISABLE_SHARED_LIBRARIES)
-  build_library(${LIBHICN}
-    STATIC
-    SOURCES ${LIBHICN_SOURCE_FILES} ${LIBHICN_HEADER_FILES} ${LIBHICN_HEADER_FILES_PROTOCOL} ${LIBHICN_HEADER_FILES_UTIL}
-    COMPONENT lib${LIBHICN}
-    INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../includes
-    DEFINITIONS ${COMPILER_DEFINITIONS}
-    HEADER_ROOT_DIR hicn
-    INSTALL_HEADERS ${LIBHICN_HEADER_FILES} ${LIBHICN_HEADER_FILES_PROTOCOL} ${LIBHICN_HEADER_FILES_UTIL}
-    LINK_LIBRARIES ${WSOCK32_LIBRARY} ${WS2_32_LIBRARY}
+##############################################################
+# Build type
+##############################################################
+set (BUILD_TYPES "STATIC")
+
+if (NOT DISABLE_SHARED_LIBRARIES)
+  list(APPEND BUILD_TYPES
+    "SHARED"
   )
-else ()
-  build_library(${LIBHICN}
-    SHARED STATIC
-    SOURCES ${LIBHICN_SOURCE_FILES} ${LIBHICN_HEADER_FILES} ${LIBHICN_HEADER_FILES_PROTOCOL} ${LIBHICN_HEADER_FILES_UTIL}
-    COMPONENT lib${LIBHICN}
-    INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../includes
-    DEFINITIONS ${COMPILER_DEFINITIONS}
-    HEADER_ROOT_DIR hicn
-    INSTALL_HEADERS ${LIBHICN_HEADER_FILES} ${LIBHICN_HEADER_FILES_PROTOCOL} ${LIBHICN_HEADER_FILES_UTIL}
-    LINK_LIBRARIES ${WSOCK32_LIBRARY} ${WS2_32_LIBRARY}
+endif()
+
+
+##############################################################
+# Compiler Options
+##############################################################
+set(COMPILER_OPTIONS
+  ${DEFAULT_COMPILER_OPTIONS}
+)
+
+
+##############################################################
+# Link libraries
+##############################################################
+if (WIN32)
+  list(APPEND LIBRARIES
+    PRIVATE ${WSOCK32_LIBRARY}
+    PRIVATE ${WS2_32_LIBRARY}
   )
 endif ()
+
+
+##############################################################
+# Build library
+##############################################################
+build_library(${LIBHICN}
+  ${BUILD_TYPES}
+  SOURCES ${LIBHICN_SOURCE_FILES}
+  COMPONENT ${LIBHICN_COMPONENT}
+  INCLUDE_DIRS
+    PUBLIC
+      $<BUILD_INTERFACE:${Libhicn_INCLUDE_DIRS}>
+      $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+      $<BUILD_INTERFACE:${THIRD_PARTY_INCLUDE_DIRS}>
+  DEFINITIONS ${COMPILER_DEFINITIONS}
+  INSTALL_HEADERS ${LIBHICN_HEADER_FILES} ${LIBHICN_HEADER_FILES_PROTOCOL} ${LIBHICN_HEADER_FILES_UTIL}
+  DEPENDS ${THIRD_PARTY_DEPENDENCIES}
+  LINK_LIBRARIES
+    PRIVATE ${WSOCK32_LIBRARY}
+    PRIVATE ${WS2_32_LIBRARY}
+    PUBLIC ${THIRD_PARTY_LIBRARIES}
+  VERSION ${CURRENT_VERSION}
+  EXPORT_NAME ${LIBHICN_COMPONENT}
+  COMPILE_OPTIONS ${COMPILER_OPTIONS}
+)
+
+##############################################################
+# Unit tests
+##############################################################
+if (${BUILD_TESTS})
+  add_subdirectory(test)
+endif()
+
+
+##############################################################
+# Cmake config files
+##############################################################
+create_cmake_config (
+  ${LIBHICN_COMPONENT}
+  INCLUDE_DIRS ${HICN_INCLUDE_DIRS}
+  VERSION ${CURRENT_VERSION}
+  COMPONENT ${LIBHICN_COMPONENT}
+  NAMESPACE hicn
+)
diff --git a/lib/src/common.c b/lib/src/common.c
index 562771e09..c4cb8bc3e 100644
--- a/lib/src/common.c
+++ b/lib/src/common.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -20,8 +20,8 @@
  */
 
 #include <stdlib.h>
-#include <string.h>		// memset
-#include <sys/types.h>		// getaddrinfo
+#include <string.h>    // memset
+#include <sys/types.h> // getaddrinfo
 #ifndef _WIN32
 #include <sys/socket.h>
 #include <netdb.h>
@@ -31,8 +31,6 @@
 #include <hicn/common.h>
 #include <hicn/util/log.h>
 
-
-
 int
 get_addr_family (const char *ip_address)
 {
@@ -59,7 +57,8 @@ get_addr_family (const char *ip_address)
 u32
 cumulative_hash32 (const void *data, size_t len, u32 lastValue)
 {
-  // Standard FNV 32-bit prime: see http://www.isthe.com/chongo/tech/comp/fnv/#FNV-param
+  // Standard FNV 32-bit prime: see
+  // http://www.isthe.com/chongo/tech/comp/fnv/#FNV-param
   const u32 fnv1a_prime = 0x01000193;
   u32 hash = lastValue;
   size_t i;
@@ -78,7 +77,8 @@ cumulative_hash32 (const void *data, size_t len, u32 lastValue)
 u32
 hash32 (const void *data, size_t len)
 {
-  // Standard FNV 32-bit offset: see http://www.isthe.com/chongo/tech/comp/fnv/#FNV-param
+  // Standard FNV 32-bit offset: see
+  // http://www.isthe.com/chongo/tech/comp/fnv/#FNV-param
   const u32 fnv1a_offset = 0x811C9DC5;
   return cumulative_hash32 (data, len, fnv1a_offset);
 }
@@ -86,7 +86,8 @@ hash32 (const void *data, size_t len)
 u64
 cumulative_hash64 (const void *data, size_t len, u64 lastValue)
 {
-  // Standard FNV 64-bit prime: see http://www.isthe.com/chongo/tech/comp/fnv/#FNV-param
+  // Standard FNV 64-bit prime: see
+  // http://www.isthe.com/chongo/tech/comp/fnv/#FNV-param
   const u64 fnv1a_prime = 0x00000100000001B3ULL;
   u64 hash = lastValue;
   const char *chardata = data;
@@ -104,13 +105,14 @@ cumulative_hash64 (const void *data, size_t len, u64 lastValue)
 u64
 hash64 (const void *data, size_t len)
 {
-  // Standard FNV 64-bit offset: see http://www.isthe.com/chongo/tech/comp/fnv/#FNV-param
+  // Standard FNV 64-bit offset: see
+  // http://www.isthe.com/chongo/tech/comp/fnv/#FNV-param
   const u64 fnv1a_offset = 0xCBF29CE484222325ULL;
   return cumulative_hash64 (data, len, fnv1a_offset);
 }
 
 void
-hicn_packet_dump (const uint8_t * buffer, size_t len)
+hicn_packet_dump (const uint8_t *buffer, size_t len)
 {
   int i;
   unsigned char buff[17];
diff --git a/lib/src/compat.c b/lib/src/compat.c
index 932c11d9e..cb771dbdd 100644
--- a/lib/src/compat.c
+++ b/lib/src/compat.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -51,6 +51,12 @@ hicn_packet_get_format (const hicn_header_t *h, hicn_format_t *format)
 	  else
 	    *format = HF_INET_TCP;
 	  break;
+	case IPPROTO_UDP:
+	  if (h->v4.newhdr.flags & HICN_NEW_FLAG_SIG)
+	    *format = HF_INET_UDP_AH;
+	  else
+	    *format = HF_INET_UDP;
+	  break;
 	case IPPROTO_ICMP:
 	  *format = HF_INET_ICMP;
 	  break;
@@ -67,6 +73,12 @@ hicn_packet_get_format (const hicn_header_t *h, hicn_format_t *format)
 	  else
 	    *format = HF_INET6_TCP;
 	  break;
+	case IPPROTO_UDP:
+	  if (h->v6.newhdr.flags & HICN_NEW_FLAG_SIG)
+	    *format = HF_INET6_UDP_AH;
+	  else
+	    *format = HF_INET6_UDP;
+	  break;
 	case IPPROTO_ICMPV6:
 	  *format = HF_INET6_ICMP;
 	  break;
@@ -74,6 +86,12 @@ hicn_packet_get_format (const hicn_header_t *h, hicn_format_t *format)
 	  return HICN_LIB_ERROR_NOT_HICN;
 	}
       break;
+    case 9:
+      {
+	uint8_t ah = (HICN_NEW_FLAG_SIG & h->protocol.newhdr.flags);
+	*format = HF_NEW_AH * ah + (1 - ah) * HF_NEW;
+	break;
+      }
     default:
       return HICN_LIB_ERROR_NOT_HICN;
     }
@@ -93,20 +111,32 @@ hicn_format_to_type (hicn_format_t format)
     {
     case HF_INET_TCP:
       return HICN_TYPE_IPV4_TCP;
+    case HF_INET_UDP:
+      return HICN_TYPE_IPV4_UDP;
     case HF_INET6_TCP:
       return HICN_TYPE_IPV6_TCP;
+    case HF_INET6_UDP:
+      return HICN_TYPE_IPV6_UDP;
     case HF_INET_ICMP:
       return HICN_TYPE_IPV4_ICMP;
     case HF_INET6_ICMP:
       return HICN_TYPE_IPV6_ICMP;
+    case HF_NEW:
+      return HICN_TYPE_NEW;
     case HF_INET_TCP_AH:
       return HICN_TYPE_IPV4_TCP_AH;
+    case HF_INET_UDP_AH:
+      return HICN_TYPE_IPV4_UDP_AH;
     case HF_INET6_TCP_AH:
       return HICN_TYPE_IPV6_TCP_AH;
+    case HF_INET6_UDP_AH:
+      return HICN_TYPE_IPV6_UDP_AH;
     case HF_INET_ICMP_AH:
       return HICN_TYPE_IPV4_ICMP_AH;
     case HF_INET6_ICMP_AH:
       return HICN_TYPE_IPV6_ICMP_AH;
+    case HF_NEW_AH:
+      return HICN_TYPE_NEW_AH;
     default:
       break;
     }
@@ -176,6 +206,8 @@ hicn_packet_get_header_length_from_format (hicn_format_t format,
   *header_length += _is_ipv6 (format) * IPV6_HDRLEN;
   *header_length += _is_icmp (format) * ICMP_HDRLEN;
   *header_length += _is_tcp (format) * TCP_HDRLEN;
+  *header_length += _is_udp (format) * UDP_HDRLEN;
+  *header_length += _is_cmpr (format) * NEW_HDRLEN;
   *header_length += _is_ah (format) * AH_HDRLEN;
 
   return HICN_LIB_ERROR_NONE;
@@ -185,17 +217,9 @@ int
 hicn_packet_get_header_length (hicn_format_t format, const hicn_header_t *h,
 			       size_t *header_length)
 {
-  hicn_packet_get_header_length_from_format (format, header_length);
-  int is_ah = _is_ah (format);
-  int is_ipv4 = _is_ipv4 (format);
-  int is_ipv6 = _is_ipv6 (format);
-  // The signature payload is expressed as number of 32 bits words
-  if (is_ah && is_ipv4)
-    *header_length += (h->v4ah.ah.payloadlen) << 2;
-  else if (is_ah && is_ipv6)
-    *header_length += (h->v6ah.ah.payloadlen) << 2;
-
-  return HICN_LIB_ERROR_NONE;
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->get_header_length (type, &h->protocol,
+						   header_length);
 }
 
 int
@@ -261,11 +285,6 @@ hicn_packet_set_name (hicn_format_t format, hicn_header_t *h,
 {
   hicn_type_t type = hicn_format_to_type (format);
 
-#ifndef HICN_VPP_PLUGIN
-  if (name->type & HNT_IOV)
-    return HICN_LIB_ERROR_NOT_IMPLEMENTED;
-#endif /* HICN_VPP_PLUGIN */
-
   if (is_interest)
     return hicn_ops_vft[type.l1]->set_interest_name (type, &h->protocol, name);
   else
@@ -325,54 +344,26 @@ int
 hicn_packet_get_locator (hicn_format_t format, const hicn_header_t *h,
 			 ip_address_t *address, bool is_interest)
 {
-  int is_ipv4 = (format & HFO_INET);
-  int is_ipv6 = (format & HFO_INET6) >> 1;
-
-  if (is_ipv4)
-    {
-      address->v4.as_inaddr =
-	is_interest ? h->v4.ip.saddr.as_inaddr : h->v4.ip.daddr.as_inaddr;
-    }
-  else if (is_ipv6)
-    {
-      address->v6.as_in6addr =
-	is_interest ? h->v6.ip.saddr.as_in6addr : h->v6.ip.daddr.as_in6addr;
-    }
+  hicn_type_t type = hicn_format_to_type (format);
+  if (is_interest)
+    return hicn_ops_vft[type.l1]->get_interest_locator (type, &h->protocol,
+							address);
   else
-    {
-      return HICN_LIB_ERROR_NOT_IMPLEMENTED;
-    }
-
-  return HICN_LIB_ERROR_NONE;
+    return hicn_ops_vft[type.l1]->get_data_locator (type, &h->protocol,
+						    address);
 }
 
 int
 hicn_packet_set_locator (hicn_format_t format, hicn_header_t *h,
 			 const ip_address_t *address, bool is_interest)
 {
-  int is_ipv4 = (format & HFO_INET);
-  int is_ipv6 = (format & HFO_INET6) >> 1;
-
-  if (is_ipv6)
-    {
-      if (is_interest)
-	h->v6.ip.saddr.as_in6addr = address->v6.as_in6addr;
-      else
-	h->v6.ip.daddr.as_in6addr = address->v6.as_in6addr;
-    }
-  else if (is_ipv4)
-    {
-      if (is_interest)
-	h->v4.ip.saddr.as_inaddr = address->v4.as_inaddr;
-      else
-	h->v4.ip.daddr.as_inaddr = address->v4.as_inaddr;
-    }
+  hicn_type_t type = hicn_format_to_type (format);
+  if (is_interest)
+    return hicn_ops_vft[type.l1]->set_interest_locator (type, &h->protocol,
+							address);
   else
-    {
-      return HICN_LIB_ERROR_INVALID_PARAMETER;
-    }
-
-  return HICN_LIB_ERROR_NONE;
+    return hicn_ops_vft[type.l1]->set_data_locator (type, &h->protocol,
+						    address);
 }
 
 int
@@ -392,19 +383,21 @@ hicn_packet_set_signature_size (hicn_format_t format, hicn_header_t *h,
 }
 
 int
-hicn_packet_get_signature_gap (hicn_format_t format, const hicn_header_t *h,
-			       uint8_t *bytes)
+hicn_packet_get_signature_padding (hicn_format_t format,
+				   const hicn_header_t *h, size_t *bytes)
 {
   hicn_type_t type = hicn_format_to_type (format);
-  return hicn_ops_vft[type.l1]->get_signature_gap (type, &h->protocol, bytes);
+  return hicn_ops_vft[type.l1]->get_signature_padding (type, &h->protocol,
+						       bytes);
 }
 
 int
-hicn_packet_set_signature_gap (hicn_format_t format, hicn_header_t *h,
-			       uint8_t bytes)
+hicn_packet_set_signature_padding (hicn_format_t format, hicn_header_t *h,
+				   size_t bytes)
 {
   hicn_type_t type = hicn_format_to_type (format);
-  return hicn_ops_vft[type.l1]->set_signature_gap (type, &h->protocol, bytes);
+  return hicn_ops_vft[type.l1]->set_signature_padding (type, &h->protocol,
+						       bytes);
 }
 
 int
@@ -499,7 +492,30 @@ hicn_packet_set_hoplimit (hicn_header_t *h, u8 hops)
 }
 
 int
-hicn_packet_get_lifetime (const hicn_header_t *h, u32 *lifetime)
+hicn_packet_is_interest (hicn_format_t format, const hicn_header_t *h,
+			 int *ret)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->is_interest (type, &h->protocol, ret);
+}
+
+int
+hicn_packet_set_interest (hicn_format_t format, hicn_header_t *h)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->mark_packet_as_interest (type, &h->protocol);
+}
+
+int
+hicn_packet_set_data (hicn_format_t format, hicn_header_t *h)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->mark_packet_as_data (type, &h->protocol);
+}
+
+int
+hicn_packet_get_lifetime (hicn_format_t format, const hicn_header_t *h,
+			  u32 *lifetime)
 {
   hicn_type_t type = hicn_header_to_type (h);
   return hicn_ops_vft[type.l1]->get_lifetime (type, &h->protocol,
@@ -507,7 +523,7 @@ hicn_packet_get_lifetime (const hicn_header_t *h, u32 *lifetime)
 }
 
 int
-hicn_packet_set_lifetime (hicn_header_t *h, u32 lifetime)
+hicn_packet_set_lifetime (hicn_format_t format, hicn_header_t *h, u32 lifetime)
 {
   hicn_type_t type = hicn_header_to_type (h);
   return hicn_ops_vft[type.l1]->set_lifetime (type, &h->protocol,
@@ -551,59 +567,21 @@ hicn_packet_set_reserved_bits (hicn_header_t *h, const u8 reserved_bits)
 }
 
 int
-hicn_packet_get_payload_type (const hicn_header_t *h,
+hicn_packet_get_payload_type (hicn_format_t format, const hicn_header_t *h,
 			      hicn_payload_type_t *payload_type)
 {
-  switch (HICN_IP_VERSION (h))
-    {
-    case 6:
-      *payload_type =
-	((h->v6.tcp.flags & HICN_TCP_FLAG_URG) == HICN_TCP_FLAG_URG);
-      break;
-    case 4:
-      *payload_type =
-	((h->v4.tcp.flags & HICN_TCP_FLAG_URG) == HICN_TCP_FLAG_URG);
-      break;
-    default:
-      return HICN_LIB_ERROR_UNEXPECTED;
-    }
-
-  if (*payload_type == HPT_UNSPEC)
-    {
-      return HICN_LIB_ERROR_UNEXPECTED;
-    }
-
-  return HICN_LIB_ERROR_NONE;
+  hicn_type_t type = hicn_header_to_type (h);
+  return hicn_ops_vft[type.l1]->get_payload_type (type, &h->protocol,
+						  payload_type);
 }
 
 int
-hicn_packet_set_payload_type (hicn_header_t *h,
+hicn_packet_set_payload_type (hicn_format_t format, hicn_header_t *h,
 			      hicn_payload_type_t payload_type)
 {
-  if (payload_type != HPT_DATA && payload_type != HPT_MANIFEST)
-    {
-      return HICN_LIB_ERROR_UNEXPECTED;
-    }
-
-  switch (HICN_IP_VERSION (h))
-    {
-    case 6:
-      if (payload_type)
-	h->v6.tcp.flags = h->v6.tcp.flags | HICN_TCP_FLAG_URG;
-      else
-	h->v6.tcp.flags = h->v6.tcp.flags & ~HICN_TCP_FLAG_URG;
-      break;
-    case 4:
-      if (payload_type)
-	h->v4.tcp.flags = h->v4.tcp.flags | HICN_TCP_FLAG_URG;
-      else
-	h->v4.tcp.flags = h->v4.tcp.flags & ~HICN_TCP_FLAG_URG;
-      break;
-    default:
-      return HICN_LIB_ERROR_UNEXPECTED;
-    }
-
-  return HICN_LIB_ERROR_NONE;
+  hicn_type_t type = hicn_header_to_type (h);
+  return hicn_ops_vft[type.l1]->set_payload_type (type, &h->protocol,
+						  payload_type);
 }
 
 int
@@ -1057,10 +1035,6 @@ int
 hicn_interest_set_name (hicn_format_t format, hicn_header_t *interest,
 			const hicn_name_t *name)
 {
-  int ret_err = hicn_packet_reset_ece (
-    format, interest); // interest packet -> ece flag unset
-  if (ret_err < 0)
-    return HICN_LIB_ERROR_UNEXPECTED;
   return hicn_packet_set_name (format, interest, name, _INTEREST);
 }
 
@@ -1088,13 +1062,25 @@ hicn_interest_compare (const hicn_header_t *interest_1,
 int
 hicn_interest_get_lifetime (const hicn_header_t *interest, u32 *lifetime)
 {
-  return hicn_packet_get_lifetime (interest, lifetime);
+  hicn_format_t format;
+  int rc = hicn_packet_get_format (interest, &format);
+
+  if (rc)
+    return rc;
+
+  return hicn_packet_get_lifetime (format, interest, lifetime);
 }
 
 int
 hicn_interest_set_lifetime (hicn_header_t *interest, u32 lifetime)
 {
-  return hicn_packet_set_lifetime (interest, lifetime);
+  hicn_format_t format;
+  int rc = hicn_packet_get_format (interest, &format);
+
+  if (rc)
+    return rc;
+
+  return hicn_packet_set_lifetime (format, interest, lifetime);
 }
 
 int
@@ -1150,10 +1136,6 @@ int
 hicn_data_set_name (hicn_format_t format, hicn_header_t *data,
 		    const hicn_name_t *name)
 {
-  int ret_err =
-    hicn_packet_set_ece (format, data); // data packet -> ece flag set
-  if (ret_err < 0)
-    return HICN_LIB_ERROR_UNEXPECTED;
   return hicn_packet_set_name (format, data, name, _DATA);
 }
 
@@ -1180,13 +1162,26 @@ hicn_data_compare (const hicn_header_t *data_1, const hicn_header_t *data_2)
 int
 hicn_data_get_expiry_time (const hicn_header_t *data, u32 *expiry_time)
 {
-  return hicn_packet_get_lifetime (data, expiry_time);
+  hicn_format_t format;
+  int rc = hicn_packet_get_format (data, &format);
+
+  if (rc)
+    return rc;
+
+  return hicn_packet_get_lifetime (format, data, expiry_time);
 }
 
 int
 hicn_data_set_expiry_time (hicn_header_t *data, u32 expiry_time)
 {
-  return hicn_packet_set_lifetime (data, (hicn_lifetime_t) expiry_time);
+  hicn_format_t format;
+  int rc = hicn_packet_get_format (data, &format);
+
+  if (rc)
+    return rc;
+
+  return hicn_packet_set_lifetime (format, data,
+				   (hicn_lifetime_t) expiry_time);
 }
 
 int
@@ -1204,20 +1199,6 @@ hicn_data_get_payload_length (hicn_format_t format, const hicn_header_t *data,
 }
 
 int
-hicn_data_set_payload_type (hicn_header_t *data,
-			    hicn_payload_type_t payload_type)
-{
-  return hicn_packet_set_payload_type (data, payload_type);
-}
-
-int
-hicn_data_get_payload_type (const hicn_header_t *data,
-			    hicn_payload_type_t *payload_type)
-{
-  return hicn_packet_get_payload_type (data, payload_type);
-}
-
-int
 hicn_data_get_path_label (const hicn_header_t *data, u32 *path_label)
 {
   hicn_type_t type = hicn_header_to_type (data);
@@ -1256,6 +1237,20 @@ hicn_data_reset_for_hash (hicn_format_t format, hicn_header_t *packet)
 }
 
 int
+hicn_data_is_last (hicn_format_t format, hicn_header_t *h, int *is_last)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->is_last_data (type, &h->protocol, is_last);
+}
+
+int
+hicn_data_set_last (hicn_format_t format, hicn_header_t *h)
+{
+  hicn_type_t type = hicn_format_to_type (format);
+  return hicn_ops_vft[type.l1]->set_last_data (type, &h->protocol);
+}
+
+int
 hicn_packet_get_signature (hicn_format_t format, hicn_header_t *packet,
 			   uint8_t **sign_buf)
 {
diff --git a/lib/src/error.c b/lib/src/error.c
index ab5d6e27d..0d7c80d9b 100644
--- a/lib/src/error.c
+++ b/lib/src/error.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,7 +21,7 @@
 #include <hicn/error.h>
 
 const char *HICN_LIB_ERROR_STRING[] = {
-#define _(a,b,c) [b] = c,
+#define _(a, b, c) [b] = c,
   foreach_libhicn_error
 #undef _
 };
diff --git a/lib/src/face.c b/lib/src/face.c
new file mode 100644
index 000000000..46b36e8cd
--- /dev/null
+++ b/lib/src/face.c
@@ -0,0 +1,451 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file face.c
+ * \brief Implementation of face abstraction
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <hicn/face.h>
+#include <hicn/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 _
+};
+
+netdevice_t *
+netdevice_create_from_index (u32 index)
+{
+  netdevice_t *netdevice = malloc (sizeof (netdevice_t));
+  if (!netdevice)
+    goto ERR_MALLOC;
+
+  int rc = netdevice_set_index (netdevice, index);
+  if (rc < 0)
+    goto ERR_INIT;
+
+  return netdevice;
+
+ERR_INIT:
+  free (netdevice);
+ERR_MALLOC:
+  return NULL;
+}
+
+netdevice_t *
+netdevice_create_from_name (const char *name)
+{
+  netdevice_t *netdevice = malloc (sizeof (netdevice_t));
+  if (!netdevice)
+    goto ERR_MALLOC;
+
+  int rc = netdevice_set_name (netdevice, name);
+  if (rc < 0)
+    goto ERR_INIT;
+
+  return netdevice;
+
+ERR_INIT:
+  free (netdevice);
+ERR_MALLOC:
+  return NULL;
+}
+
+/**
+ * \brief Update the index of the netdevice based on the name
+ */
+int
+netdevice_update_index (netdevice_t *netdevice)
+{
+  netdevice->index = if_nametoindex (netdevice->name);
+  if (netdevice->index == 0)
+    return -1;
+  return 0;
+}
+
+int
+netdevice_update_name (netdevice_t *netdevice)
+{
+  if (!if_indextoname (netdevice->index, netdevice->name))
+    return -1;
+  return 0;
+}
+
+void
+netdevice_free (netdevice_t *netdevice)
+{
+  free (netdevice);
+}
+
+int
+netdevice_get_index (const netdevice_t *netdevice, u32 *index)
+{
+  if (netdevice->index == 0)
+    return -1;
+  *index = netdevice->index;
+  return 0;
+}
+
+int
+netdevice_set_index (netdevice_t *netdevice, u32 index)
+{
+  netdevice->index = index;
+  return netdevice_update_name (netdevice);
+}
+
+int
+netdevice_get_name (const netdevice_t *netdevice, const char **name)
+{
+  if (netdevice->name[0] == '\0')
+    return -1;
+  *name = netdevice->name;
+  return 0;
+}
+
+int
+netdevice_set_name (netdevice_t *netdevice, const char *name)
+{
+  memset (netdevice->name, 0, sizeof (netdevice->name));
+  int rc = snprintf (netdevice->name, IFNAMSIZ, "%s", name);
+  if (rc < 0)
+    return -1;
+  if (rc >= IFNAMSIZ)
+    return -2; /* truncated */
+  return netdevice_update_index (netdevice);
+}
+
+int
+netdevice_cmp (const netdevice_t *nd1, const netdevice_t *nd2)
+{
+  return (nd1->index - nd2->index);
+}
+
+/* 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_type_t
+face_type_from_str (const char *str)
+{
+#define _(x)                                                                  \
+  if (strcasecmp (str, STRINGIZE (x)) == 0)                                   \
+    return FACE_TYPE_##x;                                                     \
+  else
+  foreach_face_type
+#undef _
+    return FACE_TYPE_UNDEFINED;
+}
+
+/* Face */
+
+int
+face_initialize (face_t *face)
+{
+  memset (face, 0, sizeof (face_t)); /* 0'ed for hash */
+  return 1;
+}
+
+int
+face_initialize_udp (face_t *face, const char *interface_name,
+		     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,
+    .family = family,
+    .local_addr = *local_addr,
+    .local_port = local_port,
+    .remote_addr = remote_addr ? *remote_addr : IP_ADDRESS_EMPTY,
+    .remote_port = remote_port,
+  };
+
+  snprintf (face->netdevice.name, IFNAMSIZ, "%s", interface_name);
+
+  return 1;
+}
+
+int
+face_initialize_udp_sa (face_t *face, const char *interface_name,
+			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,
+	  .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->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,
+	  .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->remote_addr.v6.as_in6addr = rsai->sin6_addr;
+      }
+      break;
+    default:
+      return -1;
+    }
+
+  snprintf (face->netdevice.name, IFNAMSIZ, "%s", interface_name);
+
+  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 char *interface_name, 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, interface_name, 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 char *interface_name,
+		    const struct sockaddr *local_addr,
+		    const struct sockaddr *remote_addr)
+{
+  face_t *face = face_create ();
+  if (face_initialize_udp_sa (face, interface_name, local_addr, remote_addr) <
+      0)
+    goto ERR_INIT;
+  return face;
+
+ERR_INIT:
+  free (face);
+  return NULL;
+}
+
+void
+face_free (face_t *face)
+{
+  free (face);
+}
+
+/**
+ * \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)
+{
+
+  int ret = f1->type - f2->type;
+  if (ret != 0)
+    return ret;
+
+  ret = f1->family - f2->family;
+  if (ret != 0)
+    return ret;
+
+  /*
+   * FIXME As hicn-light API might not return the netdevice, we can discard the
+   * comparison when one of the two is not set for now...
+   */
+  if ((f1->netdevice.index != 0) && (f2->netdevice.index != 0))
+    {
+      ret = netdevice_cmp (&f1->netdevice, &f2->netdevice);
+      if (ret != 0)
+	return ret;
+    }
+
+  switch (f1->type)
+    {
+    case FACE_TYPE_HICN:
+      ret = ip_address_cmp (&f1->local_addr, &f2->local_addr, f1->family);
+      if (ret != 0)
+	return ret;
+
+      ret = ip_address_cmp (&f1->remote_addr, &f2->remote_addr, f1->family);
+      if (ret != 0)
+	return ret;
+
+      break;
+
+    case FACE_TYPE_TCP:
+    case FACE_TYPE_UDP:
+      ret = ip_address_cmp (&f1->local_addr, &f2->local_addr, f1->family);
+      if (ret != 0)
+	return ret;
+
+      ret = f1->local_port - f2->local_port;
+      if (ret != 0)
+	return ret;
+
+      ret = ip_address_cmp (&f1->remote_addr, &f2->remote_addr, f1->family);
+      if (ret != 0)
+	return ret;
+
+      ret = f1->remote_port - f2->remote_port;
+      if (ret != 0)
+	return ret;
+
+      break;
+    default:
+      break;
+    }
+
+  return 0;
+}
+
+/* /!\ 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:
+      {
+	char local[MAXSZ_IP_ADDRESS];
+	char remote[MAXSZ_IP_ADDRESS];
+	char tags[MAXSZ_POLICY_TAGS];
+
+	ip_address_snprintf (local, MAXSZ_IP_ADDRESS, &face->local_addr,
+			     face->family);
+	ip_address_snprintf (remote, MAXSZ_IP_ADDRESS, &face->remote_addr,
+			     face->family);
+	policy_tags_snprintf (tags, MAXSZ_POLICY_TAGS, face->tags);
+	return snprintf (s, size, "%s [%s -> %s] [%s]",
+			 face_type_str (face->type), local, remote, tags);
+      }
+    case FACE_TYPE_UNDEFINED:
+    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->local_addr,
+			     face->family);
+	ip_address_snprintf (remote, MAXSZ_IP_ADDRESS, &face->remote_addr,
+			     face->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->local_port,
+			 remote, face->remote_port, tags);
+      }
+    default:
+      return -1;
+    }
+}
+
+policy_tags_t
+face_get_tags (const face_t *face)
+{
+  return face->tags;
+}
+
+int
+face_set_tags (face_t *face, policy_tags_t tags)
+{
+  face->tags = tags;
+  return 1;
+}
+
+face_protocol_t
+get_protocol (face_type_t face_type)
+{
+  switch (face_type)
+    {
+    case FACE_TYPE_HICN:
+    case FACE_TYPE_HICN_LISTENER:
+      return FACE_PROTOCOL_HICN;
+
+    case FACE_TYPE_TCP:
+    case FACE_TYPE_TCP_LISTENER:
+      return FACE_PROTOCOL_TCP;
+
+    case FACE_TYPE_UDP:
+    case FACE_TYPE_UDP_LISTENER:
+      return FACE_PROTOCOL_UDP;
+
+    default:
+      return FACE_PROTOCOL_UNKNOWN;
+    }
+}
diff --git a/lib/src/libhicn-config.cmake.in b/lib/src/libhicn-config.cmake.in
new file mode 100644
index 000000000..1ae219280
--- /dev/null
+++ b/lib/src/libhicn-config.cmake.in
@@ -0,0 +1,12 @@
+set(Libhicn_VERSION "@VERSION_MAJOR@.@VERSION_MINOR@.@VERSION_PATCH@")
+
+@PACKAGE_INIT@
+
+set(Libhicn_VERSION_MAJOR "@VERSION_MAJOR@")
+set(Libhicn_VERSION_MINOR "@VERSION_MINOR@")
+set(Libhicn_VERSION_PATCH "@VERSION_PATCH@")
+
+set_and_check(Libhicn_INCLUDE_DIRS  "@PACKAGE_Libhicn_INCLUDE_DIRS@")
+include("${CMAKE_CURRENT_LIST_DIR}/libhicn-targets.cmake")
+
+check_required_components(Libhicn)
diff --git a/lib/src/mapme.c b/lib/src/mapme.c
index 3e7e8bc80..b8e8eaed2 100644
--- a/lib/src/mapme.c
+++ b/lib/src/mapme.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -26,8 +26,8 @@
 #include <hicn/protocol/ipv6.h>
 
 size_t
-hicn_mapme_v4_create_packet (u8 * buf, const hicn_prefix_t * prefix,
-			     const mapme_params_t * params)
+hicn_mapme_v4_create_packet (u8 *buf, const hicn_prefix_t *prefix,
+			     const mapme_params_t *params)
 {
   hicn_mapme_v4_header_t *mh = (hicn_mapme_v4_header_t *) buf;
   /* *INDENT-OFF* */
@@ -41,14 +41,14 @@ hicn_mapme_v4_create_packet (u8 * buf, const hicn_prefix_t * prefix,
       .ttl = HICN_MAPME_TTL,
       .protocol = IPPROTO_ICMP,
       .csum = 0,
-      .saddr.as_u32 = 0,
-      .daddr = prefix->name.ip4,
+      .saddr.as_u32 = IPV4_LOOPBACK.v4.as_u32,
+      .daddr = prefix->name.v4,
      },
     .icmp_rd = {
       .type = ((params->type == UPDATE) || (params->type == NOTIFICATION)) ? HICN_MAPME_ICMP_TYPE_IPV4 : HICN_MAPME_ICMP_TYPE_ACK_IPV4,
       .code = HICN_MAPME_ICMP_CODE,
       .csum = 0,
-      .ip = prefix->name.ip4,
+      .ip = prefix->name.v4,
     },
     .seq = htonl(params->seq),
     .len = prefix->len,
@@ -59,15 +59,15 @@ hicn_mapme_v4_create_packet (u8 * buf, const hicn_prefix_t * prefix,
 }
 
 size_t
-hicn_mapme_v6_create_packet (u8 * buf, const hicn_prefix_t * prefix,
-			     const mapme_params_t * params)
+hicn_mapme_v6_create_packet (u8 *buf, const hicn_prefix_t *prefix,
+			     const mapme_params_t *params)
 {
   hicn_mapme_v6_header_t *mh = (hicn_mapme_v6_header_t *) buf;
   /* *INDENT-OFF* */
   *mh = (hicn_mapme_v6_header_t) {
     .ip = {
-      .saddr = {{0}},
-      .daddr = prefix->name.ip6,
+      .saddr = IPV6_LOOPBACK.v6,
+      .daddr = prefix->name.v6,
       .version_class_flow = htonl(
           (IPV6_DEFAULT_VERSION       << 28) |
           (IPV6_DEFAULT_TRAFFIC_CLASS << 20) |
@@ -81,8 +81,8 @@ hicn_mapme_v6_create_packet (u8 * buf, const hicn_prefix_t * prefix,
       .code = HICN_MAPME_ICMP_CODE,
       .csum = 0,
       .res = 0,
-      .tgt = prefix->name.ip6,
-      .dst = prefix->name.ip6,
+      .tgt = prefix->name.v6,
+      .dst = prefix->name.v6,
     },
     .seq = htonl(params->seq),
     .len = prefix->len,
@@ -92,8 +92,8 @@ hicn_mapme_v6_create_packet (u8 * buf, const hicn_prefix_t * prefix,
 }
 
 size_t
-hicn_mapme_create_packet (u8 * buf, const hicn_prefix_t * prefix,
-			  const mapme_params_t * params)
+hicn_mapme_create_packet (u8 *buf, const hicn_prefix_t *prefix,
+			  const mapme_params_t *params)
 {
   /* We currently ignore subsequent protocol definitions */
   if (PREDICT_TRUE (params->protocol == IPPROTO_IPV6))
@@ -103,9 +103,9 @@ hicn_mapme_create_packet (u8 * buf, const hicn_prefix_t * prefix,
 }
 
 size_t
-hicn_mapme_v4_create_ack (u8 * buf, const mapme_params_t * params)
+hicn_mapme_v4_create_ack (u8 *buf, const mapme_params_t *params)
 {
-  ip4_address_t tmp;		// tmp storage for swapping IP addresses for ACK
+  ip4_address_t tmp; // tmp storage for swapping IP addresses for ACK
 
   hicn_mapme_v4_header_t *mh = (hicn_mapme_v4_header_t *) buf;
   tmp = mh->ip.daddr;
@@ -119,9 +119,9 @@ hicn_mapme_v4_create_ack (u8 * buf, const mapme_params_t * params)
 }
 
 size_t
-hicn_mapme_v6_create_ack (u8 * buf, const mapme_params_t * params)
+hicn_mapme_v6_create_ack (u8 *buf, const mapme_params_t *params)
 {
-  ip6_address_t tmp;		// tmp storage for swapping IP addresses for ACK
+  ip6_address_t tmp; // tmp storage for swapping IP addresses for ACK
 
   hicn_mapme_v6_header_t *mh = (hicn_mapme_v6_header_t *) buf;
   tmp = mh->ip.daddr;
@@ -135,7 +135,7 @@ hicn_mapme_v6_create_ack (u8 * buf, const mapme_params_t * params)
 }
 
 size_t
-hicn_mapme_create_ack (u8 * buf, const mapme_params_t * params)
+hicn_mapme_create_ack (u8 *buf, const mapme_params_t *params)
 {
   /* We currently ignore subsequent protocol definitions */
   if (PREDICT_TRUE (params->protocol == IPPROTO_IPV6))
@@ -145,22 +145,23 @@ hicn_mapme_create_ack (u8 * buf, const mapme_params_t * params)
 }
 
 int
-hicn_mapme_v4_parse_packet (const u8 * packet, hicn_prefix_t * prefix,
-			    mapme_params_t * params)
+hicn_mapme_v4_parse_packet (const u8 *packet, hicn_prefix_t *prefix,
+			    mapme_params_t *params)
 {
   hicn_mapme_v4_header_t *mh = (hicn_mapme_v4_header_t *) packet;
 
   /* *INDENT-OFF* */
   *prefix = (hicn_prefix_t) {
     .name = {
-      .ip4 = HICN_MAPME_TYPE_IS_IU (mh->icmp_rd.type) ? mh->ip.daddr : mh->ip.saddr,
+      .v4 = HICN_MAPME_TYPE_IS_IU (mh->icmp_rd.type) ? mh->ip.daddr : mh->ip.saddr,
     },
     .len = mh->len,
   };
 
-  *params = (mapme_params_t) {
+  *params = (mapme_params_t){
     .protocol = IPPROTO_IP,
-    .type = (mh->icmp_rd.type == HICN_MAPME_ICMP_TYPE_IPV4) ? UPDATE : UPDATE_ACK,
+    .type =
+      (mh->icmp_rd.type == HICN_MAPME_ICMP_TYPE_IPV4) ? UPDATE : UPDATE_ACK,
     .seq = ntohl (mh->seq),
   };
   /* *INDENT-ON* */
@@ -169,22 +170,23 @@ hicn_mapme_v4_parse_packet (const u8 * packet, hicn_prefix_t * prefix,
 }
 
 int
-hicn_mapme_v6_parse_packet (const u8 * packet, hicn_prefix_t * prefix,
-			    mapme_params_t * params)
+hicn_mapme_v6_parse_packet (const u8 *packet, hicn_prefix_t *prefix,
+			    mapme_params_t *params)
 {
   hicn_mapme_v6_header_t *mh = (hicn_mapme_v6_header_t *) packet;
 
   /* *INDENT-OFF* */
   *prefix = (hicn_prefix_t) {
     .name = {
-      .ip6 = HICN_MAPME_TYPE_IS_IU (mh->icmp_rd.type) ? mh->ip.daddr : mh->ip.saddr,
+      .v6 = HICN_MAPME_TYPE_IS_IU (mh->icmp_rd.type) ? mh->ip.daddr : mh->ip.saddr,
     },
     .len = mh->len,
   };
 
-  *params = (mapme_params_t) {
+  *params = (mapme_params_t){
     .protocol = IPPROTO_IPV6,
-    .type = (mh->icmp_rd.type == HICN_MAPME_ICMP_TYPE_IPV6) ? UPDATE : UPDATE_ACK,
+    .type =
+      (mh->icmp_rd.type == HICN_MAPME_ICMP_TYPE_IPV6) ? UPDATE : UPDATE_ACK,
     .seq = ntohl (mh->seq),
   };
   /* *INDENT-ON* */
@@ -193,8 +195,8 @@ hicn_mapme_v6_parse_packet (const u8 * packet, hicn_prefix_t * prefix,
 }
 
 int
-hicn_mapme_parse_packet (const u8 * packet, hicn_prefix_t * prefix,
-			 mapme_params_t * params)
+hicn_mapme_parse_packet (const u8 *packet, hicn_prefix_t *prefix,
+			 mapme_params_t *params)
 {
   switch (HICN_IP_VERSION (packet))
     {
diff --git a/lib/src/name.c b/lib/src/name.c
index 54b2a76aa..3bdcbbdb4 100644
--- a/lib/src/name.c
+++ b/lib/src/name.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -19,522 +19,210 @@
  */
 
 #ifndef _WIN32
-#include <arpa/inet.h>          // inet_ptin
+#include <arpa/inet.h> // inet_ptin
 #endif
 #include <errno.h>
 #include <stdio.h>
-#include <stdlib.h>             // strtoul
-#include <string.h>             // memcpy
+#include <stdlib.h> // strtoul
+#include <string.h> // memcpy
 
 #include <hicn/common.h>
 #include <hicn/error.h>
 #include <hicn/name.h>
+#include <hicn/util/sstrncpy.h>
 
-#if ! HICN_VPP_PLUGIN
 int
-hicn_name_create (const char *ip_address, u32 id, hicn_name_t * name)
+hicn_name_create (const char *ip_address, u32 id, hicn_name_t *name)
 {
   int af, rc;
 
-  af = get_addr_family (ip_address);
-
-  switch (af)
-    {
-    case AF_INET:
-      if (name->type == HNT_UNSPEC)
-        {
-          name->type = HNT_CONTIGUOUS_V4;
-        }
-      name->len = IPV4_ADDR_LEN;
-      break;
-    case AF_INET6:
-      if (name->type == HNT_UNSPEC)
-        {
-          name->type = HNT_CONTIGUOUS_V6;
-        }
-      name->len = IPV6_ADDR_LEN;
-      break;
-    default:
-      return HICN_LIB_ERROR_INVALID_IP_ADDRESS;
-    }
+  memset (name, 0, sizeof (hicn_name_t));
 
-  if ((name->type != HNT_CONTIGUOUS_V4) && (name->type != HNT_CONTIGUOUS_V6))
-    {
-      return HICN_LIB_ERROR_NOT_IMPLEMENTED;
-    }
+  af = get_addr_family (ip_address);
+  int v4 = (af == AF_INET);
+  u8 *dst = (u8 *) (v4 * (intptr_t) (name->prefix.v4.as_u8) +
+		    (1 - v4) * (intptr_t) (name->prefix.v6.as_u8));
+  rc = inet_pton (af, ip_address, dst);
 
-  rc = inet_pton (af, ip_address, name->buffer);
-  if (rc <= 0)
+  if (rc != 1)
     {
       return HICN_LIB_ERROR_UNKNOWN_ADDRESS;
     }
-  *(u32 *) (name->buffer + name->len) = id;
+
+  name->suffix = id;
 
   return HICN_LIB_ERROR_NONE;
 }
 
 int
-hicn_name_create_from_ip_prefix (const ip_prefix_t * prefix, u32 id,
-                                  hicn_name_t * name)
+hicn_name_create_from_ip_prefix (const ip_prefix_t *prefix, u32 id,
+				 hicn_name_t *name)
 {
-  switch (prefix->family)
-    {
-      case AF_INET:
-        name->type = HNT_CONTIGUOUS_V4;
-        memcpy (name->buffer, prefix->address.v4.buffer,
-                ip_address_len(prefix->family));
-        name->len = IPV4_ADDR_LEN;
-        break;
-      case AF_INET6:
-        name->type = HNT_CONTIGUOUS_V6;
-        memcpy (name->buffer, prefix->address.v6.buffer,
-                ip_address_len(prefix->family));
-        name->len = IPV6_ADDR_LEN;
-        break;
-      default:
-        return HICN_LIB_ERROR_INVALID_IP_ADDRESS;
-    }
-
-  *(u32 *) (name->buffer + name->len) = id;
+  name->prefix.v6.as_u64[0] = prefix->address.v6.as_u64[0];
+  name->prefix.v6.as_u64[1] = prefix->address.v6.as_u64[1];
+  name->suffix = id;
 
   return HICN_LIB_ERROR_NONE;
 }
 
-u8
-hicn_name_get_length (const hicn_name_t * name)
-{
-  return name->len;
-}
-
 int
-hicn_name_compare (const hicn_name_t * name_1, const hicn_name_t * name_2,
-                   bool consider_segment)
+hicn_name_compare (const hicn_name_t *name_1, const hicn_name_t *name_2,
+		   bool consider_segment)
 {
-  hicn_name_t *name1 = (hicn_name_t *) name_1;
-  hicn_name_t *name2 = (hicn_name_t *) name_2;
-
-  if ((name1->type == HNT_CONTIGUOUS_V4 && name2->type == HNT_CONTIGUOUS_V6)
-      || (name1->type == HNT_CONTIGUOUS_V6
-          && name2->type == HNT_CONTIGUOUS_V4))
-    {
-      return -1;
-    }
-
-  if ((name1->type == HNT_IOV_V4 && name2->type == HNT_IOV_V6) ||
-      (name1->type == HNT_IOV_V6 && name2->type == HNT_IOV_V4))
-    {
-      return -1;
-    }
-
-  if ((name1->type == HNT_IOV_V4 && name2->type == HNT_CONTIGUOUS_V6) ||
-      (name1->type == HNT_IOV_V6 && name2->type == HNT_CONTIGUOUS_V4))
-    {
-      return -1;
-    }
-
-  if (name1->type == HNT_UNSPEC || name2->type == HNT_UNSPEC)
-    {
-      return -1;
-    }
-
-  size_t len1 = 0, len2 = 0;
+  int ret;
+  ret = memcmp (&name_1->prefix.v6.buffer, &name_2->prefix.v6.buffer,
+		sizeof (name_1->prefix.v6));
 
-  u8 *buffer11, *buffer12, *buffer21, *buffer22;
+  if (consider_segment)
+    ret |= !(name_1->suffix == name_2->suffix);
 
-  switch (name1->type)
-    {
-    case HNT_CONTIGUOUS_V4:
-      buffer11 = name1->buffer;
-      buffer12 = name1->buffer + IPV4_ADDR_LEN;
-      len1 = IPV4_ADDR_LEN;
-      break;
-    case HNT_CONTIGUOUS_V6:
-      buffer11 = name1->buffer;
-      buffer12 = name1->buffer + IPV6_ADDR_LEN;
-      len1 = IPV6_ADDR_LEN;
-      break;
-    case HNT_IOV_V4:
-      buffer11 = name1->iov.buffers[0].iov_base;
-      buffer12 = name1->iov.buffers[1].iov_base;
-      len1 = IPV4_ADDR_LEN;
-      break;
-    case HNT_IOV_V6:
-      buffer11 = name1->iov.buffers[0].iov_base;
-      buffer12 = name1->iov.buffers[1].iov_base;
-      len1 = IPV6_ADDR_LEN;
-      break;
-    default:
-      return HICN_LIB_ERROR_NOT_IMPLEMENTED;
-    }
-
-  switch (name2->type)
-    {
-    case HNT_CONTIGUOUS_V4:
-      buffer21 = name2->buffer;
-      buffer22 = name2->buffer + IPV4_ADDR_LEN;
-      len2 = IPV4_ADDR_LEN;
-      break;
-    case HNT_CONTIGUOUS_V6:
-      buffer21 = name2->buffer;
-      buffer22 = name2->buffer + IPV6_ADDR_LEN;
-      len2 = IPV6_ADDR_LEN;
-      break;
-    case HNT_IOV_V4:
-      buffer21 = name2->iov.buffers[0].iov_base;
-      buffer22 = name2->iov.buffers[1].iov_base;
-      len2 = IPV4_ADDR_LEN;
-      break;
-    case HNT_IOV_V6:
-      buffer21 = name2->iov.buffers[0].iov_base;
-      buffer22 = name2->iov.buffers[1].iov_base;
-      len2 = IPV6_ADDR_LEN;
-      break;
-    default:
-      return HICN_LIB_ERROR_NOT_IMPLEMENTED;
-    }
-
-  // Sanity check
-  if (len1 != len2)
-    {
-      return HICN_LIB_ERROR_UNEXPECTED;
-    }
-
-  int ret1 = memcmp ((u8 *) buffer11, (u8 *) buffer21, len1);
-
-  if (!consider_segment)
-    {
-      return ret1;
-    }
-
-  int ret2 = memcmp ((u8 *) buffer12, (u8 *) buffer22, HICN_SEGMENT_LEN);
-
-  return ret1 || ret2;
+  return ret;
 }
 
 int
-hicn_name_hash (const hicn_name_t * name, u32 * hash, bool consider_suffix)
+hicn_name_hash (const hicn_name_t *name, u32 *hash, bool consider_suffix)
 {
-  switch (name->type)
-    {
-    case HNT_CONTIGUOUS_V4:
-      *hash = hash32 (name->buffer, consider_suffix ? HICN_V4_NAME_LEN : HICN_V4_PREFIX_LEN);
-      break;
-    case HNT_CONTIGUOUS_V6:
-      *hash = hash32 (name->buffer, consider_suffix ? HICN_V6_NAME_LEN : HICN_V6_PREFIX_LEN);
-      break;
-    case HNT_IOV_V4:
-    case HNT_IOV_V6:
-      *hash =
-	hash32 (name->iov.buffers[0].iov_base, name->iov.buffers[0].iov_len);
-      if (consider_suffix)
-        {
-          *hash = cumulative_hash32 (name->iov.buffers[1].iov_base,
-			      name->iov.buffers[1].iov_len, *hash);
-        }
-      break;
-    default:
-      return HICN_LIB_ERROR_NOT_IMPLEMENTED;
-    }
+  *hash = hash32 (&name->prefix, sizeof (name->prefix));
+
+  if (consider_suffix)
+    *hash = cumulative_hash32 (&name->suffix, sizeof (name->suffix), *hash);
 
   return HICN_LIB_ERROR_NONE;
 }
 
 int
-hicn_name_empty (hicn_name_t * name)
+hicn_name_empty (hicn_name_t *name)
 {
-  return name->type == HNT_UNSPEC ? 1 : 0;
+  return _is_unspec (name);
 }
 
 int
-hicn_name_copy (hicn_name_t * dst, const hicn_name_t * src)
+hicn_name_copy (hicn_name_t *dst, const hicn_name_t *src)
 {
-  switch (src->type)
-    {
-    case HNT_CONTIGUOUS_V4:
-    case HNT_CONTIGUOUS_V6:
-      *dst = *src;
-      break;
-    case HNT_IOV_V4:
-    case HNT_IOV_V6:
-      dst->type =
-        src->type == HNT_IOV_V4 ? HNT_CONTIGUOUS_V4 : HNT_CONTIGUOUS_V6;
-      memcpy (dst->buffer, src->iov.buffers[0].iov_base,
-              src->iov.buffers[0].iov_len);
-      memcpy (dst->buffer + src->iov.buffers[0].iov_len,
-              src->iov.buffers[1].iov_base, src->iov.buffers[1].iov_len);
-      break;
-    default:
-      return HICN_LIB_ERROR_NOT_IMPLEMENTED;
-    }
-
+  *dst = *src;
   return HICN_LIB_ERROR_NONE;
 }
 
 int
-hicn_name_copy_to_destination (u8 * dst, const hicn_name_t * src,
-                               bool copy_suffix)
+hicn_name_copy_prefix_to_destination (u8 *dst, const hicn_name_t *name)
 {
-  size_t length;
-
-  switch (src->type)
-    {
-    case HNT_CONTIGUOUS_V4:
-      if (copy_suffix)
-        {
-          length = HICN_V4_NAME_LEN;
-        }
-      else
-        {
-          length = IPV4_ADDR_LEN;
-        }
-      memcpy (dst, src->buffer, length);
-      break;
-    case HNT_CONTIGUOUS_V6:
-      if (copy_suffix)
-        {
-          length = HICN_V6_NAME_LEN;
-        }
-      else
-        {
-          length = IPV6_ADDR_LEN;
-        }
-      memcpy (dst, src->buffer, length);
-      break;
-    case HNT_IOV_V4:
-    case HNT_IOV_V6:
-      memcpy (dst, src->iov.buffers[0].iov_base, src->iov.buffers[0].iov_len);
-      if (copy_suffix)
-        {
-          memcpy (dst + src->iov.buffers[0].iov_len,
-                  src->iov.buffers[1].iov_base, src->iov.buffers[1].iov_len);
-        }
-      break;
-    default:
-      return HICN_LIB_ERROR_NOT_IMPLEMENTED;
-    }
+  int v4 = _is_inet4 (name);
+  const u8 *src = (u8 *) (v4 * (intptr_t) (name->prefix.v4.as_u8) +
+			  (1 - v4) * (intptr_t) (name->prefix.v6.as_u8));
+  size_t size = v4 * IPV4_ADDR_LEN + (1 - v4) * IPV6_ADDR_LEN;
+  memcpy (dst, src, size);
 
   return HICN_LIB_ERROR_NONE;
 }
 
 int
-hicn_name_set_seq_number (hicn_name_t * name, u32 seq_number)
+hicn_name_set_seq_number (hicn_name_t *name, u32 seq_number)
 {
-  u8 *sequence_number = NULL;
-
-  switch (name->type)
-    {
-    case HNT_CONTIGUOUS_V6:
-      sequence_number = name->buffer + IPV6_ADDR_LEN;
-      break;
-    case HNT_CONTIGUOUS_V4:
-      sequence_number = name->buffer + IPV4_ADDR_LEN;
-      break;
-    case HNT_IOV_V6:
-    case HNT_IOV_V4:
-      sequence_number = name->iov.buffers[1].iov_base;
-      break;
-    case HNT_UNSPEC:
-      return HICN_LIB_ERROR_UNEXPECTED;
-    }
-
-  if (sequence_number)
-    {
-      *(u32 *) sequence_number = seq_number;
-    }
-  else
-    {
-      return HICN_LIB_ERROR_UNEXPECTED;
-    }
-
+  name->suffix = seq_number;
   return HICN_LIB_ERROR_NONE;
 }
 
 int
-hicn_name_to_sockaddr_address (const hicn_name_t * name,
-                               struct sockaddr *ip_address)
+hicn_name_to_sockaddr_address (const hicn_name_t *name,
+			       struct sockaddr *ip_address)
 {
   struct sockaddr_in6 *tmp6 = (struct sockaddr_in6 *) ip_address;
   struct sockaddr_in *tmp4 = (struct sockaddr_in *) ip_address;
 
-  switch (name->type)
+  assert (!_is_unspec (name));
+
+  if (_is_inet4 (name))
+    {
+      tmp4->sin_family = AF_INET;
+      tmp4->sin_port = DUMMY_PORT;
+      memcpy (&tmp4->sin_addr, &name->prefix.v4, IPV4_ADDR_LEN);
+    }
+  else
     {
-    case HNT_CONTIGUOUS_V6:
-      tmp6->sin6_family = AF_INET6;
-      tmp6->sin6_scope_id = 0;
-      tmp6->sin6_port = DUMMY_PORT;
-      memcpy (&tmp6->sin6_addr, name->buffer, IPV6_ADDR_LEN);
-      break;
-    case HNT_IOV_V6:
       tmp6->sin6_family = AF_INET6;
       tmp6->sin6_scope_id = 0;
       tmp6->sin6_port = DUMMY_PORT;
-      memcpy (&tmp6->sin6_addr, name->iov.buffers[0].iov_base,
-              name->iov.buffers[0].iov_len);
-      break;
-    case HNT_CONTIGUOUS_V4:
-      tmp4->sin_family = AF_INET;
-      tmp4->sin_port = DUMMY_PORT;
-      memcpy (&tmp4->sin_addr, name->buffer, IPV4_ADDR_LEN);
-      break;
-    case HNT_IOV_V4:
-      tmp4->sin_family = AF_INET;
-      tmp4->sin_port = DUMMY_PORT;
-      memcpy (&tmp4->sin_addr, name->iov.buffers[0].iov_base,
-              name->iov.buffers[0].iov_len);
-      break;
-    default:
-      return HICN_LIB_ERROR_UNEXPECTED;
+      memcpy (&tmp6->sin6_addr, &name->prefix.v6, IPV6_ADDR_LEN);
     }
 
   return HICN_LIB_ERROR_NONE;
 }
 
 int
-hicn_name_to_ip_prefix (const hicn_name_t * name, ip_prefix_t * prefix)
+hicn_name_to_ip_prefix (const hicn_name_t *name, ip_prefix_t *prefix)
 {
-  switch (name->type)
-    {
-    case HNT_CONTIGUOUS_V6:
-      memcpy (&prefix->address.v6.buffer, name->buffer, IPV6_ADDR_LEN);
-      prefix->family = AF_INET6;
-      break;
-    case HNT_IOV_V6:
-      memcpy (&prefix->address.v6.buffer, name->iov.buffers[0].iov_base,
-              name->iov.buffers[0].iov_len);
-      prefix->family = AF_INET6;
-      break;
-    case HNT_CONTIGUOUS_V4:
-      memcpy (&prefix->address.v4.buffer, name->buffer, IPV4_ADDR_LEN);
-      prefix->family = AF_INET;
-      break;
-    case HNT_IOV_V4:
-      memcpy (&prefix->address.v4.buffer, name->iov.buffers[0].iov_base,
-              name->iov.buffers[0].iov_len);
-      prefix->family = AF_INET;
-      break;
-    default:
-      return HICN_LIB_ERROR_UNEXPECTED;
-    }
+  int family, rc;
+  rc = hicn_name_get_family (name, &family);
+  if (rc)
+    return rc;
 
+  prefix->family = family;
+  prefix->address.v6.as_u64[0] = name->prefix.v6.as_u64[0];
+  prefix->address.v6.as_u64[1] = name->prefix.v6.as_u64[1];
+  prefix->len = 128;
   return HICN_LIB_ERROR_NONE;
 }
 
 int
-hicn_name_get_seq_number (const hicn_name_t * name, u32 * seq_number)
+hicn_name_get_seq_number (const hicn_name_t *name, u32 *seq_number)
 {
-  const u8 *sequence_number = NULL;
-
-  switch (name->type)
-    {
-    case HNT_CONTIGUOUS_V6:
-      sequence_number = name->buffer + IPV6_ADDR_LEN;
-      break;
-    case HNT_CONTIGUOUS_V4:
-      sequence_number = name->buffer + IPV4_ADDR_LEN;
-      break;
-    case HNT_IOV_V6:
-    case HNT_IOV_V4:
-      sequence_number = name->iov.buffers[1].iov_base;
-      break;
-    default:
-      return HICN_LIB_ERROR_UNEXPECTED;
-    }
-
-  if (sequence_number)
-    {
-      *seq_number = *(u32 *) sequence_number;
-    }
-  else
-    {
-      return HICN_LIB_ERROR_UNEXPECTED;
-    }
-
+  *seq_number = name->suffix;
   return HICN_LIB_ERROR_NONE;
 }
 
 int
-hicn_name_ntop (const hicn_name_t * src, char *dst, size_t len)
+hicn_name_ntop (const hicn_name_t *src, char *dst, size_t len)
 {
   int offset;
-  const char *rc;
-  void *seg_number = NULL;
-
-  switch (src->type)
-    {
-    case HNT_CONTIGUOUS_V6:
-      rc = inet_ntop (AF_INET6, src->buffer, dst, (socklen_t)len);
-      seg_number = (u8 *) src->buffer + IPV6_ADDR_LEN;
-      break;
-    case HNT_CONTIGUOUS_V4:
-      rc = inet_ntop (AF_INET, src->buffer, dst, (socklen_t)len);
-      seg_number = (u8 *) src->buffer + IPV4_ADDR_LEN;
-      break;
-    case HNT_IOV_V6:
-      rc = inet_ntop (AF_INET6, src->iov.buffers[0].iov_base, dst, (socklen_t)len);
-      seg_number = src->iov.buffers[1].iov_base;
-      break;
-    case HNT_IOV_V4:
-      rc = inet_ntop (AF_INET, src->iov.buffers[0].iov_base, dst, (socklen_t)len);
-      seg_number = src->iov.buffers[1].iov_base;
-      break;
-    default:
-      return HICN_LIB_ERROR_NOT_IMPLEMENTED;
-    }
+  const char *rc = NULL;
+  int v4 = _is_inet4 (src);
+  const u8 *addr = (u8 *) (v4 * (intptr_t) src->prefix.v4.as_u8 +
+			   (1 - v4) * (intptr_t) src->prefix.v6.as_u8);
+  int family = v4 * AF_INET + (1 - v4) * AF_INET6;
+  rc = inet_ntop (family, addr, dst, (socklen_t) len);
 
   if (!rc)
     {
-      goto ERR;
+      return HICN_LIB_ERROR_UNSPECIFIED;
     }
 
-  offset = (int) strlen (dst);
+  offset = (int) strnlen_s (dst, len);
   dst[offset] = '|';
 
-  sprintf (dst + offset + 1, "%lu", (unsigned long) (*(u32 *) seg_number));
+  snprintf (dst + offset + 1, len - offset - 1, "%lu",
+	    (unsigned long) (src->suffix));
 
   return HICN_LIB_ERROR_NONE;
-
-ERR:
-  return HICN_LIB_ERROR_UNSPECIFIED;
 }
 
 int
-hicn_name_pton (const char *src, hicn_name_t * dst)
+hicn_name_pton (const char *src, hicn_name_t *dst)
 {
   return HICN_LIB_ERROR_NOT_IMPLEMENTED;
 }
 
 int
-hicn_name_get_family (const hicn_name_t * name, int *family)
+hicn_name_get_family (const hicn_name_t *name, int *family)
 {
-  switch (name->type)
-    {
-    case HNT_CONTIGUOUS_V6:
-    case HNT_IOV_V6:
-      *family = AF_INET6;
-      break;
-    case HNT_CONTIGUOUS_V4:
-    case HNT_IOV_V4:
-      *family = AF_INET;
-      break;
-    default:
-      return HICN_LIB_ERROR_UNEXPECTED;
-    }
+  assert (!_is_unspec (name));
+  int v4 = _is_inet4 (name);
+  *family = v4 * AF_INET + (1 - v4) * AF_INET6;
 
   return HICN_LIB_ERROR_NONE;
 }
 
 int
-hicn_prefix_create_from_ip_prefix (const ip_prefix_t * ip_prefix,
-                                    hicn_prefix_t * prefix)
+hicn_prefix_create_from_ip_prefix (const ip_prefix_t *ip_prefix,
+				   hicn_prefix_t *prefix)
 {
   switch (ip_prefix->family)
     {
     case AF_INET:
-      prefix->name.ip4.as_u32 = ip_prefix->address.v4.as_u32;
+      prefix->name.v4.as_u32 = ip_prefix->address.v4.as_u32;
       break;
     case AF_INET6:
-      prefix->name.ip6.as_u64[0] = ip_prefix->address.v6.as_u64[0];
-      prefix->name.ip6.as_u64[1] = ip_prefix->address.v6.as_u64[1];
+      prefix->name.v6.as_u64[0] = ip_prefix->address.v6.as_u64[0];
+      prefix->name.v6.as_u64[1] = ip_prefix->address.v6.as_u64[1];
       break;
     default:
       return HICN_LIB_ERROR_INVALID_IP_ADDRESS;
@@ -544,9 +232,6 @@ hicn_prefix_create_from_ip_prefix (const ip_prefix_t * ip_prefix,
   return HICN_LIB_ERROR_NONE;
 }
 
-#endif /* ! HICN_VPP_PLUGIN */
-
-
 /*
  * fd.io coding-style-patch-verification: ON
  *
diff --git a/lib/src/ops.c b/lib/src/ops.c
index ef12e9bf0..80ffcf3c5 100644
--- a/lib/src/ops.c
+++ b/lib/src/ops.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -27,8 +27,10 @@
 
 extern const hicn_ops_t hicn_ops_ipv4;
 extern const hicn_ops_t hicn_ops_icmp;
+extern const hicn_ops_t hicn_ops_udp;
 extern const hicn_ops_t hicn_ops_tcp;
 extern const hicn_ops_t hicn_ops_ipv6;
+extern const hicn_ops_t hicn_ops_new;
 extern const hicn_ops_t hicn_ops_ah;
 
 /* Declare empty operations (terminates recursion on protocol layers) */
@@ -39,6 +41,7 @@ DECLARE_get_interest_name (none, NONE);
 DECLARE_set_interest_name (none, NONE);
 DECLARE_get_interest_name_suffix (none, NONE);
 DECLARE_set_interest_name_suffix (none, NONE);
+DECLARE_is_interest (none, NONE);
 DECLARE_mark_packet_as_interest (none, NONE);
 DECLARE_mark_packet_as_data (none, NONE);
 DECLARE_reset_interest_for_hash (none, NONE);
@@ -63,6 +66,8 @@ DECLARE_get_header_length (none, NONE);
 DECLARE_get_current_header_length (none, NONE);
 DECLARE_get_payload_length (none, NONE);
 DECLARE_set_payload_length (none, NONE);
+DECLARE_get_payload_type (none, NONE);
+DECLARE_set_payload_type (none, NONE);
 DECLARE_get_signature_size (none, NONE);
 DECLARE_set_signature_size (none, NONE);
 DECLARE_set_signature_timestamp (none, NONE);
@@ -72,8 +77,10 @@ DECLARE_get_validation_algorithm (none, NONE);
 DECLARE_set_key_id (none, NONE);
 DECLARE_get_key_id (none, NONE);
 DECLARE_get_signature (none, NONE);
-DECLARE_get_signature_gap (none, NONE);
-DECLARE_set_signature_gap (none, NONE);
+DECLARE_get_signature_padding (none, NONE);
+DECLARE_set_signature_padding (none, NONE);
+DECLARE_is_last_data (none, NONE);
+DECLARE_set_last_data (none, NONE);
 DECLARE_HICN_OPS (none);
 
 /**
@@ -84,9 +91,11 @@ const hicn_ops_t *const hicn_ops_vft[] = {
   /*  0 */ [IPPROTO_IP] = &hicn_ops_ipv4,
   /*  1 */[IPPROTO_ICMP] = &hicn_ops_icmp,
   /*  6 */[IPPROTO_TCP] = &hicn_ops_tcp,
+  /*  6 */[IPPROTO_UDP] = &hicn_ops_udp,
   /* 41 */[IPPROTO_IPV6] = &hicn_ops_ipv6,
   /* 51 */[IPPROTO_AH] = &hicn_ops_ah,
   /* 58 */[IPPROTO_ICMPV6] = &hicn_ops_icmp,
+  /* 98 */[IPPROTO_ENCAP] = &hicn_ops_new,
   [IPPROTO_NONE] = &hicn_ops_none,
 };
 
diff --git a/lib/src/policy.c b/lib/src/policy.c
index 694f0ea5e..0b4850b93 100644
--- a/lib/src/policy.c
+++ b/lib/src/policy.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,41 +21,56 @@
 #include <stdio.h>
 #include <hicn/policy.h>
 
-const char * policy_tag_str[] = {
-    #define _(x, y) [POLICY_TAG_ ## x] = STRINGIZE(x),
-    foreach_policy_tag
-    #undef _
+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 _
+#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 _
+const char *policy_state_str[] = {
+#define _(x) [POLICY_STATE_##x] = STRINGIZE (x),
+  foreach_policy_state
+#undef _
 };
 
+policy_state_t
+policy_state_from_str (const char *str)
+{
+#define _(x)                                                                  \
+  if (strcasecmp (str, #x) == 0)                                              \
+    return POLICY_STATE_##x;                                                  \
+  else
+  foreach_policy_state
+#undef _
+    return POLICY_STATE_N;
+}
+
 int
-policy_tag_state_snprintf(char * s, size_t size, const policy_tag_state_t * tag_state)
+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 >=  (int)(s + size - cur))
-        return (int)(s + size - cur);
-    if (rc < 0)
-        return rc;
-    cur += rc;
-    if (size != 0 && cur >= s + size)
-        return (int)(cur - s);
-
-    return (int)(cur - s);
+  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 >= (int) (s + size - cur))
+    return (int) (s + size - cur);
+  if (rc < 0)
+    return rc;
+  cur += rc;
+  if (size != 0 && cur >= s + size)
+    return (int) (cur - s);
+
+  return (int) (cur - s);
 }
diff --git a/lib/src/protocol/ah.c b/lib/src/protocol/ah.c
index 13340eae1..b3d24161d 100644
--- a/lib/src/protocol/ah.c
+++ b/lib/src/protocol/ah.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -31,6 +31,7 @@ DECLARE_get_interest_name (ah, UNEXPECTED);
 DECLARE_set_interest_name (ah, UNEXPECTED);
 DECLARE_get_interest_name_suffix (ah, UNEXPECTED);
 DECLARE_set_interest_name_suffix (ah, UNEXPECTED);
+DECLARE_is_interest (ah, UNEXPECTED);
 DECLARE_mark_packet_as_interest (ah, UNEXPECTED);
 DECLARE_mark_packet_as_data (ah, UNEXPECTED);
 DECLARE_get_data_locator (ah, UNEXPECTED);
@@ -46,6 +47,10 @@ DECLARE_get_lifetime (ah, UNEXPECTED);
 DECLARE_set_lifetime (ah, UNEXPECTED);
 DECLARE_get_payload_length (ah, UNEXPECTED);
 DECLARE_set_payload_length (ah, UNEXPECTED);
+DECLARE_get_payload_type (ah, UNEXPECTED);
+DECLARE_set_payload_type (ah, UNEXPECTED);
+DECLARE_is_last_data (ah, UNEXPECTED);
+DECLARE_set_last_data (ah, UNEXPECTED);
 
 int
 ah_init_packet_header (hicn_type_t type, hicn_protocol_t *h)
@@ -69,6 +74,7 @@ ah_reset_interest_for_hash (hicn_type_t type, hicn_protocol_t *h)
   if (rc < 0)
     return rc;
   memset (&(h->ah.validationPayload), 0, signature_size);
+  h->ah.signaturePadding = 0;
   return CHILD_OPS (reset_interest_for_hash, type, h);
 }
 
@@ -81,6 +87,7 @@ ah_reset_data_for_hash (hicn_type_t type, hicn_protocol_t *h)
   if (rc < 0)
     return rc;
   memset (&(h->ah.validationPayload), 0, signature_size);
+  h->ah.signaturePadding = 0;
   return CHILD_OPS (reset_interest_for_hash, type, h);
 }
 
@@ -102,7 +109,7 @@ ah_verify_checksums (hicn_type_t type, hicn_protocol_t *h, u16 partial_csum,
 
 int
 ah_rewrite_interest (hicn_type_t type, hicn_protocol_t *h,
-		     const ip46_address_t *addr_new, ip46_address_t *addr_old)
+		     const ip_address_t *addr_new, ip_address_t *addr_old)
 {
   /* Nothing to do on signature */
   return HICN_LIB_ERROR_NONE;
@@ -110,7 +117,7 @@ ah_rewrite_interest (hicn_type_t type, hicn_protocol_t *h,
 
 int
 ah_rewrite_data (hicn_type_t type, hicn_protocol_t *h,
-		 const ip46_address_t *addr_new, ip46_address_t *addr_old,
+		 const ip_address_t *addr_new, ip_address_t *addr_old,
 		 const hicn_faceid_t face_id, u8 reset_pl)
 {
   /* Nothing to do on signature */
@@ -162,7 +169,7 @@ int
 ah_set_signature_size (hicn_type_t type, hicn_protocol_t *h,
 		       const size_t signature_size)
 {
-  h->ah.payloadlen = (u8) (signature_size >> 2);
+  h->ah.payloadlen = signature_size >> 2;
   return HICN_LIB_ERROR_NONE;
 }
 
@@ -201,16 +208,17 @@ ah_get_validation_algorithm (hicn_type_t type, const hicn_protocol_t *h,
 }
 
 int
-ah_set_signature_gap (hicn_type_t type, hicn_protocol_t *h, uint8_t gap)
+ah_set_signature_padding (hicn_type_t type, hicn_protocol_t *h, size_t padding)
 {
-  h->ah.signatureGap = gap;
+  h->ah.signaturePadding = padding;
   return HICN_LIB_ERROR_NONE;
 }
 
 int
-ah_get_signature_gap (hicn_type_t type, const hicn_protocol_t *h, uint8_t *gap)
+ah_get_signature_padding (hicn_type_t type, const hicn_protocol_t *h,
+			  size_t *padding)
 {
-  *gap = h->ah.signatureGap;
+  *padding = h->ah.signaturePadding;
   return HICN_LIB_ERROR_NONE;
 }
 
diff --git a/lib/src/protocol/icmp.c b/lib/src/protocol/icmp.c
index 5783cf52c..0452e4fbb 100644
--- a/lib/src/protocol/icmp.c
+++ b/lib/src/protocol/icmp.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -24,6 +24,7 @@ DECLARE_get_interest_name (icmp, UNEXPECTED);
 DECLARE_set_interest_name (icmp, UNEXPECTED);
 DECLARE_get_interest_name_suffix (icmp, UNEXPECTED);
 DECLARE_set_interest_name_suffix (icmp, UNEXPECTED);
+DECLARE_is_interest (icmp, UNEXPECTED);
 DECLARE_mark_packet_as_interest (icmp, UNEXPECTED);
 DECLARE_mark_packet_as_data (icmp, UNEXPECTED);
 DECLARE_get_data_locator (icmp, UNEXPECTED);
@@ -40,7 +41,11 @@ DECLARE_set_lifetime (icmp, UNEXPECTED);
 DECLARE_get_length (icmp, UNEXPECTED);
 DECLARE_get_payload_length (icmp, UNEXPECTED);
 DECLARE_set_payload_length (icmp, UNEXPECTED);
+DECLARE_get_payload_type (icmp, UNEXPECTED);
+DECLARE_set_payload_type (icmp, UNEXPECTED);
 DECLARE_get_signature (icmp, UNEXPECTED);
+DECLARE_is_last_data (icmp, UNEXPECTED);
+DECLARE_set_last_data (icmp, UNEXPECTED);
 
 int
 icmp_init_packet_header (hicn_type_t type, hicn_protocol_t *h)
@@ -94,8 +99,7 @@ icmp_verify_checksums (hicn_type_t type, hicn_protocol_t *h, u16 partial_csum,
 
 int
 icmp_rewrite_interest (hicn_type_t type, hicn_protocol_t *h,
-		       const ip46_address_t *addr_new,
-		       ip46_address_t *addr_old)
+		       const ip_address_t *addr_new, ip_address_t *addr_old)
 {
   return HICN_LIB_ERROR_NOT_IMPLEMENTED;
   //    u16 *icmp_checksum = &(h->icmp.csum);
@@ -120,7 +124,7 @@ icmp_rewrite_interest (hicn_type_t type, hicn_protocol_t *h,
 
 int
 icmp_rewrite_data (hicn_type_t type, hicn_protocol_t *h,
-		   const ip46_address_t *addr_new, ip46_address_t *addr_old,
+		   const ip_address_t *addr_new, ip_address_t *addr_old,
 		   const hicn_faceid_t face_id, u8 reset_pl)
 {
   return HICN_LIB_ERROR_NOT_IMPLEMENTED;
@@ -184,16 +188,17 @@ icmp_set_signature_size (hicn_type_t type, hicn_protocol_t *h,
 }
 
 int
-icmp_set_signature_gap (hicn_type_t type, hicn_protocol_t *h, uint8_t gap)
+icmp_set_signature_padding (hicn_type_t type, hicn_protocol_t *h,
+			    size_t padding)
 {
-  return CHILD_OPS (set_signature_gap, type, h, gap);
+  return CHILD_OPS (set_signature_padding, type, h, padding);
 }
 
 int
-icmp_get_signature_gap (hicn_type_t type, const hicn_protocol_t *h,
-			uint8_t *gap)
+icmp_get_signature_padding (hicn_type_t type, const hicn_protocol_t *h,
+			    size_t *padding)
 {
-  return CHILD_OPS (get_signature_gap, type, h, gap);
+  return CHILD_OPS (get_signature_padding, type, h, padding);
 }
 
 int
diff --git a/lib/src/protocol/ipv4.c b/lib/src/protocol/ipv4.c
index cf50f9996..5d445f018 100644
--- a/lib/src/protocol/ipv4.c
+++ b/lib/src/protocol/ipv4.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -64,17 +64,17 @@ ipv4_init_packet_header (hicn_type_t type, hicn_protocol_t *h)
 
 int
 ipv4_get_interest_locator (hicn_type_t type, const hicn_protocol_t *h,
-			   ip46_address_t *ip_address)
+			   ip_address_t *ip_address)
 {
-  ip_address->ip4 = h->ipv4.saddr;
+  ip_address->v4 = h->ipv4.saddr;
   return HICN_LIB_ERROR_NONE;
 }
 
 int
 ipv4_set_interest_locator (hicn_type_t type, hicn_protocol_t *h,
-			   const ip46_address_t *ip_address)
+			   const ip_address_t *ip_address)
 {
-  h->ipv4.saddr = ip_address->ip4;
+  h->ipv4.saddr = ip_address->v4;
   return HICN_LIB_ERROR_NONE;
 }
 
@@ -82,20 +82,16 @@ int
 ipv4_get_interest_name (hicn_type_t type, const hicn_protocol_t *h,
 			hicn_name_t *name)
 {
-  name->ip4.prefix_as_ip4 = h->ipv4.daddr;
-#ifndef HICN_VPP_PLUGIN
-  name->type = HNT_CONTIGUOUS_V4;
-  name->len = HICN_V4_NAME_LEN;
-#endif /* HICN_VPP_PLUGIN */
-  return CHILD_OPS (get_interest_name_suffix, type, h, &(name->ip4.suffix));
+  name->prefix.v4 = h->ipv4.daddr;
+  return CHILD_OPS (get_interest_name_suffix, type, h, &(name->suffix));
 }
 
 int
 ipv4_set_interest_name (hicn_type_t type, hicn_protocol_t *h,
 			const hicn_name_t *name)
 {
-  h->ipv4.daddr = name->ip4.prefix_as_ip4;
-  return CHILD_OPS (set_interest_name_suffix, type, h, &(name->ip4.suffix));
+  h->ipv4.daddr = name->prefix.v4;
+  return CHILD_OPS (set_interest_name_suffix, type, h, &(name->suffix));
 }
 
 int
@@ -113,6 +109,12 @@ ipv4_set_interest_name_suffix (hicn_type_t type, hicn_protocol_t *h,
 }
 
 int
+ipv4_is_interest (hicn_type_t type, const hicn_protocol_t *h, int *is_interest)
+{
+  return CHILD_OPS (is_interest, type, h, is_interest);
+}
+
+int
 ipv4_mark_packet_as_interest (hicn_type_t type, hicn_protocol_t *h)
 {
   return CHILD_OPS (mark_packet_as_interest, type, h);
@@ -135,17 +137,17 @@ ipv4_reset_interest_for_hash (hicn_type_t type, hicn_protocol_t *h)
 
 int
 ipv4_get_data_locator (hicn_type_t type, const hicn_protocol_t *h,
-		       ip46_address_t *ip_address)
+		       ip_address_t *ip_address)
 {
-  ip_address->ip4 = h->ipv4.daddr;
+  ip_address->v4 = h->ipv4.daddr;
   return HICN_LIB_ERROR_NONE;
 }
 
 int
 ipv4_set_data_locator (hicn_type_t type, hicn_protocol_t *h,
-		       const ip46_address_t *ip_address)
+		       const ip_address_t *ip_address)
 {
-  h->ipv4.daddr = ip_address->ip4;
+  h->ipv4.daddr = ip_address->v4;
   return HICN_LIB_ERROR_NONE;
 }
 
@@ -153,20 +155,16 @@ int
 ipv4_get_data_name (hicn_type_t type, const hicn_protocol_t *h,
 		    hicn_name_t *name)
 {
-  name->ip4.prefix_as_ip4 = h->ipv4.saddr;
-#ifndef HICN_VPP_PLUGIN
-  name->type = HNT_CONTIGUOUS_V4;
-  name->len = HICN_V4_NAME_LEN;
-#endif /* HICN_VPP_PLUGIN */
-  return CHILD_OPS (get_data_name_suffix, type, h, &(name->ip4.suffix));
+  name->prefix.v4 = h->ipv4.saddr;
+  return CHILD_OPS (get_data_name_suffix, type, h, &(name->suffix));
 }
 
 int
 ipv4_set_data_name (hicn_type_t type, hicn_protocol_t *h,
 		    const hicn_name_t *name)
 {
-  h->ipv4.saddr = name->ip4.prefix_as_ip4;
-  return CHILD_OPS (set_data_name_suffix, type, h, &(name->ip4.suffix));
+  h->ipv4.saddr = name->prefix.v4;
+  return CHILD_OPS (set_data_name_suffix, type, h, &(name->suffix));
 }
 
 int
@@ -311,16 +309,15 @@ ipv4_verify_checksums (hicn_type_t type, hicn_protocol_t *h, u16 partial_csum,
 
 int
 ipv4_rewrite_interest (hicn_type_t type, hicn_protocol_t *h,
-		       const ip46_address_t *addr_new,
-		       ip46_address_t *addr_old)
+		       const ip_address_t *addr_new, ip_address_t *addr_old)
 {
   // ASSERT(addr_old == NULL);
-  addr_old->ip4 = h->ipv4.saddr;
+  addr_old->v4 = h->ipv4.saddr;
   addr_old->pad[0] = 0;
   addr_old->pad[1] = 0;
   addr_old->pad[2] = 0;
 
-  h->ipv4.saddr = addr_new->ip4;
+  h->ipv4.saddr = addr_new->v4;
   h->ipv4.csum = 0;
   h->ipv4.csum = csum (&h->ipv4, IPV4_HDRLEN, 0);
 
@@ -329,16 +326,16 @@ ipv4_rewrite_interest (hicn_type_t type, hicn_protocol_t *h,
 
 int
 ipv4_rewrite_data (hicn_type_t type, hicn_protocol_t *h,
-		   const ip46_address_t *addr_new, ip46_address_t *addr_old,
+		   const ip_address_t *addr_new, ip_address_t *addr_old,
 		   const hicn_faceid_t face_id, u8 reset_pl)
 {
   // ASSERT(addr_old == NULL);
-  addr_old->ip4 = h->ipv4.daddr;
+  addr_old->v4 = h->ipv4.daddr;
   addr_old->pad[0] = 0;
   addr_old->pad[1] = 0;
   addr_old->pad[2] = 0;
 
-  h->ipv4.daddr = addr_new->ip4;
+  h->ipv4.daddr = addr_new->v4;
   h->ipv4.csum = 0;
   h->ipv4.csum = csum (&h->ipv4, IPV4_HDRLEN, 0);
 
@@ -408,6 +405,20 @@ ipv4_set_payload_length (hicn_type_t type, hicn_protocol_t *h,
 }
 
 int
+ipv4_get_payload_type (hicn_type_t type, const hicn_protocol_t *h,
+		       hicn_payload_type_t *payload_type)
+{
+  return CHILD_OPS (get_payload_type, type, h, payload_type);
+}
+
+int
+ipv4_set_payload_type (hicn_type_t type, hicn_protocol_t *h,
+		       hicn_payload_type_t payload_type)
+{
+  return CHILD_OPS (set_payload_type, type, h, payload_type);
+}
+
+int
 ipv4_get_signature_size (hicn_type_t type, const hicn_protocol_t *h,
 			 size_t *signature_size)
 {
@@ -422,16 +433,17 @@ ipv4_set_signature_size (hicn_type_t type, hicn_protocol_t *h,
 }
 
 int
-ipv4_set_signature_gap (hicn_type_t type, hicn_protocol_t *h, uint8_t gap)
+ipv4_set_signature_padding (hicn_type_t type, hicn_protocol_t *h,
+			    size_t padding)
 {
-  return CHILD_OPS (set_signature_gap, type, h, gap);
+  return CHILD_OPS (set_signature_padding, type, h, padding);
 }
 
 int
-ipv4_get_signature_gap (hicn_type_t type, const hicn_protocol_t *h,
-			uint8_t *gap)
+ipv4_get_signature_padding (hicn_type_t type, const hicn_protocol_t *h,
+			    size_t *padding)
 {
-  return CHILD_OPS (get_signature_gap, type, h, gap);
+  return CHILD_OPS (get_signature_padding, type, h, padding);
 }
 
 int
@@ -481,6 +493,18 @@ ipv4_get_signature (hicn_type_t type, hicn_protocol_t *h, uint8_t **signature)
   return CHILD_OPS (get_signature, type, h, signature);
 }
 
+int
+ipv4_is_last_data (hicn_type_t type, const hicn_protocol_t *h, int *is_last)
+{
+  return CHILD_OPS (is_last_data, type, h, is_last);
+}
+
+int
+ipv4_set_last_data (hicn_type_t type, hicn_protocol_t *h)
+{
+  return CHILD_OPS (set_last_data, type, h);
+}
+
 DECLARE_HICN_OPS (ipv4);
 
 /*
diff --git a/lib/src/protocol/ipv6.c b/lib/src/protocol/ipv6.c
index 7ac55b2be..b3a107a13 100644
--- a/lib/src/protocol/ipv6.c
+++ b/lib/src/protocol/ipv6.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -33,8 +33,8 @@ ipv6_init_packet_header (hicn_type_t type, hicn_protocol_t *h)
 
   /* *INDENT-OFF* */
   h->ipv6 = (_ipv6_header_t){
-    .saddr = { { 0 } },
-    .daddr = { { 0 } },
+    .saddr = IP6_ADDRESS_EMPTY,
+    .daddr = IP6_ADDRESS_EMPTY,
     .version_class_flow = htonl ((IPV6_DEFAULT_VERSION << 28) |
 				 (IPV6_DEFAULT_TRAFFIC_CLASS << 20) |
 				 (IPV6_DEFAULT_FLOW_LABEL & 0xfffff)),
@@ -48,17 +48,17 @@ ipv6_init_packet_header (hicn_type_t type, hicn_protocol_t *h)
 
 int
 ipv6_get_interest_locator (hicn_type_t type, const hicn_protocol_t *h,
-			   ip46_address_t *ip_address)
+			   ip_address_t *ip_address)
 {
-  ip_address->ip6 = h->ipv6.saddr;
+  ip_address->v6 = h->ipv6.saddr;
   return HICN_LIB_ERROR_NONE;
 }
 
 int
 ipv6_set_interest_locator (hicn_type_t type, hicn_protocol_t *h,
-			   const ip46_address_t *ip_address)
+			   const ip_address_t *ip_address)
 {
-  h->ipv6.saddr = ip_address->ip6;
+  h->ipv6.saddr = ip_address->v6;
   return HICN_LIB_ERROR_NONE;
 }
 
@@ -66,20 +66,16 @@ int
 ipv6_get_interest_name (hicn_type_t type, const hicn_protocol_t *h,
 			hicn_name_t *name)
 {
-  name->ip6.prefix_as_ip6 = h->ipv6.daddr;
-#ifndef HICN_VPP_PLUGIN
-  name->type = HNT_CONTIGUOUS_V6;
-  name->len = HICN_V6_NAME_LEN;
-#endif /* HICN_VPP_PLUGIN */
-  return CHILD_OPS (get_interest_name_suffix, type, h, &(name->ip6.suffix));
+  name->prefix.v6 = h->ipv6.daddr;
+  return CHILD_OPS (get_interest_name_suffix, type, h, &(name->suffix));
 }
 
 int
 ipv6_set_interest_name (hicn_type_t type, hicn_protocol_t *h,
 			const hicn_name_t *name)
 {
-  h->ipv6.daddr = name->ip6.prefix_as_ip6;
-  return CHILD_OPS (set_interest_name_suffix, type, h, &(name->ip6.suffix));
+  h->ipv6.daddr = name->prefix.v6;
+  return CHILD_OPS (set_interest_name_suffix, type, h, &(name->suffix));
 }
 
 int
@@ -97,6 +93,12 @@ ipv6_set_interest_name_suffix (hicn_type_t type, hicn_protocol_t *h,
 }
 
 int
+ipv6_is_interest (hicn_type_t type, const hicn_protocol_t *h, int *is_interest)
+{
+  return CHILD_OPS (is_interest, type, h, is_interest);
+}
+
+int
 ipv6_mark_packet_as_interest (hicn_type_t type, hicn_protocol_t *h)
 {
   return CHILD_OPS (mark_packet_as_interest, type, h);
@@ -119,17 +121,17 @@ ipv6_reset_interest_for_hash (hicn_type_t type, hicn_protocol_t *h)
 
 int
 ipv6_get_data_locator (hicn_type_t type, const hicn_protocol_t *h,
-		       ip46_address_t *ip_address)
+		       ip_address_t *ip_address)
 {
-  ip_address->ip6 = h->ipv6.daddr;
+  ip_address->v6 = h->ipv6.daddr;
   return HICN_LIB_ERROR_NONE;
 }
 
 int
 ipv6_set_data_locator (hicn_type_t type, hicn_protocol_t *h,
-		       const ip46_address_t *ip_address)
+		       const ip_address_t *ip_address)
 {
-  h->ipv6.daddr = ip_address->ip6;
+  h->ipv6.daddr = ip_address->v6;
   return HICN_LIB_ERROR_NONE;
 }
 
@@ -137,20 +139,16 @@ int
 ipv6_get_data_name (hicn_type_t type, const hicn_protocol_t *h,
 		    hicn_name_t *name)
 {
-  name->ip6.prefix_as_ip6 = h->ipv6.saddr;
-#ifndef HICN_VPP_PLUGIN
-  name->type = HNT_CONTIGUOUS_V6;
-  name->len = HICN_V6_NAME_LEN;
-#endif /* HICN_VPP_PLUGIN */
-  return CHILD_OPS (get_data_name_suffix, type, h, &(name->ip6.suffix));
+  name->prefix.v6 = h->ipv6.saddr;
+  return CHILD_OPS (get_data_name_suffix, type, h, &(name->suffix));
 }
 
 int
 ipv6_set_data_name (hicn_type_t type, hicn_protocol_t *h,
 		    const hicn_name_t *name)
 {
-  h->ipv6.saddr = name->ip6.prefix_as_ip6;
-  return CHILD_OPS (set_data_name_suffix, type, h, &(name->ip6.suffix));
+  h->ipv6.saddr = name->prefix.v6;
+  return CHILD_OPS (set_data_name_suffix, type, h, &(name->suffix));
 }
 
 int
@@ -281,24 +279,23 @@ ipv6_verify_checksums (hicn_type_t type, hicn_protocol_t *h, u16 partial_csum,
 
 int
 ipv6_rewrite_interest (hicn_type_t type, hicn_protocol_t *h,
-		       const ip46_address_t *addr_new,
-		       ip46_address_t *addr_old)
+		       const ip_address_t *addr_new, ip_address_t *addr_old)
 {
   // ASSERT(addr_old == NULL);
-  addr_old->ip6 = h->ipv6.saddr;
-  h->ipv6.saddr = addr_new->ip6;
+  addr_old->v6 = h->ipv6.saddr;
+  h->ipv6.saddr = addr_new->v6;
 
   return CHILD_OPS (rewrite_interest, type, h, addr_new, addr_old);
 }
 
 int
 ipv6_rewrite_data (hicn_type_t type, hicn_protocol_t *h,
-		   const ip46_address_t *addr_new, ip46_address_t *addr_old,
+		   const ip_address_t *addr_new, ip_address_t *addr_old,
 		   const hicn_faceid_t face_id, u8 reset_pl)
 {
   // ASSERT(addr_old == NULL);
-  addr_old->ip6 = h->ipv6.daddr;
-  h->ipv6.daddr = addr_new->ip6;
+  addr_old->v6 = h->ipv6.daddr;
+  h->ipv6.daddr = addr_new->v6;
 
   return CHILD_OPS (rewrite_data, type, h, addr_new, addr_old, face_id,
 		    reset_pl);
@@ -357,6 +354,20 @@ ipv6_set_payload_length (hicn_type_t type, hicn_protocol_t *h,
 }
 
 int
+ipv6_get_payload_type (hicn_type_t type, const hicn_protocol_t *h,
+		       hicn_payload_type_t *payload_type)
+{
+  return CHILD_OPS (get_payload_type, type, h, payload_type);
+}
+
+int
+ipv6_set_payload_type (hicn_type_t type, hicn_protocol_t *h,
+		       hicn_payload_type_t payload_type)
+{
+  return CHILD_OPS (set_payload_type, type, h, payload_type);
+}
+
+int
 ipv6_get_signature_size (hicn_type_t type, const hicn_protocol_t *h,
 			 size_t *signature_size)
 {
@@ -371,16 +382,17 @@ ipv6_set_signature_size (hicn_type_t type, hicn_protocol_t *h,
 }
 
 int
-ipv6_set_signature_gap (hicn_type_t type, hicn_protocol_t *h, uint8_t gap)
+ipv6_set_signature_padding (hicn_type_t type, hicn_protocol_t *h,
+			    size_t padding)
 {
-  return CHILD_OPS (set_signature_gap, type, h, gap);
+  return CHILD_OPS (set_signature_padding, type, h, padding);
 }
 
 int
-ipv6_get_signature_gap (hicn_type_t type, const hicn_protocol_t *h,
-			uint8_t *gap)
+ipv6_get_signature_padding (hicn_type_t type, const hicn_protocol_t *h,
+			    size_t *padding)
 {
-  return CHILD_OPS (get_signature_gap, type, h, gap);
+  return CHILD_OPS (get_signature_padding, type, h, padding);
 }
 
 int
@@ -430,6 +442,18 @@ ipv6_get_signature (hicn_type_t type, hicn_protocol_t *h, uint8_t **signature)
   return CHILD_OPS (get_signature, type, h, signature);
 }
 
+int
+ipv6_is_last_data (hicn_type_t type, const hicn_protocol_t *h, int *is_last)
+{
+  return CHILD_OPS (is_last_data, type, h, is_last);
+}
+
+int
+ipv6_set_last_data (hicn_type_t type, hicn_protocol_t *h)
+{
+  return CHILD_OPS (set_last_data, type, h);
+}
+
 DECLARE_HICN_OPS (ipv6);
 
 /*
diff --git a/lib/src/protocol/new.c b/lib/src/protocol/new.c
new file mode 100644
index 000000000..8c79963ad
--- /dev/null
+++ b/lib/src/protocol/new.c
@@ -0,0 +1,441 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <hicn/common.h>
+#include <hicn/error.h>
+#include <hicn/ops.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+
+static int
+is_interest (u8 flags)
+{
+  return flags & HICN_NEW_FLAG_INT;
+}
+
+int
+new_init_packet_header (hicn_type_t type, hicn_protocol_t *h)
+{
+  memset (&h->newhdr, 0, sizeof (h->newhdr));
+  _set_new_header_version (&h->newhdr);
+  uint8_t ah_flag = type.l2 == IPPROTO_AH ? HICN_NEW_FLAG_SIG : 0;
+  h->newhdr.flags |= ah_flag;
+
+  return CHILD_OPS (init_packet_header, type, h);
+}
+
+int
+new_is_interest (hicn_type_t type, const hicn_protocol_t *h, int *is_interest)
+{
+  *is_interest = (h->newhdr.flags & HICN_NEW_FLAG_INT) != 0;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_mark_packet_as_interest (hicn_type_t type, hicn_protocol_t *h)
+{
+  h->newhdr.flags |= HICN_NEW_FLAG_INT;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_mark_packet_as_data (hicn_type_t type, hicn_protocol_t *h)
+{
+  h->newhdr.flags &= ~HICN_NEW_FLAG_INT;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_get_interest_locator (hicn_type_t type, const hicn_protocol_t *h,
+			  ip_address_t *ip_address)
+{
+  assert (is_interest (h->newhdr.flags));
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_set_interest_locator (hicn_type_t type, hicn_protocol_t *h,
+			  const ip_address_t *ip_address)
+{
+  assert (is_interest (h->newhdr.flags));
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_get_interest_name (hicn_type_t type, const hicn_protocol_t *h,
+		       hicn_name_t *name)
+{
+  assert (is_interest (h->newhdr.flags));
+  name->prefix = h->newhdr.prefix;
+  name->suffix = ntohl (h->newhdr.suffix);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_set_interest_name (hicn_type_t type, hicn_protocol_t *h,
+		       const hicn_name_t *name)
+{
+  int rc = new_mark_packet_as_interest (type, h);
+  if (rc)
+    return rc;
+
+  assert (is_interest (h->newhdr.flags));
+  h->newhdr.prefix = name->prefix;
+  h->newhdr.suffix = htonl (name->suffix);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_get_interest_name_suffix (hicn_type_t type, const hicn_protocol_t *h,
+			      hicn_name_suffix_t *suffix)
+{
+  assert (is_interest (h->newhdr.flags));
+  *suffix = ntohl (h->newhdr.suffix);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_set_interest_name_suffix (hicn_type_t type, hicn_protocol_t *h,
+			      const hicn_name_suffix_t *suffix)
+{
+  assert (is_interest (h->newhdr.flags));
+  h->newhdr.suffix = htonl (*suffix);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_reset_interest_for_hash (hicn_type_t type, hicn_protocol_t *h)
+{
+  assert (is_interest (h->newhdr.flags));
+  return CHILD_OPS (init_packet_header, type, h);
+}
+
+int
+new_get_data_locator (hicn_type_t type, const hicn_protocol_t *h,
+		      ip_address_t *ip_address)
+{
+  assert (!is_interest (h->newhdr.flags));
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_set_data_locator (hicn_type_t type, hicn_protocol_t *h,
+		      const ip_address_t *ip_address)
+{
+  assert (!is_interest (h->newhdr.flags));
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_get_data_name (hicn_type_t type, const hicn_protocol_t *h,
+		   hicn_name_t *name)
+{
+  assert (!is_interest (h->newhdr.flags));
+  name->prefix = h->newhdr.prefix;
+  name->suffix = ntohl (h->newhdr.suffix);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_set_data_name (hicn_type_t type, hicn_protocol_t *h,
+		   const hicn_name_t *name)
+{
+  new_mark_packet_as_data (type, h);
+  assert (!is_interest (h->newhdr.flags));
+  h->newhdr.prefix = name->prefix;
+  h->newhdr.suffix = htonl (name->suffix);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_get_data_name_suffix (hicn_type_t type, const hicn_protocol_t *h,
+			  hicn_name_suffix_t *suffix)
+{
+  assert (!is_interest (h->newhdr.flags));
+  *suffix = ntohl (h->newhdr.suffix);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_set_data_name_suffix (hicn_type_t type, hicn_protocol_t *h,
+			  const hicn_name_suffix_t *suffix)
+{
+  assert (!is_interest (h->newhdr.flags));
+  h->newhdr.suffix = htonl (*suffix);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_get_data_pathlabel (hicn_type_t type, const hicn_protocol_t *h,
+			u32 *pathlabel)
+{
+  assert (!is_interest (h->newhdr.flags));
+  *pathlabel = h->newhdr.path_label;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_set_data_pathlabel (hicn_type_t type, hicn_protocol_t *h,
+			const u32 pathlabel)
+{
+  assert (!is_interest (h->newhdr.flags));
+  h->newhdr.path_label = pathlabel;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_update_data_pathlabel (hicn_type_t type, hicn_protocol_t *h,
+			   const hicn_faceid_t face_id)
+{
+  hicn_pathlabel_t new_pl;
+  update_pathlabel (h->newhdr.path_label, face_id, &new_pl);
+  h->newhdr.path_label = new_pl;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_reset_data_for_hash (hicn_type_t type, hicn_protocol_t *h)
+{
+  return CHILD_OPS (reset_data_for_hash, type, h);
+}
+
+int
+new_get_lifetime (hicn_type_t type, const hicn_protocol_t *h,
+		  hicn_lifetime_t *lifetime)
+{
+  *lifetime = ntohl (h->newhdr.lifetime);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_set_lifetime (hicn_type_t type, hicn_protocol_t *h,
+		  const hicn_lifetime_t lifetime)
+{
+  h->newhdr.lifetime = htonl (lifetime);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_update_checksums (hicn_type_t type, hicn_protocol_t *h, u16 partial_csum,
+		      size_t payload_length)
+{
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_verify_checksums (hicn_type_t type, hicn_protocol_t *h, u16 partial_csum,
+		      size_t payload_length)
+{
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_rewrite_interest (hicn_type_t type, hicn_protocol_t *h,
+		      const ip_address_t *addr_new, ip_address_t *addr_old)
+{
+  assert (is_interest (h->newhdr.flags));
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_rewrite_data (hicn_type_t type, hicn_protocol_t *h,
+		  const ip_address_t *addr_new, ip_address_t *addr_old,
+		  const hicn_faceid_t face_id, u8 reset_pl)
+{
+  assert (!is_interest (h->newhdr.flags));
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_get_length (hicn_type_t type, const hicn_protocol_t *h,
+		size_t *header_length)
+{
+  *header_length = NEW_HDRLEN + ntohs (h->newhdr.payload_length);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_get_current_header_length (hicn_type_t type, const hicn_protocol_t *h,
+			       size_t *header_length)
+{
+  *header_length = NEW_HDRLEN;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_get_header_length (hicn_type_t type, const hicn_protocol_t *h,
+		       size_t *header_length)
+{
+  size_t child_header_length = 0;
+  int rc = CHILD_OPS (get_header_length, type, h, &child_header_length);
+  if (rc < 0)
+    return rc;
+  *header_length = NEW_HDRLEN + child_header_length;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_get_payload_length (hicn_type_t type, const hicn_protocol_t *h,
+			size_t *payload_length)
+{
+  size_t child_header_length = 0;
+  int rc = CHILD_OPS (get_header_length, type, h, &child_header_length);
+  if (rc < 0)
+    return rc;
+  *payload_length = ntohs (h->newhdr.payload_length) - child_header_length;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_set_payload_length (hicn_type_t type, hicn_protocol_t *h,
+			size_t payload_length)
+{
+  size_t child_header_length = 0;
+  int rc = CHILD_OPS (get_header_length, type, h, &child_header_length);
+  if (rc < 0)
+    return rc;
+  h->newhdr.payload_length =
+    htons ((u_short) (payload_length + child_header_length));
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_get_signature_size (hicn_type_t type, const hicn_protocol_t *h,
+			size_t *signature_size)
+{
+  return CHILD_OPS (get_signature_size, type, h, signature_size);
+}
+
+int
+new_set_signature_size (hicn_type_t type, hicn_protocol_t *h,
+			size_t signature_size)
+{
+  return CHILD_OPS (set_signature_size, type, h, signature_size);
+}
+
+int
+new_set_signature_padding (hicn_type_t type, hicn_protocol_t *h,
+			   size_t padding)
+{
+  return CHILD_OPS (set_signature_padding, type, h, padding);
+}
+
+int
+new_get_signature_padding (hicn_type_t type, const hicn_protocol_t *h,
+			   size_t *padding)
+{
+  return CHILD_OPS (get_signature_padding, type, h, padding);
+}
+
+int
+new_set_signature_timestamp (hicn_type_t type, hicn_protocol_t *h,
+			     uint64_t signature_timestamp)
+{
+  return CHILD_OPS (set_signature_timestamp, type, h, signature_timestamp);
+}
+
+int
+new_get_signature_timestamp (hicn_type_t type, const hicn_protocol_t *h,
+			     uint64_t *signature_timestamp)
+{
+  return CHILD_OPS (get_signature_timestamp, type, h, signature_timestamp);
+}
+
+int
+new_set_validation_algorithm (hicn_type_t type, hicn_protocol_t *h,
+			      uint8_t validation_algorithm)
+{
+  return CHILD_OPS (set_validation_algorithm, type, h, validation_algorithm);
+}
+
+int
+new_get_validation_algorithm (hicn_type_t type, const hicn_protocol_t *h,
+			      uint8_t *validation_algorithm)
+{
+  return CHILD_OPS (get_validation_algorithm, type, h, validation_algorithm);
+}
+
+int
+new_set_key_id (hicn_type_t type, hicn_protocol_t *h, uint8_t *key_id)
+{
+  return CHILD_OPS (set_key_id, type, h, key_id);
+}
+
+int
+new_get_key_id (hicn_type_t type, hicn_protocol_t *h, uint8_t **key_id,
+		uint8_t *key_id_size)
+{
+  return CHILD_OPS (get_key_id, type, h, key_id, key_id_size);
+}
+
+int
+new_get_signature (hicn_type_t type, hicn_protocol_t *h, uint8_t **signature)
+{
+  return CHILD_OPS (get_signature, type, h, signature);
+}
+
+int
+new_get_payload_type (hicn_type_t type, const hicn_protocol_t *h,
+		      hicn_payload_type_t *payload_type)
+{
+  *payload_type = ((h->newhdr.flags & HICN_NEW_FLAG_MAN) == HICN_NEW_FLAG_MAN);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_set_payload_type (hicn_type_t type, hicn_protocol_t *h,
+		      hicn_payload_type_t payload_type)
+{
+  if (payload_type != HPT_DATA && payload_type != HPT_MANIFEST)
+    return HICN_LIB_ERROR_INVALID_PARAMETER;
+
+  if (payload_type)
+    h->newhdr.flags |= HICN_NEW_FLAG_MAN;
+  else
+    h->newhdr.flags &= ~HICN_NEW_FLAG_MAN;
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_is_last_data (hicn_type_t type, const hicn_protocol_t *h, int *is_last)
+{
+  assert (!is_interest (h->newhdr.flags));
+  *is_last = h->newhdr.flags & HICN_NEW_FLAG_LST;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+new_set_last_data (hicn_type_t type, hicn_protocol_t *h)
+{
+  assert (!is_interest (h->newhdr.flags));
+  h->newhdr.flags |= HICN_NEW_FLAG_LST;
+  return HICN_LIB_ERROR_NONE;
+}
+
+DECLARE_HICN_OPS (new);
+
+#pragma GCC diagnostic pop
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/lib/src/protocol/tcp.c b/lib/src/protocol/tcp.c
index cfeac1907..8097cfd12 100644
--- a/lib/src/protocol/tcp.c
+++ b/lib/src/protocol/tcp.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -44,7 +44,20 @@ DECLARE_get_length (tcp, UNEXPECTED);
 DECLARE_get_payload_length (tcp, UNEXPECTED);
 DECLARE_set_payload_length (tcp, UNEXPECTED);
 
-always_inline int
+static inline void
+reset_for_hash (hicn_protocol_t *h)
+{
+  h->tcp.sport = 0;
+  h->tcp.dport = 0;
+  h->tcp.seq_ack = 0;
+  h->tcp.data_offset_and_reserved = 0;
+  h->tcp.flags = 0;
+  h->tcp.window = 0;
+  h->tcp.csum = 0;
+  h->tcp.urg_ptr = 0;
+}
+
+static inline int
 check_tcp_checksum (u16 csum)
 {
   /* As per RFC1624
@@ -92,6 +105,20 @@ tcp_init_packet_header (hicn_type_t type, hicn_protocol_t *h)
 }
 
 int
+tcp_is_interest (hicn_type_t type, const hicn_protocol_t *h, int *is_interest)
+{
+  *is_interest = (h->tcp.flags & HICN_TCP_FLAG_ECE) == 0;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_mark_packet_as_interest (hicn_type_t type, hicn_protocol_t *h)
+{
+  h->tcp.flags &= ~HICN_TCP_FLAG_ECE;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
 tcp_get_interest_name_suffix (hicn_type_t type, const hicn_protocol_t *h,
 			      hicn_name_suffix_t *suffix)
 {
@@ -103,15 +130,12 @@ int
 tcp_set_interest_name_suffix (hicn_type_t type, hicn_protocol_t *h,
 			      const hicn_name_suffix_t *suffix)
 {
-  h->tcp.name_suffix = htonl (*suffix);
+  int rc = tcp_mark_packet_as_interest (type, h);
+  if (rc)
+    return rc;
 
-  return HICN_LIB_ERROR_NONE;
-}
+  h->tcp.name_suffix = htonl (*suffix);
 
-int
-tcp_mark_packet_as_interest (hicn_type_t type, hicn_protocol_t *h)
-{
-  h->tcp.flags &= ~HICN_TCP_FLAG_ECE;
   return HICN_LIB_ERROR_NONE;
 }
 
@@ -125,9 +149,7 @@ tcp_mark_packet_as_data (hicn_type_t type, hicn_protocol_t *h)
 int
 tcp_reset_interest_for_hash (hicn_type_t type, hicn_protocol_t *h)
 {
-  memset (&(h->tcp), 0, 4);
-  memset (&(h->tcp.seq_ack), 0, 12);
-
+  reset_for_hash (h);
   return CHILD_OPS (reset_interest_for_hash, type, h);
 }
 
@@ -143,6 +165,10 @@ int
 tcp_set_data_name_suffix (hicn_type_t type, hicn_protocol_t *h,
 			  const hicn_name_suffix_t *suffix)
 {
+  int rc = tcp_mark_packet_as_data (type, h);
+  if (rc)
+    return rc;
+
   h->tcp.name_suffix = htonl (*suffix);
   return HICN_LIB_ERROR_NONE;
 }
@@ -181,9 +207,7 @@ tcp_update_data_pathlabel (hicn_type_t type, hicn_protocol_t *h,
 int
 tcp_reset_data_for_hash (hicn_type_t type, hicn_protocol_t *h)
 {
-  memset (&(h->tcp), 0, 4);
-  memset (&(h->tcp.seq_ack), 0, 12);
-
+  reset_for_hash (h);
   return CHILD_OPS (reset_data_for_hash, type, h);
 }
 
@@ -279,7 +303,7 @@ tcp_verify_checksums (hicn_type_t type, hicn_protocol_t *h, u16 partial_csum,
 
 int
 tcp_rewrite_interest (hicn_type_t type, hicn_protocol_t *h,
-		      const ip46_address_t *addr_new, ip46_address_t *addr_old)
+		      const ip_address_t *addr_new, ip_address_t *addr_old)
 {
   u16 *tcp_checksum = &(h->tcp.csum);
   int ret = check_tcp_checksum (*tcp_checksum);
@@ -310,7 +334,7 @@ tcp_rewrite_interest (hicn_type_t type, hicn_protocol_t *h,
 
 int
 tcp_rewrite_data (hicn_type_t type, hicn_protocol_t *h,
-		  const ip46_address_t *addr_new, ip46_address_t *addr_old,
+		  const ip_address_t *addr_new, ip_address_t *addr_old,
 		  const hicn_faceid_t face_id, u8 reset_pl)
 {
 
@@ -339,11 +363,11 @@ tcp_rewrite_data (hicn_type_t type, hicn_protocol_t *h,
    * csum = ip_csum_add_even (csum, h->ipv4.saddr.as_u32);
    */
   ip_csum_t csum =
-    ip_csum_sub_even (*tcp_checksum, (ip_csum_t) (addr_old->ip6.as_u64[0]));
+    ip_csum_sub_even (*tcp_checksum, (ip_csum_t) (addr_old->v6.as_u64[0]));
   csum =
-    ip_csum_sub_even (*tcp_checksum, (ip_csum_t) (addr_old->ip6.as_u64[1]));
-  csum = ip_csum_add_even (csum, (ip_csum_t) (addr_new->ip6.as_u64[0]));
-  csum = ip_csum_add_even (csum, (ip_csum_t) (addr_new->ip6.as_u64[1]));
+    ip_csum_sub_even (*tcp_checksum, (ip_csum_t) (addr_old->v6.as_u64[1]));
+  csum = ip_csum_add_even (csum, (ip_csum_t) (addr_new->v6.as_u64[0]));
+  csum = ip_csum_add_even (csum, (ip_csum_t) (addr_new->v6.as_u64[1]));
 
   csum = ip_csum_sub_even (csum, old_pl);
   csum = ip_csum_add_even (csum, h->tcp.seq_ack);
@@ -389,16 +413,17 @@ tcp_set_signature_size (hicn_type_t type, hicn_protocol_t *h,
 }
 
 int
-tcp_set_signature_gap (hicn_type_t type, hicn_protocol_t *h, uint8_t gap)
+tcp_set_signature_padding (hicn_type_t type, hicn_protocol_t *h,
+			   size_t padding)
 {
-  return CHILD_OPS (set_signature_gap, type, h, gap);
+  return CHILD_OPS (set_signature_padding, type, h, padding);
 }
 
 int
-tcp_get_signature_gap (hicn_type_t type, const hicn_protocol_t *h,
-		       uint8_t *gap)
+tcp_get_signature_padding (hicn_type_t type, const hicn_protocol_t *h,
+			   size_t *padding)
 {
-  return CHILD_OPS (get_signature_gap, type, h, gap);
+  return CHILD_OPS (get_signature_padding, type, h, padding);
 }
 
 int
@@ -448,6 +473,43 @@ tcp_get_signature (hicn_type_t type, hicn_protocol_t *h, uint8_t **signature)
   return CHILD_OPS (get_signature, type, h, signature);
 }
 
+int
+tcp_get_payload_type (hicn_type_t type, const hicn_protocol_t *h,
+		      hicn_payload_type_t *payload_type)
+{
+  *payload_type = ((h->tcp.flags & HICN_TCP_FLAG_URG) == HICN_TCP_FLAG_URG);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_set_payload_type (hicn_type_t type, hicn_protocol_t *h,
+		      hicn_payload_type_t payload_type)
+{
+  if (payload_type != HPT_DATA && payload_type != HPT_MANIFEST)
+    return HICN_LIB_ERROR_INVALID_PARAMETER;
+
+  if (payload_type)
+    h->tcp.flags |= HICN_TCP_FLAG_URG;
+  else
+    h->tcp.flags &= ~HICN_TCP_FLAG_URG;
+
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_is_last_data (hicn_type_t type, const hicn_protocol_t *h, int *is_last)
+{
+  *is_last = (h->tcp.flags & HICN_TCP_FLAG_RST) == HICN_TCP_FLAG_RST;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+tcp_set_last_data (hicn_type_t type, hicn_protocol_t *h)
+{
+  h->tcp.flags |= HICN_TCP_FLAG_RST;
+  return HICN_LIB_ERROR_NONE;
+}
+
 DECLARE_HICN_OPS (tcp);
 
 /*
diff --git a/lib/src/protocol/udp.c b/lib/src/protocol/udp.c
new file mode 100644
index 000000000..ee46b8e9d
--- /dev/null
+++ b/lib/src/protocol/udp.c
@@ -0,0 +1,312 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <hicn/common.h>
+#include <hicn/error.h>
+#include <hicn/ops.h>
+
+#include <hicn/protocol/udp.h>
+
+DECLARE_get_interest_locator (udp, UNEXPECTED);
+DECLARE_set_interest_locator (udp, UNEXPECTED);
+DECLARE_get_interest_name (udp, UNEXPECTED);
+DECLARE_set_interest_name (udp, UNEXPECTED);
+DECLARE_get_data_locator (udp, UNEXPECTED);
+DECLARE_set_data_locator (udp, UNEXPECTED);
+DECLARE_get_data_name (udp, UNEXPECTED);
+DECLARE_set_data_name (udp, UNEXPECTED);
+DECLARE_get_payload_length (udp, UNEXPECTED);
+DECLARE_set_payload_length (udp, UNEXPECTED);
+
+int
+udp_init_packet_header (hicn_type_t type, hicn_protocol_t *h)
+{
+  size_t total_header_length;
+  int rc = CHILD_OPS (get_header_length, type, h, &total_header_length);
+  if (rc < 0)
+    return rc;
+
+  /* *INDENT-OFF* */
+  h->udp = (_udp_header_t){ .src_port = 0,
+			    .dst_port = 0,
+			    .length = htons ((u16) total_header_length),
+			    .checksum = 0 };
+  /* *INDENT-ON* */
+  return CHILD_OPS (init_packet_header, type, h);
+}
+
+int
+udp_get_interest_name_suffix (hicn_type_t type, const hicn_protocol_t *h,
+			      hicn_name_suffix_t *suffix)
+{
+  return CHILD_OPS (get_interest_name_suffix, type, h, suffix);
+}
+
+int
+udp_set_interest_name_suffix (hicn_type_t type, hicn_protocol_t *h,
+			      const hicn_name_suffix_t *suffix)
+{
+  return CHILD_OPS (set_interest_name_suffix, type, h, suffix);
+}
+
+int
+udp_is_interest (hicn_type_t type, const hicn_protocol_t *h, int *is_interest)
+{
+  return CHILD_OPS (is_interest, type, h, is_interest);
+}
+
+int
+udp_mark_packet_as_interest (hicn_type_t type, hicn_protocol_t *h)
+{
+  return CHILD_OPS (mark_packet_as_interest, type, h);
+}
+
+int
+udp_mark_packet_as_data (hicn_type_t type, hicn_protocol_t *h)
+{
+  return CHILD_OPS (mark_packet_as_data, type, h);
+}
+
+int
+udp_reset_interest_for_hash (hicn_type_t type, hicn_protocol_t *h)
+{
+  return CHILD_OPS (reset_interest_for_hash, type, h);
+}
+
+int
+udp_get_data_name_suffix (hicn_type_t type, const hicn_protocol_t *h,
+			  hicn_name_suffix_t *suffix)
+{
+  return CHILD_OPS (get_data_name_suffix, type, h, suffix);
+}
+
+int
+udp_set_data_name_suffix (hicn_type_t type, hicn_protocol_t *h,
+			  const hicn_name_suffix_t *suffix)
+{
+  return CHILD_OPS (set_data_name_suffix, type, h, suffix);
+}
+
+int
+udp_get_data_pathlabel (hicn_type_t type, const hicn_protocol_t *h,
+			u32 *pathlabel)
+{
+  return CHILD_OPS (get_data_pathlabel, type, h, pathlabel);
+}
+
+int
+udp_set_data_pathlabel (hicn_type_t type, hicn_protocol_t *h,
+			const u32 pathlabel)
+{
+  return CHILD_OPS (set_data_pathlabel, type, h, pathlabel);
+}
+
+int
+udp_update_data_pathlabel (hicn_type_t type, hicn_protocol_t *h,
+			   const hicn_faceid_t face_id)
+{
+  return CHILD_OPS (update_data_pathlabel, type, h, face_id);
+}
+
+int
+udp_reset_data_for_hash (hicn_type_t type, hicn_protocol_t *h)
+{
+  return CHILD_OPS (reset_data_for_hash, type, h);
+}
+
+int
+udp_get_lifetime (hicn_type_t type, const hicn_protocol_t *h,
+		  hicn_lifetime_t *lifetime)
+{
+  return CHILD_OPS (get_lifetime, type, h, lifetime);
+}
+
+int
+udp_set_lifetime (hicn_type_t type, hicn_protocol_t *h,
+		  const hicn_lifetime_t lifetime)
+{
+  return CHILD_OPS (set_lifetime, type, h, lifetime);
+}
+
+int
+udp_update_checksums (hicn_type_t type, hicn_protocol_t *h, u16 partial_csum,
+		      size_t payload_length)
+{
+  return CHILD_OPS (update_checksums, type, h, partial_csum, payload_length);
+}
+
+int
+udp_verify_checksums (hicn_type_t type, hicn_protocol_t *h, u16 partial_csum,
+		      size_t payload_length)
+{
+  return CHILD_OPS (verify_checksums, type, h, partial_csum, payload_length);
+}
+
+int
+udp_rewrite_interest (hicn_type_t type, hicn_protocol_t *h,
+		      const ip_address_t *addr_new, ip_address_t *addr_old)
+{
+  return CHILD_OPS (rewrite_interest, type, h, addr_new, addr_old);
+}
+
+int
+udp_rewrite_data (hicn_type_t type, hicn_protocol_t *h,
+		  const ip_address_t *addr_new, ip_address_t *addr_old,
+		  const hicn_faceid_t face_id, u8 reset_pl)
+{
+  return CHILD_OPS (rewrite_data, type, h, addr_new, addr_old, face_id,
+		    reset_pl);
+}
+
+int
+udp_get_length (hicn_type_t type, const hicn_protocol_t *h,
+		size_t *header_length)
+{
+  *header_length = IPV6_HDRLEN + ntohs (h->ipv6.len);
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+udp_get_current_header_length (hicn_type_t type, const hicn_protocol_t *h,
+			       size_t *header_length)
+{
+  *header_length = UDP_HDRLEN;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+udp_get_header_length (hicn_type_t type, const hicn_protocol_t *h,
+		       size_t *header_length)
+{
+  size_t child_header_length = 0;
+  int rc = CHILD_OPS (get_header_length, type, h, &child_header_length);
+  if (rc < 0)
+    return rc;
+  *header_length = UDP_HDRLEN + child_header_length;
+  return HICN_LIB_ERROR_NONE;
+}
+
+int
+udp_get_payload_type (hicn_type_t type, const hicn_protocol_t *h,
+		      hicn_payload_type_t *payload_type)
+{
+  return CHILD_OPS (get_payload_type, type, h, payload_type);
+}
+
+int
+udp_set_payload_type (hicn_type_t type, hicn_protocol_t *h,
+		      hicn_payload_type_t payload_type)
+{
+  return CHILD_OPS (set_payload_type, type, h, payload_type);
+}
+
+int
+udp_get_signature_size (hicn_type_t type, const hicn_protocol_t *h,
+			size_t *signature_size)
+{
+  return CHILD_OPS (get_signature_size, type, h, signature_size);
+}
+
+int
+udp_set_signature_size (hicn_type_t type, hicn_protocol_t *h,
+			size_t signature_size)
+{
+  return CHILD_OPS (set_signature_size, type, h, signature_size);
+}
+
+int
+udp_set_signature_padding (hicn_type_t type, hicn_protocol_t *h,
+			   size_t padding)
+{
+  return CHILD_OPS (set_signature_padding, type, h, padding);
+}
+
+int
+udp_get_signature_padding (hicn_type_t type, const hicn_protocol_t *h,
+			   size_t *padding)
+{
+  return CHILD_OPS (get_signature_padding, type, h, padding);
+}
+
+int
+udp_set_signature_timestamp (hicn_type_t type, hicn_protocol_t *h,
+			     uint64_t signature_timestamp)
+{
+  return CHILD_OPS (set_signature_timestamp, type, h, signature_timestamp);
+}
+
+int
+udp_get_signature_timestamp (hicn_type_t type, const hicn_protocol_t *h,
+			     uint64_t *signature_timestamp)
+{
+  return CHILD_OPS (get_signature_timestamp, type, h, signature_timestamp);
+}
+
+int
+udp_set_validation_algorithm (hicn_type_t type, hicn_protocol_t *h,
+			      uint8_t validation_algorithm)
+{
+  return CHILD_OPS (set_validation_algorithm, type, h, validation_algorithm);
+}
+
+int
+udp_get_validation_algorithm (hicn_type_t type, const hicn_protocol_t *h,
+			      uint8_t *validation_algorithm)
+{
+  return CHILD_OPS (get_validation_algorithm, type, h, validation_algorithm);
+}
+
+int
+udp_set_key_id (hicn_type_t type, hicn_protocol_t *h, uint8_t *key_id)
+{
+  return CHILD_OPS (set_key_id, type, h, key_id);
+}
+
+int
+udp_get_key_id (hicn_type_t type, hicn_protocol_t *h, uint8_t **key_id,
+		uint8_t *key_id_size)
+{
+  return CHILD_OPS (get_key_id, type, h, key_id, key_id_size);
+}
+
+int
+udp_get_signature (hicn_type_t type, hicn_protocol_t *h, uint8_t **signature)
+{
+  return CHILD_OPS (get_signature, type, h, signature);
+}
+
+int
+udp_is_last_data (hicn_type_t type, const hicn_protocol_t *h, int *is_last)
+{
+  return CHILD_OPS (is_last_data, type, h, is_last);
+}
+
+int
+udp_set_last_data (hicn_type_t type, hicn_protocol_t *h)
+{
+  return CHILD_OPS (set_last_data, type, h);
+}
+
+DECLARE_HICN_OPS (udp);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/hicn-light/src/hicn/config/controlCache.h b/lib/src/strategy.c
index c2f2402f1..3b797664a 100644
--- a/hicn-light/src/hicn/config/controlCache.h
+++ b/lib/src/strategy.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,10 +13,10 @@
  * limitations under the License.
  */
 
-#ifndef controlCache_h
-#define controlCache_h
+#include <hicn/strategy.h>
 
-#include <hicn/config/controlState.h>
-CommandOps *controlCache_Create(ControlState *state);
-CommandOps *controlCache_HelpCreate(ControlState *state);
-#endif  // controlCache_h
+const char *strategy_str[] = {
+#define _(x) [STRATEGY_TYPE_##x] = #x,
+  foreach_strategy_type
+#undef _
+};
\ No newline at end of file
diff --git a/lib/src/test/CMakeLists.txt b/lib/src/test/CMakeLists.txt
new file mode 100644
index 000000000..3e3c025c7
--- /dev/null
+++ b/lib/src/test/CMakeLists.txt
@@ -0,0 +1,47 @@
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+find_package(Threads REQUIRED)
+
+##############################################################
+# Test sources
+##############################################################
+list(APPEND TESTS_SRC
+  main.cc
+  test_name.cc
+  test_new_header.cc
+  test_udp_header.cc
+  test_validation.cc
+)
+
+##############################################################
+# Build single unit test executable and add it to test list
+##############################################################
+build_executable(lib_tests
+  NO_INSTALL
+  SOURCES ${TESTS_SRC}
+  LINK_LIBRARIES
+    PRIVATE ${LIBHICN_STATIC}
+    PRIVATE ${GTEST_LIBRARIES}
+    PRIVATE ${CMAKE_THREAD_LIBS_INIT}
+  INCLUDE_DIRS
+    PRIVATE ${Libhicn_INCLUDE_DIRS}
+    PRIVATE ${GTEST_INCLUDE_DIRS}
+  DEPENDS gtest ${LIBHICN_SHARED}
+  COMPONENT ${LIBHICN_COMPONENT}
+  DEFINITIONS ${COMPILER_DEFINITIONS}
+  COMPILE_OPTIONS ${DEFAULT_COMPILER_OPTIONS}
+  LINK_FLAGS ${LINK_FLAGS}
+)
+
+add_test_internal(lib_tests)
diff --git a/lib/src/test/main.cc b/lib/src/test/main.cc
new file mode 100644
index 000000000..042fcd6c0
--- /dev/null
+++ b/lib/src/test/main.cc
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+int
+main (int argc, char **argv)
+{
+  ::testing::InitGoogleTest (&argc, argv);
+  return RUN_ALL_TESTS ();
+}
diff --git a/lib/src/test/test_name.cc b/lib/src/test/test_name.cc
new file mode 100644
index 000000000..207725adb
--- /dev/null
+++ b/lib/src/test/test_name.cc
@@ -0,0 +1,339 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+extern "C"
+{
+#include <hicn/name.h>
+#include <hicn/common.h>
+#include <hicn/error.h>
+}
+
+class NameTest : public ::testing::Test
+{
+protected:
+  const char *ipv6_prefix = "b001::abcd:1234:abcd:1234";
+  const char *ipv4_prefix = "12.13.14.15";
+  const uint32_t suffix = 12345;
+
+  NameTest () : name_{}, name4_{}, name6_{}
+  {
+    int rc = inet_pton (AF_INET6, ipv6_prefix, &ipv6_prefix_bytes.v6);
+    EXPECT_EQ (rc, 1);
+
+    rc = inet_pton (AF_INET, ipv4_prefix, &ipv4_prefix_bytes.v4);
+    EXPECT_EQ (rc, 1);
+
+    rc = hicn_name_create (ipv4_prefix, suffix, &name4_);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+    rc = hicn_name_create (ipv6_prefix, suffix, &name6_);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  }
+
+  virtual ~NameTest () {}
+
+  void
+  nameHashTest (const char *prefix)
+  {
+    // Create 2 names
+    uint32_t suffix = 13579;
+    hicn_name_t name_a, name_b;
+    int rc = hicn_name_create (prefix, suffix, &name_a);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+    rc = hicn_name_create (prefix, suffix, &name_b);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+    // The hash should be equal, with and without considering the suffix
+    uint32_t hash_a, hash_b;
+    rc = hicn_name_hash (&name_a, &hash_a, 1);
+    EXPECT_EQ (rc, 0);
+    rc = hicn_name_hash (&name_b, &hash_b, 1);
+    EXPECT_EQ (rc, 0);
+    EXPECT_EQ (hash_a, hash_b);
+
+    rc = hicn_name_hash (&name_a, &hash_a, 0);
+    EXPECT_EQ (rc, 0);
+    rc = hicn_name_hash (&name_b, &hash_b, 0);
+    EXPECT_EQ (rc, 0);
+    EXPECT_EQ (hash_a, hash_b);
+
+    // Now let's change the suffix
+    rc = hicn_name_set_seq_number (&name_a, 97531);
+    // They should result equal if we do not consider the suffix
+    rc = hicn_name_hash (&name_a, &hash_a, 0);
+    EXPECT_EQ (rc, 0);
+    rc = hicn_name_hash (&name_b, &hash_b, 0);
+    EXPECT_EQ (rc, 0);
+    EXPECT_EQ (hash_a, hash_b);
+
+    // And different if we consider it
+    rc = hicn_name_hash (&name_a, &hash_a, 1);
+    EXPECT_EQ (rc, 0);
+    rc = hicn_name_hash (&name_b, &hash_b, 1);
+    EXPECT_EQ (rc, 0);
+    EXPECT_NE (hash_a, hash_b);
+  }
+
+  void
+  nameCopyTest (const char *prefix)
+  {
+    uint32_t suffix = 13579;
+    hicn_name_t name_a, name_b;
+    int rc = hicn_name_create (prefix, suffix, &name_a);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+    rc = hicn_name_copy (&name_b, &name_a);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+    rc = hicn_name_compare (&name_a, &name_b, 1);
+    EXPECT_EQ (rc, 0);
+  }
+
+  void
+  nameCompareTest (const char *prefix)
+  {
+    // Create 2 names
+    uint32_t suffix = 13579;
+    hicn_name_t name_a, name_b;
+    int rc = hicn_name_create (prefix, suffix, &name_a);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+    rc = hicn_name_create (prefix, suffix, &name_b);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+    // They should be equal, with and without considering the suffix
+    rc = hicn_name_compare (&name_a, &name_b, 1);
+    EXPECT_EQ (rc, 0);
+    rc = hicn_name_compare (&name_a, &name_b, 0);
+    EXPECT_EQ (rc, 0);
+
+    // Now let's change the suffix
+    rc = hicn_name_set_seq_number (&name_a, 97531);
+    // They should result equal if we do not consider the suffix
+    rc = hicn_name_compare (&name_a, &name_b, 0);
+    EXPECT_EQ (rc, 0);
+    // And different if we consider the suffix
+    rc = hicn_name_compare (&name_a, &name_b, 1);
+    EXPECT_NE (rc, 0);
+  }
+
+  void
+  nameFromIpPrefixTest (const ip_prefix_t &ip_prefix)
+  {
+    uint32_t suffix = 54321;
+    hicn_name_t name;
+    int rc = hicn_name_create_from_ip_prefix (&ip_prefix, suffix, &name);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+    rc = memcmp (ip_prefix.address.v6.as_u8, name.prefix.v6.as_u8,
+		 sizeof (name.prefix.v6));
+    EXPECT_EQ (rc, 0);
+    EXPECT_EQ (suffix, name.suffix);
+  }
+
+  void
+  nameToIpPrefixTest (const char *prefix)
+  {
+    uint32_t suffix = 54321;
+    hicn_name_t name;
+    int rc = hicn_name_create (prefix, suffix, &name);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+    // Get family
+    int family;
+    rc = hicn_name_get_family (&name, &family);
+
+    ip_prefix_t ip_prefix;
+    rc = hicn_name_to_ip_prefix (&name, &ip_prefix);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+    EXPECT_EQ (ip_prefix.family, family);
+    rc = ip_address_cmp (&ip_prefix.address, &name.prefix, AF_INET6);
+    EXPECT_EQ (rc, 0);
+  }
+
+  hicn_name_t name_, name4_, name6_;
+  ip_address_t ipv6_prefix_bytes, ipv4_prefix_bytes;
+};
+
+/**
+ * Name Initialization
+ */
+TEST_F (NameTest, NameInitialization)
+{
+  EXPECT_TRUE (_is_unspec (&name_));
+  uint32_t suffix = 12345;
+
+  // Initialize ipv6 name
+  hicn_name_t name6;
+  int rc = hicn_name_create (ipv6_prefix, suffix, &name6);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Check name is correctly created
+  rc = ip_address_cmp (&name6.prefix, &ipv6_prefix_bytes, AF_INET6);
+  EXPECT_EQ (rc, 0);
+  EXPECT_EQ (name6.suffix, suffix);
+
+  // Initialize ipv4 name
+  hicn_name_t name4;
+  rc = hicn_name_create (ipv4_prefix, suffix, &name4);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Check name is correctly created
+  rc = ip_address_cmp (&name4.prefix, &ipv4_prefix_bytes, AF_INET);
+  EXPECT_EQ (name4.prefix.pad[0], 0UL);
+  EXPECT_EQ (name4.prefix.pad[1], 0UL);
+  EXPECT_EQ (name4.prefix.pad[2], 0UL);
+  EXPECT_EQ (rc, 0);
+  EXPECT_EQ (name4.suffix, suffix);
+
+  // Try also to reuse previously initialized name
+  rc = hicn_name_create (ipv4_prefix, suffix, &name6);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Check name is correctly created
+  rc = ip_address_cmp (&name6.prefix, &ipv4_prefix_bytes, AF_INET);
+  EXPECT_EQ (name6.prefix.pad[0], 0UL);
+  EXPECT_EQ (name6.prefix.pad[1], 0UL);
+  EXPECT_EQ (name6.prefix.pad[2], 0UL);
+  EXPECT_EQ (rc, 0);
+  EXPECT_EQ (name6.suffix, suffix);
+}
+
+/**
+ * Name from ip prefix
+ */
+TEST_F (NameTest, NameFromIpPrefix6)
+{
+  ip_prefix_t ip_prefix = { .family = AF_INET6, .address = {}, .len = 64 };
+
+  ip_prefix.address.v6.as_u64[0] = ipv6_prefix_bytes.v6.as_u64[0];
+  ip_prefix.address.v6.as_u64[1] = ipv6_prefix_bytes.v6.as_u64[1];
+
+  nameFromIpPrefixTest (ip_prefix);
+}
+
+TEST_F (NameTest, NameFromIpPrefix4)
+{
+  ip_prefix_t ip_prefix = { .family = AF_INET, .address = {}, .len = 64 };
+  ip_prefix.address.v4.as_u32 = ipv4_prefix_bytes.v4.as_u32;
+  ip_prefix.address.pad[0] = 0;
+  ip_prefix.address.pad[1] = 0;
+  ip_prefix.address.pad[2] = 0;
+  nameFromIpPrefixTest (ip_prefix);
+}
+
+TEST_F (NameTest, NameCompare6) { nameCompareTest (ipv6_prefix); }
+
+TEST_F (NameTest, NameCompare4) { nameCompareTest (ipv4_prefix); }
+
+TEST_F (NameTest, NameHash6) { nameHashTest (ipv6_prefix); }
+
+TEST_F (NameTest, NameHash4) { nameHashTest (ipv4_prefix); }
+
+TEST_F (NameTest, NameEmpty)
+{
+  int rc = hicn_name_empty (&name_);
+  EXPECT_EQ (rc, 1);
+
+  name_.prefix.v6 = ipv6_prefix_bytes.v6;
+  rc = hicn_name_empty (&name_);
+  EXPECT_EQ (rc, 0);
+}
+
+TEST_F (NameTest, NameCopy6) { nameCopyTest (ipv6_prefix); }
+
+TEST_F (NameTest, NameCopy4) { nameCopyTest (ipv4_prefix); }
+
+TEST_F (NameTest, NameCopyToDestination)
+{
+  ip4_address_t dst4;
+  ip6_address_t dst6;
+
+  // Copy names to destination
+  int rc = hicn_name_copy_prefix_to_destination (dst4.as_u8, &name4_);
+  EXPECT_EQ (rc, 0);
+  rc = hicn_name_copy_prefix_to_destination (dst6.as_u8, &name6_);
+  EXPECT_EQ (rc, 0);
+
+  // Check copy succeeded
+  EXPECT_TRUE (dst4.as_u32 == name4_.prefix.v4.as_u32);
+  EXPECT_TRUE (dst6.as_u64[0] == name6_.prefix.v6.as_u64[0]);
+  EXPECT_TRUE (dst6.as_u64[1] == name6_.prefix.v6.as_u64[1]);
+}
+
+TEST_F (NameTest, SetGetSuffix)
+{
+  uint32_t suffix2 = 55555, suffix_ret;
+
+  // Check if suffix is correct
+  int rc = hicn_name_get_seq_number (&name6_, &suffix_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (suffix, suffix_ret);
+
+  // Set new suffix
+  rc = hicn_name_set_seq_number (&name6_, suffix2);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Check suffix was set
+  rc = hicn_name_get_seq_number (&name6_, &suffix_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (suffix2, suffix_ret);
+}
+
+TEST_F (NameTest, NameToSockAddr)
+{
+  struct sockaddr_in saddr4;
+  struct sockaddr_in6 saddr6;
+
+  int rc =
+    hicn_name_to_sockaddr_address (&name6_, (struct sockaddr *) (&saddr6));
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  rc = memcmp (name6_.prefix.v6.as_u8, saddr6.sin6_addr.s6_addr,
+	       sizeof (name6_.prefix.v6));
+  EXPECT_EQ (rc, 0);
+
+  rc = hicn_name_to_sockaddr_address (&name4_, (struct sockaddr *) (&saddr4));
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (name4_.prefix.v4.as_u32, saddr4.sin_addr.s_addr);
+}
+
+TEST_F (NameTest, NameToIpPrefix)
+{
+  nameToIpPrefixTest (ipv4_prefix);
+  nameToIpPrefixTest (ipv6_prefix);
+}
+
+TEST_F (NameTest, NameNToP)
+{
+  char dst[128];
+
+  // V6
+  int rc = hicn_name_ntop (&name6_, dst, 128);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Build expected name
+  std::stringstream expected6;
+  expected6 << ipv6_prefix << "|" << suffix;
+
+  rc = strcmp (dst, expected6.str ().c_str ());
+  EXPECT_EQ (rc, 0);
+
+  // V4
+  rc = hicn_name_ntop (&name4_, dst, 128);
+  std::stringstream expected4;
+  expected4 << ipv4_prefix << "|" << suffix;
+
+  rc = strcmp (dst, expected4.str ().c_str ());
+  EXPECT_EQ (rc, 0);
+}
diff --git a/lib/src/test/test_new_header.cc b/lib/src/test/test_new_header.cc
new file mode 100644
index 000000000..33c9e13c9
--- /dev/null
+++ b/lib/src/test/test_new_header.cc
@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+extern "C"
+{
+#include <hicn/name.h>
+#include <hicn/common.h>
+#include <hicn/error.h>
+#include <hicn/protocol/new.h>
+#include <hicn/protocol/ah.h>
+#include <hicn/header.h>
+#include <hicn/compat.h>
+}
+
+class NewHeaderTest : public ::testing::Test
+{
+protected:
+  const char *ipv6_prefix = "b001::abcd:1234:abcd:1234";
+  const char *ipv4_prefix = "12.13.14.15";
+  const uint32_t suffix = 12345;
+
+  NewHeaderTest (size_t hdr_size, hicn_format_t format)
+      : buffer_ (new uint8_t[hdr_size]), header_ ((hicn_header_t *) (buffer_)),
+	format_ (format), name_{}, name4_{}, name6_{}
+  {
+    int rc = inet_pton (AF_INET6, ipv6_prefix, &ipv6_prefix_bytes.v6);
+    EXPECT_EQ (rc, 1);
+
+    rc = inet_pton (AF_INET, ipv4_prefix, &ipv4_prefix_bytes.v4);
+    EXPECT_EQ (rc, 1);
+
+    rc = hicn_name_create (ipv4_prefix, suffix, &name4_);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+    rc = hicn_name_create (ipv6_prefix, suffix, &name6_);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  }
+
+  NewHeaderTest () : NewHeaderTest (NEW_HDRLEN, HF_NEW) {}
+
+  virtual ~NewHeaderTest () { delete[] buffer_; }
+
+  void
+  checkCommon (const _new_header_t *new_hdr)
+  {
+    // Initialize header
+    int rc = hicn_packet_init_header (format_, header_);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+    // Check fields
+    EXPECT_EQ (new_hdr->prefix.v6.as_u64[0], 0UL);
+    EXPECT_EQ (new_hdr->prefix.v6.as_u64[1], 0UL);
+    EXPECT_EQ (new_hdr->suffix, 0UL);
+    EXPECT_EQ (new_hdr->lifetime, 0UL);
+    EXPECT_EQ (new_hdr->path_label, 0UL);
+    EXPECT_EQ (new_hdr->payload_length, 0UL);
+    EXPECT_EQ (_get_new_header_version (new_hdr), 0x9);
+  }
+
+  virtual void
+  SetUp () override
+  {
+    auto new_hdr = &header_->protocol.newhdr;
+    checkCommon (new_hdr);
+    EXPECT_EQ (new_hdr->flags, 0);
+  }
+
+  uint8_t *buffer_;
+  hicn_header_t *header_;
+  hicn_format_t format_;
+  hicn_name_t name_, name4_, name6_;
+  ip_address_t ipv6_prefix_bytes, ipv4_prefix_bytes;
+};
+
+class NewHeaderAHTest : public NewHeaderTest
+{
+protected:
+  NewHeaderAHTest () : NewHeaderTest (NEW_HDRLEN + AH_HDRLEN, HF_NEW_AH) {}
+
+  virtual void
+  SetUp () override
+  {
+    auto new_hdr = &header_->protocol.newhdr;
+    checkCommon (new_hdr);
+    EXPECT_NE (new_hdr->flags, 0);
+  }
+};
+
+/**
+ * Header Initialization
+ */
+TEST_F (NewHeaderTest, GetFormat)
+{
+  // Get format from existing packet
+  hicn_format_t format;
+  int rc = hicn_packet_get_format (header_, &format);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Check it corresponds to the new header format
+  EXPECT_EQ (format, HF_NEW);
+}
+
+TEST_F (NewHeaderAHTest, GetFormat)
+{
+  // Get format from existing packet
+  hicn_format_t format;
+  int rc = hicn_packet_get_format (header_, &format);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Check it corresponds to the new header format
+  EXPECT_EQ (format, HF_NEW_AH);
+}
+
+/**
+ * @brief Checksum functions are not required, but we keep them for
+ * compatibility.
+ */
+TEST_F (NewHeaderTest, Checksum)
+{
+  // Get format from existing packet
+  int rc = hicn_packet_compute_checksum (format_, header_);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_compute_header_checksum (format_, header_, 0);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_check_integrity_no_payload (format_, header_, 0);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+}
+
+TEST_F (NewHeaderAHTest, Checksum)
+{
+  // Get format from existing packet
+  int rc = hicn_packet_compute_checksum (format_, header_);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_compute_header_checksum (format_, header_, 0);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_check_integrity_no_payload (format_, header_, 0);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+}
+
+TEST_F (NewHeaderTest, GetHeaderLengthFromFormat)
+{
+  // Get format from existing packet
+  std::size_t hdr_len;
+  int rc = hicn_packet_get_header_length_from_format (format_, &hdr_len);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (hdr_len, NEW_HDRLEN);
+}
+
+TEST_F (NewHeaderAHTest, GetHeaderLengthFromFormat)
+{
+  // Get format from existing packet
+  std::size_t hdr_len;
+  int rc = hicn_packet_get_header_length_from_format (format_, &hdr_len);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (hdr_len, NEW_HDRLEN + AH_HDRLEN);
+}
+
+TEST_F (NewHeaderTest, GetHeaderLength)
+{
+  // Get format from existing packet
+  std::size_t hdr_len;
+  int rc = hicn_packet_get_header_length (format_, header_, &hdr_len);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (hdr_len, NEW_HDRLEN);
+}
+
+TEST_F (NewHeaderAHTest, GetHeaderLength)
+{
+  // Get format from existing packet
+  std::size_t hdr_len;
+  int rc = hicn_packet_get_header_length (format_, header_, &hdr_len);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (hdr_len, NEW_HDRLEN + AH_HDRLEN);
+}
+
+TEST_F (NewHeaderTest, SetGetPayloadLength)
+{
+  // Get format from existing packet
+  std::size_t payload_len = 1000, payload_len_ret;
+  int rc = hicn_packet_set_payload_length (format_, header_, payload_len);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  rc = hicn_packet_get_payload_length (format_, header_, &payload_len_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (payload_len, payload_len_ret);
+}
+
+TEST_F (NewHeaderAHTest, SetGetPayloadLength)
+{
+  // Get format from existing packet
+  std::size_t payload_len = 1000, payload_len_ret;
+  int rc = hicn_packet_set_payload_length (format_, header_, payload_len);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  rc = hicn_packet_get_payload_length (format_, header_, &payload_len_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (payload_len, payload_len_ret);
+}
+
+TEST_F (NewHeaderTest, SetGetName)
+{
+  // Get v6 name and set it to new_header
+  hicn_name_t name_ret;
+  int rc = hicn_packet_set_name (format_, header_, &name6_, 1);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_get_name (format_, header_, &name_ret, 1);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_name_compare (&name6_, &name_ret, 1);
+  EXPECT_EQ (rc, 0);
+}
+
+TEST_F (NewHeaderTest, SetGetLocator)
+{
+  // This function does nothing but it is set for compatibility
+  ip_address_t locator;
+  memset (&locator, 0, sizeof (locator));
+  locator.v6.as_u8[15] = 1;
+  int rc = hicn_packet_set_interest (format_, header_);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_set_locator (format_, header_, &locator, 1);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_get_locator (format_, header_, &locator, 1);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+}
+
+TEST_F (NewHeaderTest, SetGetSignatureSize)
+{
+  // No AH, so we should get an error
+  // FixMe no error raised here
+  size_t signature_size = 128;
+  int rc = hicn_packet_set_signature_size (format_, header_, signature_size);
+  (void) rc;
+  // EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Same for hicn_packet_get_signature_size
+  rc = hicn_packet_get_signature_size (format_, header_, &signature_size);
+  // EXPECT_NE (rc, HICN_LIB_ERROR_NONE);
+}
+
+TEST_F (NewHeaderAHTest, SetGetSignatureSize)
+{
+  // No AH, so we should get an error
+  size_t signature_size = 128, signature_size_ret;
+  int rc = hicn_packet_set_signature_size (format_, header_, signature_size);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Same for hicn_packet_get_signature_size
+  rc = hicn_packet_get_signature_size (format_, header_, &signature_size_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  EXPECT_EQ (signature_size, signature_size_ret);
+}
+
+TEST_F (NewHeaderTest, IsInterestIsData)
+{
+  // Mark packet as interest
+  int rc = hicn_packet_set_interest (format_, header_);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  int ret;
+  rc = hicn_packet_is_interest (format_, header_, &ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (ret, 1);
+
+  // Mark packet as data
+  rc = hicn_packet_set_data (format_, header_);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_is_interest (format_, header_, &ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (ret, 0);
+}
+
+TEST_F (NewHeaderTest, SetGetLifetime)
+{
+  // Lifetime
+  u32 lifetime = 20000, lifetime_ret; // 20 sec.
+  int rc = hicn_packet_set_lifetime (format_, header_, lifetime);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_get_lifetime (format_, header_, &lifetime_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  EXPECT_EQ (lifetime, lifetime_ret);
+}
+
+TEST_F (NewHeaderAHTest, SetGetLifetime)
+{
+  // Lifetime
+  u32 lifetime = 20000, lifetime_ret; // 20 sec.
+  int rc = hicn_packet_set_lifetime (format_, header_, lifetime);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_get_lifetime (format_, header_, &lifetime_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  EXPECT_EQ (lifetime, lifetime_ret);
+}
+
+TEST_F (NewHeaderTest, SetGetPayloadType)
+{
+  // Lifetime
+  hicn_payload_type_t payload_type = HPT_MANIFEST, payload_type_ret;
+  int rc = hicn_packet_set_payload_type (format_, header_, payload_type);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_get_payload_type (format_, header_, &payload_type_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  EXPECT_EQ (payload_type, payload_type_ret);
+
+  payload_type = HPT_DATA;
+
+  rc = hicn_packet_set_payload_type (format_, header_, payload_type);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_get_payload_type (format_, header_, &payload_type_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  EXPECT_EQ (payload_type, payload_type_ret);
+}
diff --git a/lib/src/test/test_udp_header.cc b/lib/src/test/test_udp_header.cc
new file mode 100644
index 000000000..5d9f4d1eb
--- /dev/null
+++ b/lib/src/test/test_udp_header.cc
@@ -0,0 +1,355 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+extern "C"
+{
+#include <hicn/name.h>
+#include <hicn/common.h>
+#include <hicn/error.h>
+#include <hicn/protocol/new.h>
+#include <hicn/protocol/ah.h>
+#include <hicn/header.h>
+#include <hicn/compat.h>
+}
+
+class UdpHeaderTest : public ::testing::Test
+{
+protected:
+  const char *ipv6_prefix = "b001::abcd:1234:abcd:1234";
+  const char *ipv4_prefix = "12.13.14.15";
+  const uint32_t suffix = 12345;
+
+  UdpHeaderTest (size_t hdr_size, hicn_format_t format)
+      : buffer_ (new uint8_t[hdr_size]), header_ ((hicn_header_t *) (buffer_)),
+	format_ (format), name_{}, name4_{}, name6_{}
+  {
+    int rc = inet_pton (AF_INET6, ipv6_prefix, &ipv6_prefix_bytes.v6);
+    EXPECT_EQ (rc, 1);
+
+    rc = inet_pton (AF_INET, ipv4_prefix, &ipv4_prefix_bytes.v4);
+    EXPECT_EQ (rc, 1);
+
+    rc = hicn_name_create (ipv4_prefix, suffix, &name4_);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+    rc = hicn_name_create (ipv6_prefix, suffix, &name6_);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  }
+
+  UdpHeaderTest ()
+      : UdpHeaderTest (NEW_HDRLEN + UDP_HDRLEN + IPV6_HDRLEN, HF_INET6_UDP)
+  {
+  }
+
+  virtual ~UdpHeaderTest () { delete[] buffer_; }
+
+  void
+  checkCommon (const _ipv6_header_t *ip6_hdr)
+  {
+    // Initialize header
+    int rc = hicn_packet_init_header (format_, header_);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+    // Check fields
+    EXPECT_EQ (ip6_hdr->saddr.as_u64[0], 0UL);
+    EXPECT_EQ (ip6_hdr->saddr.as_u64[1], 0UL);
+    EXPECT_EQ (ip6_hdr->daddr.as_u64[0], 0UL);
+    EXPECT_EQ (ip6_hdr->daddr.as_u64[1], 0UL);
+    EXPECT_EQ (ip6_hdr->nxt, IPPROTO_UDP);
+
+    _udp_header_t *udp_hdr = (_udp_header_t *) (ip6_hdr + 1);
+    EXPECT_EQ (udp_hdr->src_port, 0UL);
+    EXPECT_EQ (udp_hdr->dst_port, 0UL);
+    EXPECT_EQ (udp_hdr->checksum, 0UL);
+    // EXPECT_EQ (ntohs (udp_hdr->length), NEW_HDRLEN + AH_HDRLEN);
+
+    _new_header_t *new_hdr = (_new_header_t *) (udp_hdr + 1);
+    EXPECT_EQ (new_hdr->prefix.v6.as_u64[0], 0UL);
+    EXPECT_EQ (new_hdr->prefix.v6.as_u64[1], 0UL);
+    EXPECT_EQ (new_hdr->suffix, 0UL);
+    EXPECT_EQ (new_hdr->lifetime, 0UL);
+    EXPECT_EQ (new_hdr->path_label, 0UL);
+    EXPECT_EQ (new_hdr->payload_length, 0UL);
+    EXPECT_EQ (_get_new_header_version (new_hdr), 0x9);
+  }
+
+  virtual void
+  SetUp () override
+  {
+    auto ip6_hdr = &header_->protocol.ipv6;
+    checkCommon (ip6_hdr);
+  }
+
+  uint8_t *buffer_;
+  hicn_header_t *header_;
+  hicn_format_t format_;
+  hicn_name_t name_, name4_, name6_;
+  ip_address_t ipv6_prefix_bytes, ipv4_prefix_bytes;
+};
+
+class UdpHeaderAHTest : public UdpHeaderTest
+{
+protected:
+  UdpHeaderAHTest ()
+      : UdpHeaderTest (AH_HDRLEN + NEW_HDRLEN + UDP_HDRLEN + IPV6_HDRLEN,
+		       HF_INET6_UDP_AH)
+  {
+  }
+};
+
+/**
+ * Header Initialization
+ */
+TEST_F (UdpHeaderTest, GetFormat)
+{
+  // Get format from existing packet
+  hicn_format_t format;
+  int rc = hicn_packet_get_format (header_, &format);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Check it corresponds to the new header format
+  EXPECT_EQ (format, HF_INET6_UDP);
+}
+
+TEST_F (UdpHeaderAHTest, GetFormat)
+{
+  // Get format from existing packet
+  hicn_format_t format;
+  int rc = hicn_packet_get_format (header_, &format);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Check it corresponds to the new header format
+  EXPECT_EQ (format, HF_INET6_UDP_AH);
+}
+
+// /**
+//  * @brief Checksum functions are not required, but we keep them for
+//  * compatibility.
+//  */
+// TEST_F (NewHeaderTest, Checksum)
+// {
+//   // Get format from existing packet
+//   int rc = hicn_packet_compute_checksum (format_, header_);
+//   EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+//   rc = hicn_packet_compute_header_checksum (format_, header_, 0);
+//   EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+//   rc = hicn_packet_check_integrity_no_payload (format_, header_, 0);
+//   EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+// }
+
+// TEST_F (NewHeaderAHTest, Checksum)
+// {
+//   // Get format from existing packet
+//   int rc = hicn_packet_compute_checksum (format_, header_);
+//   EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+//   rc = hicn_packet_compute_header_checksum (format_, header_, 0);
+//   EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+//   rc = hicn_packet_check_integrity_no_payload (format_, header_, 0);
+//   EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+// }
+
+TEST_F (UdpHeaderTest, GetHeaderLengthFromFormat)
+{
+  // Get format from existing packet
+  std::size_t hdr_len;
+  int rc = hicn_packet_get_header_length_from_format (format_, &hdr_len);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (hdr_len, UDP_HDRLEN + IPV6_HDRLEN + NEW_HDRLEN);
+}
+
+TEST_F (UdpHeaderAHTest, GetHeaderLengthFromFormat)
+{
+  // Get format from existing packet
+  std::size_t hdr_len;
+  int rc = hicn_packet_get_header_length_from_format (format_, &hdr_len);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (hdr_len, UDP_HDRLEN + IPV6_HDRLEN + NEW_HDRLEN + AH_HDRLEN);
+}
+
+TEST_F (UdpHeaderTest, GetHeaderLength)
+{
+  // Get format from existing packet
+  std::size_t hdr_len;
+  int rc = hicn_packet_get_header_length (format_, header_, &hdr_len);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (hdr_len, UDP_HDRLEN + IPV6_HDRLEN + NEW_HDRLEN);
+}
+
+TEST_F (UdpHeaderAHTest, GetHeaderLength)
+{
+  // Get format from existing packet
+  std::size_t hdr_len;
+  int rc = hicn_packet_get_header_length (format_, header_, &hdr_len);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (hdr_len, UDP_HDRLEN + IPV6_HDRLEN + NEW_HDRLEN + AH_HDRLEN);
+}
+
+TEST_F (UdpHeaderTest, SetGetPayloadLength)
+{
+  // Get format from existing packet
+  std::size_t payload_len = 1000, payload_len_ret;
+  int rc = hicn_packet_set_payload_length (format_, header_, payload_len);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  rc = hicn_packet_get_payload_length (format_, header_, &payload_len_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (payload_len, payload_len_ret);
+}
+
+TEST_F (UdpHeaderAHTest, SetGetPayloadLength)
+{
+  // Get format from existing packet
+  std::size_t payload_len = 1000, payload_len_ret;
+  int rc = hicn_packet_set_payload_length (format_, header_, payload_len);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  rc = hicn_packet_get_payload_length (format_, header_, &payload_len_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (payload_len, payload_len_ret);
+}
+
+TEST_F (UdpHeaderTest, SetGetName)
+{
+  // Get v6 name and set it to new_header
+  hicn_name_t name_ret;
+
+  int rc = hicn_packet_set_interest (format_, header_);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_set_name (format_, header_, &name6_, 1);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_get_name (format_, header_, &name_ret, 1);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_name_compare (&name6_, &name_ret, 1);
+  EXPECT_EQ (rc, 0);
+}
+
+TEST_F (UdpHeaderTest, SetGetLocator)
+{
+  // This function does nothing but it is set for compatibility
+  ip_address_t locator;
+  memset (&locator, 0, sizeof (locator));
+  locator.v6.as_u8[15] = 1;
+  int rc = hicn_packet_set_interest (format_, header_);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_set_locator (format_, header_, &locator, 1);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_get_locator (format_, header_, &locator, 1);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+}
+
+TEST_F (UdpHeaderTest, SetGetSignatureSize)
+{
+  // No AH, so we should get an error
+  // FixMe no error raised here
+  size_t signature_size = 128;
+  int rc = hicn_packet_set_signature_size (format_, header_, signature_size);
+  (void) rc;
+  // EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Same for hicn_packet_get_signature_size
+  rc = hicn_packet_get_signature_size (format_, header_, &signature_size);
+  // EXPECT_NE (rc, HICN_LIB_ERROR_NONE);
+}
+
+TEST_F (UdpHeaderAHTest, SetGetSignatureSize)
+{
+  // No AH, so we should get an error
+  size_t signature_size = 128, signature_size_ret;
+  int rc = hicn_packet_set_signature_size (format_, header_, signature_size);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Same for hicn_packet_get_signature_size
+  rc = hicn_packet_get_signature_size (format_, header_, &signature_size_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  EXPECT_EQ (signature_size, signature_size_ret);
+}
+
+TEST_F (UdpHeaderTest, IsInterestIsData)
+{
+  // Mark packet as interest
+  int rc = hicn_packet_set_interest (format_, header_);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  int ret;
+  rc = hicn_packet_is_interest (format_, header_, &ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (ret, 1);
+
+  // Mark packet as data
+  rc = hicn_packet_set_data (format_, header_);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_is_interest (format_, header_, &ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (ret, 0);
+}
+
+TEST_F (UdpHeaderTest, SetGetLifetime)
+{
+  // Lifetime
+  u32 lifetime = 20000, lifetime_ret; // 20 sec.
+  int rc = hicn_packet_set_lifetime (format_, header_, lifetime);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_get_lifetime (format_, header_, &lifetime_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  EXPECT_EQ (lifetime, lifetime_ret);
+}
+
+TEST_F (UdpHeaderAHTest, SetGetLifetime)
+{
+  // Lifetime
+  u32 lifetime = 20000, lifetime_ret; // 20 sec.
+  int rc = hicn_packet_set_lifetime (format_, header_, lifetime);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_get_lifetime (format_, header_, &lifetime_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  EXPECT_EQ (lifetime, lifetime_ret);
+}
+
+TEST_F (UdpHeaderTest, SetGetPayloadType)
+{
+  // Lifetime
+  hicn_payload_type_t payload_type = HPT_MANIFEST, payload_type_ret;
+  int rc = hicn_packet_set_payload_type (format_, header_, payload_type);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_get_payload_type (format_, header_, &payload_type_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  EXPECT_EQ (payload_type, payload_type_ret);
+
+  payload_type = HPT_DATA;
+
+  rc = hicn_packet_set_payload_type (format_, header_, payload_type);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  rc = hicn_packet_get_payload_type (format_, header_, &payload_type_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  EXPECT_EQ (payload_type, payload_type_ret);
+}
diff --git a/lib/src/test/test_validation.cc b/lib/src/test/test_validation.cc
new file mode 100644
index 000000000..091f26d65
--- /dev/null
+++ b/lib/src/test/test_validation.cc
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2022 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+extern "C"
+{
+#include <hicn/validation.h>
+}
+
+static constexpr int BUF_SIZE = 10;
+
+class ValidationTest : public ::testing::Test
+{
+};
+
+TEST_F (ValidationTest, SymbolicName)
+{
+  const char symbolic_name_correct[BUF_SIZE] = "conn0";
+  const char symbolic_name_empty[BUF_SIZE] = "";
+  const char symbolic_name_wrong[BUF_SIZE] = "1conn0";
+
+  EXPECT_TRUE (is_symbolic_name (symbolic_name_correct, BUF_SIZE));
+  EXPECT_FALSE (is_symbolic_name (symbolic_name_empty, BUF_SIZE));
+  EXPECT_FALSE (is_symbolic_name (symbolic_name_wrong, BUF_SIZE));
+}
+
+TEST_F (ValidationTest, Number)
+{
+  const char number_correct[BUF_SIZE] = "123";
+  const char number_empty[BUF_SIZE] = "";
+  const char number_wrong[BUF_SIZE] = "a123";
+  const char number_wrong_2[BUF_SIZE] = "12T3";
+  const char number_wrong_3[BUF_SIZE] = "a";
+  const char number_wrong_negative[BUF_SIZE] = "-123";
+
+  EXPECT_TRUE (is_number (number_correct, BUF_SIZE));
+  EXPECT_FALSE (is_number (number_empty, BUF_SIZE));
+  EXPECT_FALSE (is_number (number_wrong, BUF_SIZE));
+  EXPECT_FALSE (is_number (number_wrong_2, BUF_SIZE));
+  EXPECT_FALSE (is_number (number_wrong_3, BUF_SIZE));
+  EXPECT_FALSE (is_number (number_wrong_negative, BUF_SIZE));
+}
\ No newline at end of file
diff --git a/lib/src/util/ip_address.c b/lib/src/util/ip_address.c
index 49916547d..412baddcf 100644
--- a/lib/src/util/ip_address.c
+++ b/lib/src/util/ip_address.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -20,44 +20,51 @@
 
 #include <hicn/util/ip_address.h>
 #include <hicn/util/log.h>
+#include <hicn/util/sstrncpy.h>
 
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 #ifdef __ANDROID__
-#define SWAP(x) bswap_32(x)
+#define SWAP(x) bswap_32 (x)
 #else
-#define SWAP(x) __bswap_constant_32(x)
+#define SWAP(x) __bswap_constant_32 (x)
 #endif
 #else
 #define SWAP(x) x
 #endif
 
-
 /* No htonl() with const */
 const ip_address_t IPV4_LOOPBACK = {
-    .v4.as_inaddr.s_addr = SWAP(INADDR_LOOPBACK),
+  .v4.as_inaddr.s_addr = SWAP (INADDR_LOOPBACK),
 };
 
-const ip_address_t IPV6_LOOPBACK ={
-    .v6.as_in6addr = IN6ADDR_LOOPBACK_INIT,
+const ip_address_t IPV6_LOOPBACK = {
+  .v6.as_in6addr = IN6ADDR_LOOPBACK_INIT,
 };
 
-const ip_address_t IPV4_ANY =  {
-    .v4.as_inaddr.s_addr = INADDR_ANY,
+const ip_address_t IPV4_ANY = {
+  .v4.as_inaddr.s_addr = INADDR_ANY,
 };
 
 const ip_address_t IPV6_ANY = {
-    .v6.as_in6addr = IN6ADDR_ANY_INIT,
+  .v6.as_in6addr = IN6ADDR_ANY_INIT,
 };
 
-const ip_address_t IP_ADDRESS_EMPTY = {
-    .v6.as_u64 = { 0 },
+const ip4_address_t IP4_ADDRESS_EMPTY = {
+  .as_u32 = 0,
+};
+
+const ip6_address_t IP6_ADDRESS_EMPTY = {
+  .as_u64 = { 0, 0 },
 };
 
+const ip_address_t IP_ADDRESS_EMPTY = {
+  .v6.as_u64 = { 0, 0 },
+};
 
 /* IP address */
 
 int
-ip_address_get_family (const char * ip_address)
+ip_address_get_family (const char *ip_address)
 {
   struct addrinfo hint, *res = NULL;
   int rc;
@@ -81,24 +88,26 @@ int
 ip_address_len (int family)
 {
   return (family == AF_INET6) ? IPV6_ADDR_LEN :
-    (family == AF_INET) ? IPV4_ADDR_LEN : 0;
+	 (family == AF_INET)  ? IPV4_ADDR_LEN :
+				      0;
 }
 
 int
-ip_address_ntop (const ip_address_t * ip_address, char *dst, const size_t len,
-        int family)
+ip_address_ntop (const ip_address_t *ip_address, char *dst, const size_t len,
+		 int family)
 {
-  const char * s;
-  switch(family) {
+  const char *s;
+  switch (family)
+    {
     case AF_INET:
-      s = inet_ntop (AF_INET, ip_address->v4.buffer, dst, (socklen_t)len);
+      s = inet_ntop (AF_INET, ip_address->v4.buffer, dst, (socklen_t) len);
       break;
     case AF_INET6:
-      s = inet_ntop (AF_INET6, ip_address->v6.buffer, dst, (socklen_t)len);
+      s = inet_ntop (AF_INET6, ip_address->v6.buffer, dst, (socklen_t) len);
       break;
     default:
       return -1;
-  }
+    }
   return (s ? 1 : -1);
 }
 
@@ -106,14 +115,15 @@ ip_address_ntop (const ip_address_t * ip_address, char *dst, const size_t len,
  * Parse ip addresses in presentation format
  */
 int
-ip_address_pton (const char *ip_address_str, ip_address_t * ip_address)
+ip_address_pton (const char *ip_address_str, ip_address_t *ip_address)
 {
   int pton_fd;
   int family;
 
   family = ip_address_get_family (ip_address_str);
 
-  switch (family) {
+  switch (family)
+    {
     case AF_INET:
       ip_address->pad[0] = 0;
       ip_address->pad[1] = 0;
@@ -136,32 +146,34 @@ ip_address_pton (const char *ip_address_str, ip_address_t * ip_address)
 }
 
 int
-ip_address_snprintf(char * s, size_t size, const ip_address_t * ip_address, int family)
+ip_address_snprintf (char *s, size_t size, const ip_address_t *ip_address,
+		     int family)
 {
 
-    const char * rc;
-    switch(family) {
-        case AF_INET:
-            if (size < INET_ADDRSTRLEN)
-                return -1;
-            rc = inet_ntop (AF_INET, ip_address->v4.buffer, s, INET_ADDRSTRLEN);
-            break;
-        case AF_INET6:
-            if (size < INET6_ADDRSTRLEN)
-                return -1;
-            rc = inet_ntop (AF_INET6, ip_address->v6.buffer, s, INET6_ADDRSTRLEN);
-            break;
-        default:
-            return -1;
+  const char *rc;
+  switch (family)
+    {
+    case AF_INET:
+      if (size < INET_ADDRSTRLEN)
+	return -1;
+      rc = inet_ntop (AF_INET, ip_address->v4.buffer, s, INET_ADDRSTRLEN);
+      break;
+    case AF_INET6:
+      if (size < INET6_ADDRSTRLEN)
+	return -1;
+      rc = inet_ntop (AF_INET6, ip_address->v6.buffer, s, INET6_ADDRSTRLEN);
+      break;
+    default:
+      return -1;
     }
-    if (!rc)
-        return -1;
-    return (int)strlen(s);
+  if (!rc)
+    return -1;
+  return (int) strnlen_s (s, MAXSZ_IP_ADDRESS);
 }
 
 int
-ip_address_to_sockaddr(const ip_address_t * ip_address,
-        struct sockaddr *sa, int family)
+ip_address_to_sockaddr (const ip_address_t *ip_address, struct sockaddr *sa,
+			int family)
 {
   struct sockaddr_in6 *tmp6 = (struct sockaddr_in6 *) sa;
   struct sockaddr_in *tmp4 = (struct sockaddr_in *) sa;
@@ -187,33 +199,30 @@ ip_address_to_sockaddr(const ip_address_t * ip_address,
 }
 
 int
-ip_address_cmp(const ip_address_t * ip1, const ip_address_t * ip2, int family)
+ip_address_cmp (const ip_address_t *ip1, const ip_address_t *ip2, int family)
 {
-    switch(family) {
-        case AF_INET:
-            return memcmp(&ip1->v4, &ip2->v4, sizeof(ip1->v4));
-            break;
-        case AF_INET6:
-            return memcmp(&ip1->v6, &ip2->v6, sizeof(ip1->v6));
-            break;
-        default:
-            return memcmp(ip1, ip2, sizeof(ip_address_t));
+  switch (family)
+    {
+    case AF_INET:
+      return memcmp (ip1->v4.buffer, ip2->v4.buffer, sizeof (ip1->v4));
+    case AF_INET6:
+    default:
+      return memcmp (ip1->v6.buffer, ip2->v6.buffer, sizeof (ip1->v6));
     }
 }
 
 int
-ip_address_empty(const ip_address_t * ip)
+ip_address_empty (const ip_address_t *ip)
 {
-    return (memcmp(ip, &IP_ADDRESS_EMPTY, sizeof(IP_ADDRESS_EMPTY)) == 0);
+  return (memcmp (ip->v6.buffer, &IP_ADDRESS_EMPTY.v6.buffer,
+		  sizeof (IP_ADDRESS_EMPTY)) == 0);
 }
 
-
-
 /* Prefix */
 
 /* Parse IP Prefixes in presentation format (in bits, separated by a slash) */
 int
-ip_prefix_pton (const char *ip_address_str, ip_prefix_t * ip_prefix)
+ip_prefix_pton (const char *ip_address_str, ip_prefix_t *ip_prefix)
 {
   int pton_fd;
   char *p;
@@ -221,29 +230,32 @@ ip_prefix_pton (const char *ip_address_str, ip_prefix_t * ip_prefix)
   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 = (u8)strtoul (p + 1, &eptr, 10);
-    *p = 0;
-  }
+  if (!p)
+    {
+      ip_prefix->len = ~0; // until we get the ip address family
+    }
+  else
+    {
+      ip_prefix->len = (u8) 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 == (u8)~0)
-          ip_prefix->len = IPV6_ADDR_LEN_BITS;
+      if (ip_prefix->len == (u8) ~0)
+	ip_prefix->len = IPV6_ADDR_LEN_BITS;
       if (ip_prefix->len > IPV6_ADDR_LEN_BITS)
-    goto ERR;
+	goto ERR;
       pton_fd = inet_pton (AF_INET6, addr, &ip_prefix->address.v6.buffer);
       break;
     case AF_INET:
-      if (ip_prefix->len == (u8)~0)
-          ip_prefix->len = IPV4_ADDR_LEN_BITS;
+      if (ip_prefix->len == (u8) ~0)
+	ip_prefix->len = IPV4_ADDR_LEN_BITS;
       if (ip_prefix->len > IPV4_ADDR_LEN_BITS)
-    goto ERR;
+	goto ERR;
       pton_fd = inet_pton (AF_INET, addr, &ip_prefix->address.v4.buffer);
       break;
     default:
@@ -253,9 +265,9 @@ ip_prefix_pton (const char *ip_address_str, ip_prefix_t * ip_prefix)
   //   0 = not in presentation format
   // < 0 = other error (use perror)
   if (pton_fd <= 0)
-      goto ERR;
+    goto ERR;
 
-  free(addr);
+  free (addr);
   return 1;
 ERR:
   free (addr);
@@ -263,129 +275,143 @@ ERR:
 }
 
 int
-ip_prefix_ntop_short(const ip_prefix_t * ip_prefix, char *dst, size_t size)
+ip_prefix_ntop_short (const ip_prefix_t *ip_prefix, char *dst, size_t size)
 {
   char ip_s[MAXSZ_IP_ADDRESS];
-  const char * s;
-  switch(ip_prefix->family) {
+  const char *s;
+  switch (ip_prefix->family)
+    {
     case AF_INET:
-      s = inet_ntop (AF_INET, ip_prefix->address.v4.buffer, ip_s, MAXSZ_IP_ADDRESS);
+      s = inet_ntop (AF_INET, ip_prefix->address.v4.buffer, ip_s,
+		     MAXSZ_IP_ADDRESS);
       break;
     case AF_INET6:
-      s = inet_ntop (AF_INET6, ip_prefix->address.v6.buffer, ip_s, MAXSZ_IP_ADDRESS);
+      s = inet_ntop (AF_INET6, ip_prefix->address.v6.buffer, ip_s,
+		     MAXSZ_IP_ADDRESS);
       break;
     default:
       return -1;
-  }
+    }
   if (!s)
-      return -1;
-  int rc = snprintf(dst, size, "%s", ip_s);
+    return -1;
+  int rc = snprintf (dst, size, "%s", ip_s);
   if (rc >= size)
-      return (int)size;
+    return (int) size;
   return rc;
 }
 
 int
-ip_prefix_ntop(const ip_prefix_t * ip_prefix, char *dst, size_t size)
+ip_prefix_ntop (const ip_prefix_t *ip_prefix, char *dst, size_t size)
 {
   char ip_s[MAXSZ_IP_ADDRESS];
-  const char * s;
-  switch(ip_prefix->family) {
+  const char *s;
+  switch (ip_prefix->family)
+    {
     case AF_INET:
-      s = inet_ntop (AF_INET, ip_prefix->address.v4.buffer, ip_s, MAXSZ_IP_ADDRESS);
+      s = inet_ntop (AF_INET, ip_prefix->address.v4.buffer, ip_s,
+		     MAXSZ_IP_ADDRESS);
       break;
     case AF_INET6:
-      s = inet_ntop (AF_INET6, ip_prefix->address.v6.buffer, ip_s, MAXSZ_IP_ADDRESS);
+      s = inet_ntop (AF_INET6, ip_prefix->address.v6.buffer, ip_s,
+		     MAXSZ_IP_ADDRESS);
       break;
     default:
       return -1;
-  }
+    }
   if (!s)
-      return -1;
-  int rc = snprintf(dst, size, "%s/%d", ip_s, ip_prefix->len);
+    return -1;
+  int rc = snprintf (dst, size, "%s/%d", ip_s, ip_prefix->len);
   if (rc >= size)
-      return (int)size;
+    return (int) size;
   return rc;
 }
 
 int
-ip_prefix_len (const ip_prefix_t * prefix)
+ip_prefix_snprintf (char *s, size_t size, const ip_prefix_t *prefix)
+{
+  return ip_prefix_ntop (prefix, s, size);
+}
+
+int
+ip_prefix_len (const ip_prefix_t *prefix)
 {
-    return prefix->len; // ip_address_len(&prefix->address, prefix->family);
+  return prefix->len; // ip_address_len(&prefix->address, prefix->family);
 }
 
 const u8 *
-ip_address_get_buffer(const ip_address_t * ip_address, int family)
+ip_address_get_buffer (const ip_address_t *ip_address, int family)
 {
-  switch(family) {
+  switch (family)
+    {
     case AF_INET:
       return ip_address->v4.buffer;
     case AF_INET6:
       return ip_address->v6.buffer;
     default:
       return NULL;
-  }
+    }
 }
 
 bool
-ip_prefix_empty (const ip_prefix_t * prefix)
+ip_prefix_empty (const ip_prefix_t *prefix)
 {
   return prefix->len == 0;
 }
 
 int
-ip_prefix_to_sockaddr(const ip_prefix_t * prefix,
-        struct sockaddr *sa)
+ip_prefix_to_sockaddr (const ip_prefix_t *prefix, struct sockaddr *sa)
 {
-    // XXX assert len == ip_address_len
-    return ip_address_to_sockaddr(&prefix->address, sa, prefix->family);
+  // XXX assert len == ip_address_len
+  return ip_address_to_sockaddr (&prefix->address, sa, prefix->family);
 }
 
 int
-ip_prefix_cmp(const ip_prefix_t * prefix1, const ip_prefix_t * prefix2)
+ip_prefix_cmp (const ip_prefix_t *prefix1, const ip_prefix_t *prefix2)
 {
-    if (prefix1->family < prefix2->family)
-        return -1;
-    else if (prefix1->family > prefix2->family)
-        return 1;
+  if (prefix1->family < prefix2->family)
+    return -1;
+  else if (prefix1->family > prefix2->family)
+    return 1;
 
-    if (prefix1->len < prefix2->len)
-        return -1;
-    else if (prefix1->len > prefix2->len)
-        return 1;
+  if (prefix1->len < prefix2->len)
+    return -1;
+  else if (prefix1->len > prefix2->len)
+    return 1;
 
-    return ip_address_cmp(&prefix1->address, &prefix2->address, prefix1->family);
+  return ip_address_cmp (&prefix1->address, &prefix2->address,
+			 prefix1->family);
 }
 
 /* URL */
 
 #define MAXSZ_PROTO_ 8 /* inetX:// */
-#define MAXSZ_PROTO MAXSZ_PROTO_ + NULLTERM
+#define MAXSZ_PROTO  MAXSZ_PROTO_ + NULLTERM
 
 #define MAXSZ_URL4_ MAXSZ_PROTO_ + MAXSZ_IP4_ADDRESS_ + MAXSZ_PORT_
 #define MAXSZ_URL6_ MAXSZ_PROTO_ + MAXSZ_IP6_ADDRESS_ + MAXSZ_PORT_
-#define MAXSZ_URL_ MAXSZ_URL6_
-#define MAXSZ_URL4 MAXSZ_URL4_ + NULLTERM
-#define MAXSZ_URL6 MAXSZ_URL6_ + NULLTERM
-#define MAXSZ_URL MAXSZ_URL_ + NULLTERM
+#define MAXSZ_URL_  MAXSZ_URL6_
+#define MAXSZ_URL4  MAXSZ_URL4_ + NULLTERM
+#define MAXSZ_URL6  MAXSZ_URL6_ + NULLTERM
+#define MAXSZ_URL   MAXSZ_URL_ + NULLTERM
 
 int
-url_snprintf(char * s, size_t size, int family,
-        const ip_address_t * ip_address, u16 port)
+url_snprintf (char *s, size_t size, int family, const ip_address_t *ip_address,
+	      u16 port)
 {
-    char ip_address_s[MAXSZ_IP_ADDRESS];
-    int rc;
+  char ip_address_s[MAXSZ_IP_ADDRESS];
+  int rc;
 
-    /* Other address are currently not supported */
-    if (!IS_VALID_FAMILY(family))
-        return -1;
+  /* Other address are currently not supported */
+  if (!IS_VALID_FAMILY (family))
+    return -1;
 
-    rc = ip_address_snprintf(ip_address_s, MAXSZ_IP_ADDRESS, ip_address, family);
-    if (rc >= MAXSZ_IP_ADDRESS)
-        WARN("[url_snprintf] Unexpected ip_address truncation");
-    if (rc < 0)
-        return rc;
+  rc =
+    ip_address_snprintf (ip_address_s, MAXSZ_IP_ADDRESS, ip_address, family);
+  if (rc >= MAXSZ_IP_ADDRESS)
+    WARN ("[url_snprintf] Unexpected ip_address truncation");
+  if (rc < 0)
+    return rc;
 
-    return snprintf(s, size, "inet%c://%s:%d", (family == AF_INET) ? '4' : '6',
-            ip_address_s, port);
+  return snprintf (s, size, "inet%c://%s:%d", (family == AF_INET) ? '4' : '6',
+		   ip_address_s, port);
 }
diff --git a/lib/src/util/log.c b/lib/src/util/log.c
index c1fc999ad..975762603 100644
--- a/lib/src/util/log.c
+++ b/lib/src/util/log.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -18,6 +18,7 @@
 #include <stdarg.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <strings.h>
 
 #ifdef __ANDROID__
 #include <android/log.h>
@@ -25,154 +26,177 @@
 
 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)
-
+#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)
+static char *
+timestamp (void)
 {
-	time_t tv;
-	struct tm *tm;
+  time_t tv;
+  struct tm *tm;
 
-	time(&tv);
-	tm = localtime(&tv);
+  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;
+  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)
-{  
+void
+_log_va (int level, const char *fmt, va_list ap)
+{
 
 #if 0
 	if (!conf.log_system)
 		return;
 #endif
 
-	char *prefix;
+  char *prefix;
 
 #ifdef __ANDROID__
-	int prio = -1;
-	if (level > log_conf.log_level)
-		return;
-
-	switch (level) {
-		case LOG_FATAL:
-			prio = ANDROID_LOG_FATAL;
-			prefix = "FATAL: ";
-			break;
-		case LOG_ERROR:
-			prio = ANDROID_LOG_ERROR;
-			prefix = "ERROR: ";
-			break;
-		case LOG_WARN:
-			prio = ANDROID_LOG_WARN;
-			prefix = "WARNING: ";
-			break;
-		case LOG_INFO:
-			prio = ANDROID_LOG_INFO;
-			prefix = "";
-			break;
-		case LOG_DEBUG:
-			prio  = ANDROID_LOG_DEBUG;
-			prefix = "DEBUG: ";
-			break;
-		case LOG_TRACE:
-			prio = ANDROID_LOG_DEBUG;
-			prefix = "TRACE: ";
-			break;
-		default:
-			prio = ANDROID_LOG_INFO;
-			prefix = "";
-			break;
-	}
-
-	if (log_conf.log_file) {
-		FILE *f = log_conf.log_file;
-		fprintf(f, "%s %s", timestamp(), prefix);
-		vfprintf(f, fmt, ap);
-		fprintf(f, "\n");
-	} else {
-		__android_log_vprint(ANDROID_LOG_INFO, "HICN FACEMGR", fmt, ap);
-	}
+  int prio = -1;
+  if (level > log_conf.log_level)
+    return;
+
+  switch (level)
+    {
+    case LOG_FATAL:
+      prio = ANDROID_LOG_FATAL;
+      prefix = "FATAL: ";
+      break;
+    case LOG_ERROR:
+      prio = ANDROID_LOG_ERROR;
+      prefix = "ERROR: ";
+      break;
+    case LOG_WARN:
+      prio = ANDROID_LOG_WARN;
+      prefix = "WARNING: ";
+      break;
+    case LOG_INFO:
+      prio = ANDROID_LOG_INFO;
+      prefix = "";
+      break;
+    case LOG_DEBUG:
+      prio = ANDROID_LOG_DEBUG;
+      prefix = "DEBUG: ";
+      break;
+    case LOG_TRACE:
+      prio = ANDROID_LOG_DEBUG;
+      prefix = "TRACE: ";
+      break;
+    default:
+      prio = ANDROID_LOG_INFO;
+      prefix = "";
+      break;
+    }
+
+  if (log_conf.log_file)
+    {
+      FILE *f = log_conf.log_file;
+      fprintf (f, "%s %s", timestamp (), prefix);
+      vfprintf (f, fmt, ap);
+      fprintf (f, "\n");
+    }
+  else
+    {
+      __android_log_vprint (ANDROID_LOG_INFO, "HICN FACEMGR", fmt, ap);
+    }
 
 #else
 
-	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;
-	}
-	FILE *f = log_conf.log_file ? log_conf.log_file : stdout;
-	fprintf(f, "%s %s", timestamp(), prefix);
-	vfprintf(f, fmt, ap);
-	fprintf(f, "\n");
+  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;
+    }
+  FILE *f = log_conf.log_file ? log_conf.log_file : stdout;
+  fprintf (f, "%s %s", timestamp (), prefix);
+  vfprintf (f, fmt, ap);
+  fprintf (f, "\n");
 #ifdef DEBUG
-	fflush(f);
+  fflush (f);
 #endif
 #endif
 }
 
-void _log(int level, const char *fmt, ...)
+void
+_log (int level, const char *fmt, ...)
 {
-	va_list ap;
+  va_list ap;
 
-	va_start(ap, fmt);
-	_log_va(level, fmt, ap);
-	va_end(ap);
+  va_start (ap, fmt);
+  _log_va (level, fmt, ap);
+  va_end (ap);
 }
 
 #ifdef HAVE_BACKTRACE
 #include <execinfo.h>
 
-void print_trace(void)
+void
+print_trace (void)
 {
-	void *array[32];
-	size_t size;
+  void *array[32];
+  size_t size;
 
-	size = backtrace(array, 32);
-	fflush(conf.log_file);
-	backtrace_symbols_fd(array, size, fileno(conf.log_file));
+  size = backtrace (array, 32);
+  fflush (conf.log_file);
+  backtrace_symbols_fd (array, size, fileno (conf.log_file));
 }
 #endif
 
-void fatal(char *fmt, ...)
+void
+fatal (char *fmt, ...)
 {
-	va_list ap;
+  va_list ap;
 
-	va_start(ap, fmt);
-	_log_va(LOG_FATAL, fmt, ap);
-	va_end(ap);
+  va_start (ap, fmt);
+  _log_va (LOG_FATAL, fmt, ap);
+  va_end (ap);
 
 #ifdef HAVE_BACKTRACE
-	print_trace();
+  print_trace ();
 #endif
 
-	exit(200);
+  exit (200);
 }
+
+const char *loglevel_str[] = { "fatal", "error", "warn",
+			       "info",	"debug", "trace" };
+
+int
+loglevel_from_str (const char *loglevel)
+{
+  for (int i = 0; i <= LOG_TRACE; i++)
+    {
+      if (strcasecmp (loglevel, loglevel_str[i]) == 0)
+	return i;
+    }
+  return -1;
+}
\ No newline at end of file
diff --git a/lib/src/util/windows/dlfcn.c b/lib/src/util/windows/dlfcn.c
index c8173cdb0..5606074a0 100644
--- a/lib/src/util/windows/dlfcn.c
+++ b/lib/src/util/windows/dlfcn.c
@@ -1,4 +1,4 @@
-/* dlfcn.c */ 
+/* dlfcn.c */
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -6,60 +6,68 @@
 #include <string.h>
 #include <windows.h>
 
-static struct {
-    long lasterror;
-    const char *err_rutin;
-} var = {
-    0,
-    NULL
-};
+static struct
+{
+  long lasterror;
+  const char *err_rutin;
+} var = { 0, NULL };
 
-void *dlopen (const char *filename, int flags)
+void *
+dlopen (const char *filename, int flags)
 {
-    HINSTANCE hInst;
+  HINSTANCE hInst;
 
-    hInst= LoadLibrary (filename);
-    if (hInst==NULL) {
-        var.lasterror = GetLastError ();
-        var.err_rutin = "dlopen";
+  hInst = LoadLibrary (filename);
+  if (hInst == NULL)
+    {
+      var.lasterror = GetLastError ();
+      var.err_rutin = "dlopen";
     }
-    return hInst;
+  return hInst;
 }
 
-int dlclose (void *handle)
+int
+dlclose (void *handle)
 {
-    BOOL ok;
-    int rc= 0;
+  BOOL ok;
+  int rc = 0;
 
-    ok= FreeLibrary ((HINSTANCE)handle);
-    if (! ok) {
-        var.lasterror = GetLastError ();
-        var.err_rutin = "dlclose";
-        rc= -1;
+  ok = FreeLibrary ((HINSTANCE) handle);
+  if (!ok)
+    {
+      var.lasterror = GetLastError ();
+      var.err_rutin = "dlclose";
+      rc = -1;
     }
-    return rc;
+  return rc;
 }
 
-void *dlsym (void *handle, const char *name)
+void *
+dlsym (void *handle, const char *name)
 {
-    FARPROC fp;
+  FARPROC fp;
 
-    fp= GetProcAddress ((HINSTANCE)handle, name);
-    if (!fp) {
-        var.lasterror = GetLastError ();
-        var.err_rutin = "dlsym";
+  fp = GetProcAddress ((HINSTANCE) handle, name);
+  if (!fp)
+    {
+      var.lasterror = GetLastError ();
+      var.err_rutin = "dlsym";
     }
-    return (void *)(intptr_t)fp;
+  return (void *) (intptr_t) fp;
 }
 
-const char *dlerror (void)
+const char *
+dlerror (void)
 {
-static char errstr [88];
+  static char errstr[88];
 
-    if (var.lasterror) {
-        sprintf (errstr, "%s error #%ld", var.err_rutin, var.lasterror);
-        return errstr;
-    } else {
-        return NULL;
+  if (var.lasterror)
+    {
+      snprintf (errstr, 88, "%s error #%ld", var.err_rutin, var.lasterror);
+      return errstr;
+    }
+  else
+    {
+      return NULL;
     }
 }
\ No newline at end of file
diff --git a/libtransport/.clang-format b/libtransport/.clang-format
index 513da4d69..ae46ce82d 100644
--- a/libtransport/.clang-format
+++ b/libtransport/.clang-format
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/libtransport/CMakeLists.txt b/libtransport/CMakeLists.txt
index a5009f353..62c0c0788 100644
--- a/libtransport/CMakeLists.txt
+++ b/libtransport/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2021 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,29 +11,36 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+##############################################################
+# Project and cmake version
+##############################################################
 # CMake 3.11 required to use FetchContent
 cmake_minimum_required(VERSION 3.11 FATAL_ERROR)
-
 project(libtransport)
 
+
+##############################################################
+# Cmake modules
+##############################################################
 set(CMAKE_MODULE_PATH
   ${CMAKE_MODULE_PATH}
-  "${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Modules"
-  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
+  ${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Modules
 )
+include("${CMAKE_CURRENT_SOURCE_DIR}/../versions.cmake")
 
-include(DefaultConfiguration)
-include(BuildMacros)
 
-if (NOT CMAKE_BUILD_TYPE)
-  message(STATUS "${PROJECT_NAME}: No build type selected, default to Release")
-  set(CMAKE_BUILD_TYPE "Release")
-endif ()
+##############################################################
+# C/CXX Standard
+##############################################################
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_C_STANDARD 11)
 
-set(TRANSPORT_ROOT_PATH "src")
 
+##############################################################
+# Libs and Bins names
+##############################################################
 set(LIBTRANSPORT hicntransport)
-set(LIBTRANSPORT_COMPONENT libhicntransport)
+set(LIBTRANSPORT_COMPONENT lib${LIBTRANSPORT})
 
 if ((BUILD_HICNPLUGIN OR BUILD_MEMIF_CONNECTOR) AND "${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
   set(__vpp__ 1)
@@ -42,19 +49,32 @@ endif ()
 set(LIBTRANSPORT ${LIBTRANSPORT} CACHE INTERNAL "" FORCE)
 set(LIBTRANSPORT_SHARED ${LIBTRANSPORT}.shared CACHE INTERNAL "" FORCE)
 set(LIBTRANSPORT_STATIC ${LIBTRANSPORT}.static CACHE INTERNAL "" FORCE)
-set(LIBTRANSPORT_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/src CACHE INTERNAL "" FORCE)
 
-include(WindowsMacros)
-include(IosMacros)
 
-find_package_wrapper(Asio REQUIRED)
-find_package(OpenSSL REQUIRED)
+##############################################################
+# Dependencies and third party libs
+##############################################################
+find_package(Asio ${ASIO_DEFAULT_VERSION} REQUIRED)
+find_package(OpenSSL ${OPENSSL_DEFAULT_VERSION} EXACT REQUIRED)
 find_package(Threads REQUIRED)
-find_package(OpenSSL REQUIRED)
-find_package(Libconfig++ REQUIRED)
+find_package(Libconfig++ ${LIBCONFIG_DEFAULT_VERSION} REQUIRED)
+add_subdirectory(third-party)
 
+
+##############################################################
+# Check if building as subproject or as root project
+##############################################################
 if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-  find_package_wrapper(Libhicn REQUIRED)
+  include(CommonSetup)
+  find_package(Libhicn ${CURRENT_VERSION} REQUIRED NO_MODULE)
+
+  if (DISABLE_SHARED_LIBRARIES)
+    set(LIBTYPE static)
+  else()
+    set(LIBTYPE shared)
+  endif()
+
+  list(APPEND HICN_LIBRARIES hicn::hicn.${LIBTYPE})
 else()
   if (DISABLE_SHARED_LIBRARIES)
     if (WIN32)
@@ -73,34 +93,16 @@ else()
   endif()
 endif()
 
-include(Packaging)
-
-add_subdirectory(third-party)
-
-set(LIBRARIES
-  PRIVATE ${HICN_LIBRARIES}
-  PRIVATE ${CMAKE_THREAD_LIBS_INIT}
-  PRIVATE ${CMAKE_DL_LIBS}
-  PRIVATE ${OPENSSL_LIBRARIES}
-  PRIVATE ${LIBCONFIG_CPP_LIBRARIES}
-  PRIVATE ${THIRD_PARTY_LIBRARIES}
-)
 
-# Include dirs -- Order does matter!
-list(APPEND LIBTRANSPORT_INTERNAL_INCLUDE_DIRS
-  ${HICN_INCLUDE_DIRS}
-  ${HICNPLUGIN_INCLUDE_DIRS}
-  ${CMAKE_THREADS_INCLUDE_DIRS}
-  ${ASIO_INCLUDE_DIRS}
-  ${WINDOWS_INCLUDE_DIRS}
-  ${OPENSSL_INCLUDE_DIR}
-  ${CONFIG_INCLUDE_DIRS}
-  ${THIRD_PARTY_INCLUDE_DIRS}
-)
+##############################################################
+# Packaging and versioning
+##############################################################
+include(${CMAKE_CURRENT_SOURCE_DIR}/../versions.cmake)
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/packaging.cmake)
 
-list(APPEND DEPENDENCIES
-  ${THIRD_PARTY_DEPENDENCIES}
-)
 
+##############################################################
+# Subdirectories
+##############################################################
 add_subdirectory(includes/hicn/transport)
-add_subdirectory(${TRANSPORT_ROOT_PATH})
+add_subdirectory(src)
diff --git a/libtransport/cmake/Modules/Android.cmake b/libtransport/cmake/Modules/Android.cmake
deleted file mode 100644
index 78918455a..000000000
--- a/libtransport/cmake/Modules/Android.cmake
+++ /dev/null
@@ -1,19 +0,0 @@
-# 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.
-
-function (configure_android_environment)
-  set(CMAKE_CXX_FLAGS "  -Wall -stdlib=libc++ -DASIO_STANDALONE -pthread -isystem -lm")
-
-  #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" PARENT_SCOPE)
-  #set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ANDROID_C_FLAGS}" PARENT_SCOPE)
-endfunction()
\ No newline at end of file
diff --git a/libtransport/cmake/Modules/DefaultConfiguration.cmake b/libtransport/cmake/Modules/DefaultConfiguration.cmake
deleted file mode 100644
index 402ad86f5..000000000
--- a/libtransport/cmake/Modules/DefaultConfiguration.cmake
+++ /dev/null
@@ -1,30 +0,0 @@
-# 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.
-
-# C/c++ standard
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_C_STANDARD 11)
-
-# Compilation flags
-
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG")
-if (NOT WIN32)
-  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fpermissive")
-  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -fpermissive")
-  set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -fpermissive")
-endif ()
-
-set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DDEBUG")
-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
-set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
-set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL}")
\ No newline at end of file
diff --git a/libtransport/cmake/Modules/Ios.cmake b/libtransport/cmake/Modules/Ios.cmake
deleted file mode 100644
index 1b2aae2bf..000000000
--- a/libtransport/cmake/Modules/Ios.cmake
+++ /dev/null
@@ -1,20 +0,0 @@
-# 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.
-
-function (configure_ios_environment)
-  find_host_package ( OpenSSL REQUIRED )
-  include_directories(extras/iOS)
-
-  find_host_package(Libhicn REQUIRED)
-  include_directories(${HICN_INCLUDE_DIRS})
-endfunction()
\ No newline at end of file
diff --git a/libtransport/cmake/Modules/Packaging.cmake b/libtransport/cmake/packaging.cmake
index 9ff26aecc..f7f0c27e3 100644
--- a/libtransport/cmake/Modules/Packaging.cmake
+++ b/libtransport/cmake/packaging.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -17,6 +17,11 @@
 # Packages section
 ######################
 
+##############################################################
+# Get VPP version
+##############################################################
+list(GET VPP_DEFAULT_VERSION 0 VPP_VERSION)
+
 set(${LIBTRANSPORT_COMPONENT}_DESCRIPTION
 "Libhicn-transport provides transport services and \
 socket API for applications willing to communicate \
@@ -28,7 +33,7 @@ set(${LIBTRANSPORT_COMPONENT}-dev_DESCRIPTION
   CACHE STRING "Header files for developing using libhicntransport."
 )
 
-set(${LIBTRANSPORT_COMPONENT}-devel_DESCRIPTION
+set(lib${LIBTRANSPORT}-devel_DESCRIPTION
   CACHE STRING "Header files for developing using libhicntransport."
 )
 
@@ -37,31 +42,44 @@ set(${LIBTRANSPORT_COMPONENT}-io-modules_DESCRIPTION
 )
 
 set(${LIBTRANSPORT_COMPONENT}_DEB_DEPENDENCIES
-  "lib${LIBHICN} (>= stable_version), libparc (>= 1.0), libconfig++9v5 (>= 1.5-0.4build1)"
+  "lib${LIBHICN} (= stable_version), libconfig++9v5 (>= 1.5-0.4build1)"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(${LIBTRANSPORT_COMPONENT}_RPM_DEPENDENCIES
-  "lib${LIBHICN} >= stable_version, libparc >= 1.0, libconfig >= 1.5-9.el8"
+  "lib${LIBHICN} = stable_version, libconfig >= 1.5-9.el8"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(${LIBTRANSPORT_COMPONENT}-dev_DEB_DEPENDENCIES
-  "${LIBTRANSPORT_COMPONENT} (>= stable_version), libasio-dev (>= 1.10), lib${LIBHICN}-dev (>= stable_version), libparc-dev (>= 1.0), libconfig++-dev (>= 1.5-0.4build1)"
+  "${LIBTRANSPORT_COMPONENT} (= stable_version), libasio-dev (>= 1.10), lib${LIBHICN}-dev (= stable_version), libconfig++-dev (>= 1.5-0.4build1)"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(${LIBTRANSPORT_COMPONENT}-dev_RPM_DEPENDENCIES
-  "${LIBTRANSPORT_COMPONENT} >= stable_version, asio-devel >= 1.10, lib${LIBHICN}-devel >= stable_version, libparc-devel >= 1.0, libconfig-devel >= 1.5-9.el8"
+  "${LIBTRANSPORT_COMPONENT} = stable_version, asio-devel >= 1.10, lib${LIBHICN}-devel = stable_version, libconfig-devel >= 1.5-9.el8"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(${LIBTRANSPORT_COMPONENT}-io-modules_DEB_DEPENDENCIES
-  "${LIBTRANSPORT_COMPONENT} (>= stable_version), libmemif (>= stable_version), vpp (>= stable_version-release), vpp (<< next_version-release), hicn-plugin (>= stable_version)"
+  "${LIBTRANSPORT_COMPONENT} (= stable_version), vpp (>= ${VPP_VERSION}), hicn-plugin (= stable_version)"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(${LIBTRANSPORT_COMPONENT}-io-modules_RPM_DEPENDENCIES
-  "${LIBTRANSPORT_COMPONENT} >= stable_version, libmemif >= stable_version, vpp >= stable_version-release, vpp < next_version-release, hicn-plugin >= stable_version"
+  "${LIBTRANSPORT_COMPONENT} = stable_version, vpp >= ${VPP_VERSION}, hicn-plugin = stable_version"
   CACHE STRING "Dependencies for deb/rpm package."
 )
+
+if (INTERNAL_ENVIRONMENT)
+  include(CheckSsl)
+  CheckSsl()
+  set(${LIBTRANSPORT_COMPONENT}_DEB_DEPENDENCIES
+    "${${LIBTRANSPORT_COMPONENT}_DEB_DEPENDENCIES}, ${OPENSSL_DEPENDENCY}"
+    CACHE STRING "Dependencies for deb/rpm package."
+  )
+  set(${LIBTRANSPORT_COMPONENT}-dev_DEB_DEPENDENCIES
+    "${${LIBTRANSPORT_COMPONENT}-dev_DEB_DEPENDENCIES}, ${OPENSSL_DEPENDENCY_DEV}"
+    CACHE STRING "Dependencies for deb/rpm package."
+  )
+endif ()
diff --git a/libtransport/includes/hicn/transport/CMakeLists.txt b/libtransport/includes/hicn/transport/CMakeLists.txt
index eb339fb5a..8b9f907b9 100644
--- a/libtransport/includes/hicn/transport/CMakeLists.txt
+++ b/libtransport/includes/hicn/transport/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2020 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -23,14 +23,21 @@ add_subdirectory(portability)
 add_subdirectory(auth)
 add_subdirectory(utils)
 
-set(LIBTRANSPORT_INCLUDE_DIRS
-  ${CMAKE_CURRENT_SOURCE_DIR}/../.. ""
+
+##############################################################
+# Public headers directory
+##############################################################
+set(Libhicntransport_INCLUDE_DIRS
+  ${CMAKE_CURRENT_SOURCE_DIR}/../..
   CACHE INTERNAL
   "" FORCE
 )
 
+
+##############################################################
+# Header files to install
+##############################################################
 set(LIBHICNTRANSPORT_TO_INSTALL_HEADER_FILES
-  ${HEADER_FILES} ""
-  CACHE INTERNAL
-  "" FORCE
+  ${HEADER_FILES}
+  PARENT_SCOPE
 )
diff --git a/libtransport/includes/hicn/transport/auth/CMakeLists.txt b/libtransport/includes/hicn/transport/auth/CMakeLists.txt
index 1e9fe4698..0b5ae1836 100644
--- a/libtransport/includes/hicn/transport/auth/CMakeLists.txt
+++ b/libtransport/includes/hicn/transport/auth/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -15,7 +15,6 @@ list(APPEND HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/common.h
   ${CMAKE_CURRENT_SOURCE_DIR}/crypto_hash.h
   ${CMAKE_CURRENT_SOURCE_DIR}/crypto_suite.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/identity.h
   ${CMAKE_CURRENT_SOURCE_DIR}/key_id.h
   ${CMAKE_CURRENT_SOURCE_DIR}/policies.h
   ${CMAKE_CURRENT_SOURCE_DIR}/signer.h
diff --git a/libtransport/includes/hicn/transport/auth/common.h b/libtransport/includes/hicn/transport/auth/common.h
index fb0e82eb7..d2282436e 100644
--- a/libtransport/includes/hicn/transport/auth/common.h
+++ b/libtransport/includes/hicn/transport/auth/common.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/auth/crypto_hash.h b/libtransport/includes/hicn/transport/auth/crypto_hash.h
index 90f1627e9..3c734fee3 100644
--- a/libtransport/includes/hicn/transport/auth/crypto_hash.h
+++ b/libtransport/includes/hicn/transport/auth/crypto_hash.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -89,7 +89,7 @@ class CryptoHash {
   static std::size_t getSize(CryptoHashType hash_type);
 
   // Compare two raw buffers
-  static bool compareDigest(const uint8_t *h1, const uint8_t *h2,
+  static bool compareDigest(const uint8_t *digest1, const uint8_t *digest2,
                             CryptoHashType hash_type);
 
  private:
diff --git a/libtransport/includes/hicn/transport/auth/crypto_suite.h b/libtransport/includes/hicn/transport/auth/crypto_suite.h
index d0f1de395..ed21abb91 100644
--- a/libtransport/includes/hicn/transport/auth/crypto_suite.h
+++ b/libtransport/includes/hicn/transport/auth/crypto_suite.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -47,6 +47,9 @@ enum class CryptoSuite : uint8_t {
 // Return the suite associated to the given NID
 CryptoSuite getSuite(int nid);
 
+// Return the string representation of given suite
+std::string getStringSuite(CryptoSuite suite);
+
 // Return the hash type associated to the given suite
 CryptoHashType getHashType(CryptoSuite suite);
 
diff --git a/libtransport/includes/hicn/transport/auth/identity.h b/libtransport/includes/hicn/transport/auth/identity.h
deleted file mode 100644
index be072f5d3..000000000
--- a/libtransport/includes/hicn/transport/auth/identity.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <errno.h>
-#include <fcntl.h>
-#include <hicn/transport/auth/signer.h>
-#include <unistd.h>
-
-extern "C" {
-#include <openssl/pkcs12.h>
-#include <openssl/rand.h>
-#include <openssl/x509.h>
-#include <openssl/x509v3.h>
-}
-
-namespace transport {
-namespace auth {
-
-class Identity {
-  // This class holds several information about a client, including its public
-  // key.
- public:
-  // Generate a new identity from the given parameters. The identity will be
-  // saved in 'keystore_path' and encrypted using 'keystore_pwd'.
-  Identity(const std::string &keystore_path, const std::string &keystore_pwd,
-           CryptoSuite suite, unsigned int signature_len,
-           unsigned int validity_days, const std::string &subject_name);
-
-  // Create an identity from an already existing keystore path.
-  Identity(std::string &keystore_path, std::string &keystore_pwd,
-           CryptoHashType hash_type);
-
-  Identity(const Identity &other);
-  Identity(Identity &&other);
-  ~Identity();
-
-  // Return the asymmetric signer object created from the public key.
-  std::shared_ptr<AsymmetricSigner> getSigner() const;
-
-  // Return the key store filename.
-  std::string getFilename() const;
-
-  // Return the key store password.
-  std::string getPassword() const;
-
-  std::shared_ptr<X509> getCertificate() const;
-
-  std::shared_ptr<EVP_PKEY> getPrivateKey() const;
-
-  // Generate a new random identity.
-  static Identity generateIdentity(const std::string &subject_name = "");
-
- private:
-  static void free_key(EVP_PKEY *T) { EVP_PKEY_free(T); }
-
-  std::string pwd_;
-  std::string filename_;
-  std::shared_ptr<AsymmetricSigner> signer_;
-  std::shared_ptr<X509> cert_;
-};
-
-}  // namespace auth
-}  // namespace transport
diff --git a/libtransport/includes/hicn/transport/auth/key_id.h b/libtransport/includes/hicn/transport/auth/key_id.h
index 3aa09336f..8723ae698 100644
--- a/libtransport/includes/hicn/transport/auth/key_id.h
+++ b/libtransport/includes/hicn/transport/auth/key_id.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/auth/policies.h b/libtransport/includes/hicn/transport/auth/policies.h
index 00464d54b..b9755595c 100644
--- a/libtransport/includes/hicn/transport/auth/policies.h
+++ b/libtransport/includes/hicn/transport/auth/policies.h
@@ -23,10 +23,10 @@ namespace auth {
  * perform after verification.
  */
 enum class VerificationPolicy {
+  UNKNOWN,
   ABORT,
-  ACCEPT,
   DROP,
-  UNKNOWN,
+  ACCEPT,
 };
 
 }  // namespace auth
diff --git a/libtransport/includes/hicn/transport/auth/signer.h b/libtransport/includes/hicn/transport/auth/signer.h
index 405dd83cf..5a7598991 100644
--- a/libtransport/includes/hicn/transport/auth/signer.h
+++ b/libtransport/includes/hicn/transport/auth/signer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -21,18 +21,19 @@
 #include <hicn/transport/errors/errors.h>
 #include <hicn/transport/utils/membuf.h>
 
+#include <memory>
 extern "C" {
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
+#include <openssl/pkcs12.h>
+#include <openssl/x509.h>
 }
 
 namespace transport {
 namespace auth {
 
-class Identity;
 class Signer {
   // The base class from which all signer classes derive.
-  friend class Identity;
 
  public:
   Signer();
@@ -47,6 +48,9 @@ class Signer {
   // Return the signature.
   std::vector<uint8_t> getSignature() const;
 
+  // Return the signature as a string
+  std::string getStringSignature() const;
+
   // Return the signature size in bytes.
   virtual std::size_t getSignatureSize() const;
 
@@ -61,6 +65,9 @@ class Signer {
   // Return the hash algorithm associated to the signer.
   CryptoHashType getHashType() const;
 
+  // Print signature to stdout
+  void display();
+
  protected:
   CryptoSuite suite_;
   std::vector<uint8_t> signature_;
@@ -84,10 +91,17 @@ class AsymmetricSigner : public Signer {
  public:
   AsymmetricSigner() = default;
 
-  // Construct an AsymmetricSigner from a key store and a given crypto suite.
+  // Create an AsymmetricSigner from a keystore file (.p12).
+  AsymmetricSigner(std::string keystore_path, std::string password);
+
+  // Construct an AsymmetricSigner from a key store and a given crypto
+  // suite.
   AsymmetricSigner(CryptoSuite suite, std::shared_ptr<EVP_PKEY> key,
                    std::shared_ptr<EVP_PKEY> pub_key);
 
+  void setKey(CryptoSuite suite, std::shared_ptr<EVP_PKEY> key,
+              std::shared_ptr<EVP_PKEY> pub_key);
+
   std::size_t getSignatureFieldSize() const override;
 };
 
diff --git a/libtransport/includes/hicn/transport/auth/verifier.h b/libtransport/includes/hicn/transport/auth/verifier.h
index 6321d4ed5..677a1efe4 100644
--- a/libtransport/includes/hicn/transport/auth/verifier.h
+++ b/libtransport/includes/hicn/transport/auth/verifier.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -40,9 +40,9 @@ class Verifier {
   // The VerificationFailedCallback will be called by the transport if a
   // data packet (either a manifest or a content object) was not validated.
   // The application decides what to do then by returning a
-  // VerificationPolicy object.
+  // new VerificationPolicy.
   using VerificationFailedCallback = std::function<auth::VerificationPolicy(
-      const core::ContentObject &content_object, std::error_code ec)>;
+      Suffix suffix, VerificationPolicy policy)>;
 
   // The list of VerificationPolicy that will trigger the
   // VerificationFailedCallback.
@@ -96,13 +96,13 @@ class Verifier {
   void getVerificationFailedCallback(
       VerificationFailedCallback **verification_failed_cb);
 
+  // Call VerificationFailedCallback if it is set and update the packet policy.
+  void callVerificationFailedCallback(Suffix suffix,
+                                      VerificationPolicy &policy);
+
  protected:
   VerificationFailedCallback verification_failed_cb_;
   std::vector<VerificationPolicy> failed_policies_;
-
-  // Call VerificationFailedCallback if it is set and update the packet policy.
-  void callVerificationFailedCallback(PacketPtr packet,
-                                      VerificationPolicy &policy);
 };
 
 class VoidVerifier : public Verifier {
diff --git a/libtransport/includes/hicn/transport/core/CMakeLists.txt b/libtransport/includes/hicn/transport/core/CMakeLists.txt
index 14c795a7a..34048d93a 100644
--- a/libtransport/includes/hicn/transport/core/CMakeLists.txt
+++ b/libtransport/includes/hicn/transport/core/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/core/connector.h b/libtransport/includes/hicn/transport/core/connector.h
index dcf38cdc8..b671a7d89 100644
--- a/libtransport/includes/hicn/transport/core/connector.h
+++ b/libtransport/includes/hicn/transport/core/connector.h
@@ -15,6 +15,7 @@
 
 #pragma once
 
+#include <glog/logging.h>
 #include <hicn/transport/core/connector_stats.h>
 #include <hicn/transport/core/content_object.h>
 #include <hicn/transport/core/endpoint.h>
@@ -50,22 +51,21 @@ class Connector : public std::enable_shared_from_this<Connector> {
 
   enum class Role : std::uint8_t { CONSUMER, PRODUCER };
 
- public:
   static constexpr std::size_t queue_size = 4096;
   static constexpr std::uint32_t invalid_connector = ~0;
-
-#ifdef LINUX
+  static constexpr std::uint32_t max_reconnection_reattempts = 5;
   static constexpr std::uint16_t max_burst = 256;
-#endif
 
   using Ptr = std::shared_ptr<Connector>;
-  using PacketQueue = std::deque<Packet::Ptr>;
-  using PacketReceivedCallback = std::function<void(
-      Connector *, utils::MemBuf &, const std::error_code &)>;
+  using PacketQueue = std::deque<utils::MemBuf::Ptr>;
+  using PacketReceivedCallback =
+      std::function<void(Connector *, const std::vector<utils::MemBuf::Ptr> &,
+                         const std::error_code &)>;
   using PacketSentCallback =
       std::function<void(Connector *, const std::error_code &)>;
   using OnCloseCallback = std::function<void(Connector *)>;
-  using OnReconnectCallback = std::function<void(Connector *)>;
+  using OnReconnectCallback =
+      std::function<void(Connector *, const std::error_code &)>;
   using Id = std::uint64_t;
 
   template <typename ReceiveCallback, typename SentCallback, typename OnClose,
@@ -77,7 +77,8 @@ class Connector : public std::enable_shared_from_this<Connector> {
         on_close_callback_(std::forward<OnClose &&>(close_callback)),
         on_reconnect_callback_(std::forward<OnReconnect &&>(on_reconnect)),
         state_(State::CLOSED),
-        connector_id_(invalid_connector) {}
+        connector_id_(invalid_connector),
+        connection_reattempts_(0) {}
 
   virtual ~Connector(){};
 
@@ -115,7 +116,7 @@ class Connector : public std::enable_shared_from_this<Connector> {
 
   virtual void send(Packet &packet) = 0;
 
-  virtual void send(const uint8_t *packet, std::size_t len) = 0;
+  virtual void send(const utils::MemBuf::Ptr &buffer) = 0;
 
   virtual void close() = 0;
 
@@ -206,6 +207,9 @@ class Connector : public std::enable_shared_from_this<Connector> {
 
   // Stats
   AtomicConnectorStats stats_;
+
+  // Connection attempts
+  std::uint32_t connection_reattempts_;
 };
 
 }  // namespace core
diff --git a/libtransport/includes/hicn/transport/core/content_object.h b/libtransport/includes/hicn/transport/core/content_object.h
index 38baafc69..a8df1e8e3 100644
--- a/libtransport/includes/hicn/transport/core/content_object.h
+++ b/libtransport/includes/hicn/transport/core/content_object.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -31,10 +31,9 @@ class ContentObject : public Packet {
   using Ptr = std::shared_ptr<ContentObject>;
   using HICNContentObject = hicn_header_t;
 
-  ContentObject(Packet::Format format = HF_INET6_TCP,
-                std::size_t additional_header_size = 0);
+  ContentObject(Packet::Format format, std::size_t additional_header_size = 0);
 
-  ContentObject(const Name &name, Packet::Format format = HF_INET6_TCP,
+  ContentObject(const Name &name, Packet::Format format,
                 std::size_t additional_header_size = 0);
 
   ContentObject(const Name &name, hicn_format_t format,
@@ -42,7 +41,7 @@ class ContentObject : public Packet {
                 std::size_t payload_size);
 
   template <typename... Args>
-  ContentObject(CopyBufferOp op, Args &&... args)
+  ContentObject(CopyBufferOp op, Args &&...args)
       : Packet(op, std::forward<Args>(args)...) {
     if (hicn_data_get_name(format_, packet_start_, name_.getStructReference()) <
         0) {
@@ -51,7 +50,7 @@ class ContentObject : public Packet {
   }
 
   template <typename... Args>
-  ContentObject(WrapBufferOp op, Args &&... args)
+  ContentObject(WrapBufferOp op, Args &&...args)
       : Packet(op, std::forward<Args>(args)...) {
     if (hicn_data_get_name(format_, packet_start_, name_.getStructReference()) <
         0) {
@@ -60,8 +59,12 @@ class ContentObject : public Packet {
   }
 
   template <typename... Args>
-  ContentObject(CreateOp op, Args &&... args)
+  ContentObject(CreateOp op, Args &&...args)
       : Packet(op, std::forward<Args>(args)...) {
+    if (hicn_packet_set_data(format_, packet_start_) < 0) {
+      throw errors::MalformedPacketException();
+    }
+
     if (hicn_data_get_name(format_, packet_start_, name_.getStructReference()) <
         0) {
       throw errors::MalformedPacketException();
@@ -96,6 +99,10 @@ class ContentObject : public Packet {
 
   auto shared_from_this() { return utils::shared_from(this); }
 
+  bool isLast() const;
+
+  void setLast();
+
  private:
   void resetForHash() override;
 };
diff --git a/libtransport/includes/hicn/transport/core/endpoint.h b/libtransport/includes/hicn/transport/core/endpoint.h
index cb6b0f562..e1fa193d7 100644
--- a/libtransport/includes/hicn/transport/core/endpoint.h
+++ b/libtransport/includes/hicn/transport/core/endpoint.h
@@ -42,14 +42,20 @@ class Endpoint {
   ~Endpoint() = default;
 
   Endpoint &operator=(const Endpoint &other) {
-    address_ = other.address_;
-    port_ = other.port_;
+    if (this != &other) {
+      address_ = other.address_;
+      port_ = other.port_;
+    }
+
     return *this;
   }
 
   Endpoint &operator=(Endpoint &&other) {
-    address_ = std::move(other.address_);
-    port_ = std::move(other.port_);
+    if (this != &other) {
+      address_ = std::move(other.address_);
+      port_ = std::move(other.port_);
+    }
+
     return *this;
   }
 
diff --git a/libtransport/includes/hicn/transport/core/global_object_pool.h b/libtransport/includes/hicn/transport/core/global_object_pool.h
index d7f3a9e41..f98df521f 100644
--- a/libtransport/includes/hicn/transport/core/global_object_pool.h
+++ b/libtransport/includes/hicn/transport/core/global_object_pool.h
@@ -27,9 +27,10 @@ namespace transport {
 namespace core {
 
 template <std::size_t packet_pool_size = 1024, std::size_t chunk_size = 2048>
-class PacketManager
-    : public utils::Singleton<PacketManager<packet_pool_size, chunk_size>> {
-  friend class utils::Singleton<PacketManager<packet_pool_size, chunk_size>>;
+class PacketManager : public utils::ThreadLocalSingleton<
+                          PacketManager<packet_pool_size, chunk_size>> {
+  friend class utils::ThreadLocalSingleton<
+      PacketManager<packet_pool_size, chunk_size>>;
 
  public:
   using MemoryPool = utils::FixedBlockAllocator<chunk_size, packet_pool_size>;
@@ -71,7 +72,10 @@ class PacketManager
   template <
       typename PacketType, typename... Args,
       typename = std::enable_if_t<std::is_base_of<Packet, PacketType>::value>>
-  typename PacketType::Ptr getPacket(Args &&... args) {
+  typename PacketType::Ptr getPacket(Args &&...args) {
+    static_assert(sizeof(PacketType) + sizeof(std::shared_ptr<PacketType>) +
+                      sizeof(std::max_align_t) <=
+                  sizeof(PacketStorage::packet_and_shared_ptr));
     PacketType *memory = nullptr;
 
     memory = reinterpret_cast<PacketType *>(memory_pool_.allocateBlock());
@@ -98,7 +102,7 @@ class PacketManager
   template <typename PacketType, typename... Args>
   typename PacketType::Ptr getPacketFromExistingBuffer(uint8_t *buffer,
                                                        std::size_t length,
-                                                       Args &&... args) {
+                                                       Args &&...args) {
     auto offset = offsetof(PacketStorage, align);
     auto memory = reinterpret_cast<PacketType *>(buffer - offset);
     utils::STLAllocator<PacketType, MemoryPool> allocator(memory,
diff --git a/libtransport/includes/hicn/transport/core/interest.h b/libtransport/includes/hicn/transport/core/interest.h
index a5b9cf375..b7ce3c3a0 100644
--- a/libtransport/includes/hicn/transport/core/interest.h
+++ b/libtransport/includes/hicn/transport/core/interest.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -40,16 +40,15 @@ class Interest
  public:
   using Ptr = std::shared_ptr<Interest>;
 
-  Interest(Packet::Format format = HF_INET6_TCP,
-           std::size_t additional_header_size = 0);
+  Interest(Packet::Format format, std::size_t additional_header_size = 0);
 
-  Interest(const Name &interest_name, Packet::Format format = HF_INET6_TCP,
+  Interest(const Name &interest_name, Packet::Format format,
            std::size_t additional_header_size = 0);
 
   Interest(MemBuf &&buffer);
 
   template <typename... Args>
-  Interest(CopyBufferOp op, Args &&... args)
+  Interest(CopyBufferOp op, Args &&...args)
       : Packet(op, std::forward<Args>(args)...) {
     if (hicn_interest_get_name(format_, packet_start_,
                                name_.getStructReference()) < 0) {
@@ -58,7 +57,7 @@ class Interest
   }
 
   template <typename... Args>
-  Interest(WrapBufferOp op, Args &&... args)
+  Interest(WrapBufferOp op, Args &&...args)
       : Packet(op, std::forward<Args>(args)...) {
     if (hicn_interest_get_name(format_, packet_start_,
                                name_.getStructReference()) < 0) {
@@ -67,8 +66,12 @@ class Interest
   }
 
   template <typename... Args>
-  Interest(CreateOp op, Args &&... args)
-      : Packet(op, std::forward<Args>(args)...) {}
+  Interest(CreateOp op, Args &&...args)
+      : Packet(op, std::forward<Args>(args)...) {
+    if (hicn_packet_set_interest(format_, packet_start_) < 0) {
+      throw errors::MalformedPacketException();
+    }
+  }
 
   /* Move constructor */
   Interest(Interest &&other_interest);
diff --git a/libtransport/includes/hicn/transport/core/io_module.h b/libtransport/includes/hicn/transport/core/io_module.h
index ea3cf4e16..817d96d00 100644
--- a/libtransport/includes/hicn/transport/core/io_module.h
+++ b/libtransport/includes/hicn/transport/core/io_module.h
@@ -40,7 +40,7 @@ typedef struct {
 
 class Connector;
 
-class IoModule {
+class IoModule : utils::NonCopyable {
  protected:
   IoModule()
       : inet_address_({}),
@@ -64,15 +64,20 @@ class IoModule {
   virtual bool isConnected() = 0;
 
   virtual void init(Connector::PacketReceivedCallback &&receive_callback,
+                    Connector::PacketSentCallback &&sent_callback,
                     Connector::OnReconnectCallback &&reconnect_callback,
                     asio::io_service &io_service,
                     const std::string &app_name = "Libtransport") = 0;
 
   virtual void registerRoute(const Prefix &prefix) = 0;
+  virtual void sendMapme() {}
+
+  virtual void setForwardingStrategy(const Prefix &prefix,
+                                     std::string &strategy){};
 
   virtual std::uint32_t getMtu() = 0;
 
-  virtual bool isControlMessage(const uint8_t *message) = 0;
+  virtual bool isControlMessage(utils::MemBuf &packet_buffer) = 0;
 
   virtual void processControlMessageReply(utils::MemBuf &packet_buffer) = 0;
 
@@ -89,7 +94,7 @@ class IoModule {
     }
   }
 
-  virtual void send(const uint8_t *packet, std::size_t len) = 0;
+  virtual void send(const utils::MemBuf::Ptr &buffer) = 0;
 
   void setContentStoreSize(uint32_t cs_size) {
     content_store_reserved_ = cs_size;
diff --git a/libtransport/includes/hicn/transport/core/name.h b/libtransport/includes/hicn/transport/core/name.h
index 033582289..5cb4efd10 100644
--- a/libtransport/includes/hicn/transport/core/name.h
+++ b/libtransport/includes/hicn/transport/core/name.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -51,7 +51,7 @@ class Name {
 
  public:
   using NameStruct = hicn_name_t;
-  using Type = hicn_name_type_t;
+  enum class Type { UNDEFINED, V4, V6 };
 
   Name();
 
@@ -69,6 +69,8 @@ class Name {
 
   Name(const Name &name);
 
+  ~Name();
+
   Name &operator=(const Name &name);
 
   bool operator==(const Name &name) const;
@@ -91,14 +93,11 @@ class Name {
 
   uint32_t getSuffix() const;
 
-  std::shared_ptr<Sockaddr> getAddress() const;
-
   Name &setSuffix(uint32_t seq_number);
 
   ip_prefix_t toIpAddress() const;
 
-  void copyToDestination(uint8_t *destination,
-                         bool include_suffix = false) const;
+  void copyPrefixToDestination(uint8_t *destination) const;
 
   int getAddressFamily() const;
 
diff --git a/libtransport/includes/hicn/transport/core/packet.h b/libtransport/includes/hicn/transport/core/packet.h
index 269a1571a..059430f1d 100644
--- a/libtransport/includes/hicn/transport/core/packet.h
+++ b/libtransport/includes/hicn/transport/core/packet.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -30,11 +30,7 @@ namespace transport {
 
 namespace auth {
 class Signer;
-class AsymmetricSigner;
-class SymmetricSigner;
 class Verifier;
-class AsymmetricVerifier;
-class SymmetricVerifier;
 }  // namespace auth
 
 namespace core {
@@ -51,16 +47,13 @@ namespace core {
 class Packet : public utils::MemBuf,
                public std::enable_shared_from_this<Packet> {
   friend class auth::Signer;
-  friend class auth::SymmetricSigner;
-  friend class auth::AsymmetricSigner;
   friend class auth::Verifier;
-  friend class auth::AsymmetricVerifier;
-  friend class auth::SymmetricVerifier;
 
  public:
   using Ptr = std::shared_ptr<Packet>;
   using MemBufPtr = std::shared_ptr<utils::MemBuf>;
   using Format = hicn_format_t;
+
   static constexpr size_t default_mtu = 1500;
 
   /**
@@ -68,146 +61,73 @@ class Packet : public utils::MemBuf,
    * the eventual payload will be added by prepending the payload buffer
    * to the buffer chain whose the fist buffer is the header itself.
    */
-  Packet(Format format = HF_INET6_TCP, std::size_t additional_header_size = 0);
-
-  /**
-   * Create new IP packet using raw buffer.
-   */
-
+  Packet(Format format, std::size_t additional_header_size = 0);
   /* Copy buffer */
   Packet(CopyBufferOp, const uint8_t *buffer, std::size_t size);
   /* Wrap buffer */
   Packet(WrapBufferOp, uint8_t *buffer, std::size_t length, std::size_t size);
   /* Create new using pre-allocated buffer */
   Packet(CreateOp, uint8_t *buffer, std::size_t length, std::size_t size,
-         Format format = HF_INET6_TCP, std::size_t additional_header_size = 0);
-  /* Move MemBuf */
-  Packet(MemBuf &&buffer);
+         Format format, std::size_t additional_header_size = 0);
 
+  Packet(MemBuf &&buffer);
   Packet(Packet &&other);
-
-  /*
-   * Copy constructor and assignemnt operators.
-   */
   Packet(const Packet &other);
-  Packet &operator=(const Packet &other);
-
-  friend bool operator==(const Packet &l_packet, const Packet &r_packet);
 
+  // Destructor
   virtual ~Packet();
 
-  static std::size_t getHeaderSizeFromFormat(Format format,
-                                             std::size_t signature_size = 0) {
-    std::size_t header_length;
-    hicn_packet_get_header_length_from_format(format, &header_length);
-    int is_ah = _is_ah(format);
-    return is_ah * (header_length + signature_size) + (!is_ah) * header_length;
-  }
-
-  static std::size_t getHeaderSizeFromBuffer(Format format,
-                                             const uint8_t *buffer);
-
-  static std::size_t getPayloadSizeFromBuffer(Format format,
-                                              const uint8_t *buffer);
-
-  static bool isInterest(const uint8_t *buffer);
-
-  bool isInterest();
-
-  static Format getFormatFromBuffer(const uint8_t *buffer, std::size_t length) {
-    Format format = HF_UNSPEC;
-    hicn_packet_get_format((const hicn_header_t *)buffer, &format);
-    return format;
-  }
-
-  void reset() {
-    clear();
-    packet_start_ = reinterpret_cast<hicn_header_t *>(writableData());
-    header_offset_ = 0;
-    format_ = HF_UNSPEC;
-    payload_type_ = PayloadType::UNSPECIFIED;
-    name_.clear();
-
-    if (isChained()) {
-      separateChain(next(), prev());
-    }
-  }
-
-  void setFormat(Packet::Format format = HF_INET6_TCP,
-                 std::size_t additional_header_size = 0);
-
-  std::size_t payloadSize() const;
-
-  std::size_t headerSize() const;
+  // Operators
+  Packet &operator=(const Packet &other);
+  friend bool operator==(const Packet &l_packet, const Packet &r_packet);
 
+  // Cast to MemBuf
   std::shared_ptr<utils::MemBuf> acquireMemBufReference();
 
-  virtual const Name &getName() const = 0;
+  // Format
+  Format getFormat() const;
+  void setFormat(Packet::Format format, std::size_t additional_header_size = 0);
 
+  // Name
+  virtual const Name &getName() const = 0;
   virtual Name &getWritableName() = 0;
-
   virtual void setName(const Name &name) = 0;
 
+  // Lifetime
   virtual void setLifetime(uint32_t lifetime) = 0;
-
   virtual uint32_t getLifetime() const = 0;
 
-  Packet &appendPayload(const uint8_t *buffer, std::size_t length);
-
-  Packet &appendPayload(std::unique_ptr<utils::MemBuf> &&payload);
-
-  std::unique_ptr<utils::MemBuf> getPayload() const;
-
-  Packet &updateLength(std::size_t length = 0);
-
-  PayloadType getPayloadType() const;
-
-  Packet &setPayloadType(PayloadType payload_type);
-
-  Format getFormat() const;
-
-  void dump() const;
-
-  static void dump(uint8_t *buffer, std::size_t length);
-
+  // Locator
   virtual void setLocator(const ip_address_t &locator) = 0;
-
   virtual ip_address_t getLocator() const = 0;
 
-  /**
-   * @brief Set signature timestamp, in milliseconds.
-   */
-  void setSignatureTimestamp(const uint64_t &timestamp_milliseconds);
-
-  uint64_t getSignatureTimestamp() const;
-
-  void setValidationAlgorithm(const auth::CryptoSuite &validation_algorithm);
-
-  auth::CryptoSuite getValidationAlgorithm() const;
-
-  void setKeyId(const auth::KeyId &key_id);
+  // Payload type
+  PayloadType getPayloadType() const;
+  Packet &setPayloadType(PayloadType payload_type);
 
-  auth::KeyId getKeyId() const;
+  // Payload
+  std::unique_ptr<utils::MemBuf> getPayload() const;
+  Packet &appendPayload(std::unique_ptr<utils::MemBuf> &&payload);
+  Packet &appendPayload(const uint8_t *buffer, std::size_t length);
 
-  virtual auth::CryptoHash computeDigest(auth::CryptoHashType algorithm) const;
+  // Sizes
+  std::size_t headerSize() const;
+  std::size_t payloadSize() const;
 
-  void setChecksum() {
-    uint16_t partial_csum =
-        csum(data() + HICN_V6_TCP_HDRLEN, length() - HICN_V6_TCP_HDRLEN, 0);
+  // Digest
+  auth::CryptoHash computeDigest(auth::CryptoHashType algorithm) const;
 
-    for (utils::MemBuf *current = next(); current != this;
-         current = current->next()) {
-      partial_csum = csum(current->data(), current->length(), ~partial_csum);
-    }
+  // Reset packet
+  void reset();
 
-    if (hicn_packet_compute_header_checksum(format_, packet_start_,
-                                            partial_csum) < 0) {
-      throw errors::MalformedPacketException();
-    }
-  }
+  // Utils
+  bool isInterest();
+  Packet &updateLength(std::size_t length = 0);
+  void dump() const;
 
+  // TCP methods
+  void setChecksum();
   bool checkIntegrity() const;
-
   Packet &setSyn();
   Packet &resetSyn();
   bool testSyn() const;
@@ -222,53 +142,45 @@ class Packet : public utils::MemBuf,
   bool testFin() const;
   Packet &resetFlags();
   std::string printFlags() const;
-
   Packet &setSrcPort(uint16_t srcPort);
   Packet &setDstPort(uint16_t dstPort);
   uint16_t getSrcPort() const;
   uint16_t getDstPort() const;
-
   Packet &setTTL(uint8_t hops);
   uint8_t getTTL() const;
 
+  // Authentication Header methods
+  bool hasAH() const;
+  std::vector<uint8_t> getSignature() const;
+  std::size_t getSignatureFieldSize() const;
+  std::size_t getSignatureSize() const;
+  uint64_t getSignatureTimestamp() const;
+  auth::KeyId getKeyId() const;
+  auth::CryptoSuite getValidationAlgorithm() const;
+  void setSignature(const std::vector<uint8_t> &signature);
+  void setSignatureFieldSize(std::size_t size);
+  void setSignatureSize(std::size_t size);
+  void setSignatureTimestamp(const uint64_t &timestamp_ms);
+  void setKeyId(const auth::KeyId &key_id);
+  void setValidationAlgorithm(const auth::CryptoSuite &algo);
+
+  // Static methods
+  static Format toAHFormat(const Format &format);
+  static Format getFormatFromBuffer(const uint8_t *buffer, std::size_t length);
+  static std::size_t getHeaderSizeFromFormat(Format format,
+                                             std::size_t signature_size = 0);
+  static std::size_t getHeaderSizeFromBuffer(Format format,
+                                             const uint8_t *buffer);
+  static std::size_t getPayloadSizeFromBuffer(Format format,
+                                              const uint8_t *buffer);
+  static bool isInterest(const uint8_t *buffer,
+                         Format format = Format::HF_UNSPEC);
+  static void dump(uint8_t *buffer, std::size_t length);
+
  private:
   virtual void resetForHash() = 0;
-  void setSignatureSize(std::size_t size_bytes);
-  void setSignatureSizeGap(std::size_t size_bytes);
   void prependPayload(const uint8_t **buffer, std::size_t *size);
 
-  bool authenticationHeader() const { return _is_ah(format_); }
-
-  std::size_t getSignatureSize() const {
-    size_t size_bytes;
-    int ret =
-        hicn_packet_get_signature_size(format_, packet_start_, &size_bytes);
-
-    if (ret < 0) {
-      throw errors::RuntimeException("Packet without Authentication Header.");
-    }
-
-    return size_bytes;
-  }
-
-  std::size_t getSignatureSizeGap() const {
-    uint8_t size_bytes;
-    int ret =
-        hicn_packet_get_signature_gap(format_, packet_start_, &size_bytes);
-
-    if (ret < 0) {
-      throw errors::RuntimeException("Packet without Authentication Header.");
-    }
-
-    return (size_t)size_bytes;
-  }
-
-  std::size_t getSignatureSizeReal() const {
-    return getSignatureSize() - getSignatureSizeGap();
-  }
-
-  uint8_t *getSignature() const;
-
  protected:
   hicn_header_t *packet_start_;
   std::size_t header_offset_;
diff --git a/libtransport/includes/hicn/transport/core/payload_type.h b/libtransport/includes/hicn/transport/core/payload_type.h
index 8c918f792..3a682e177 100644
--- a/libtransport/includes/hicn/transport/core/payload_type.h
+++ b/libtransport/includes/hicn/transport/core/payload_type.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/core/prefix.h b/libtransport/includes/hicn/transport/core/prefix.h
index 7ef667bc8..13401e1a8 100644
--- a/libtransport/includes/hicn/transport/core/prefix.h
+++ b/libtransport/includes/hicn/transport/core/prefix.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -35,6 +35,10 @@ class Prefix {
 
   Prefix(const core::Name &content_name, uint16_t prefix_length);
 
+  bool operator<(const Prefix &prefix) const;
+
+  bool operator==(const Prefix &prefix) const;
+
   std::unique_ptr<Sockaddr> toSockaddr() const;
 
   uint16_t getPrefixLength() const;
diff --git a/libtransport/includes/hicn/transport/errors/CMakeLists.txt b/libtransport/includes/hicn/transport/errors/CMakeLists.txt
index 1d35c5b34..c8642b51b 100644
--- a/libtransport/includes/hicn/transport/errors/CMakeLists.txt
+++ b/libtransport/includes/hicn/transport/errors/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/errors/errors.h b/libtransport/includes/hicn/transport/errors/errors.h
index b659820fa..09ce97221 100644
--- a/libtransport/includes/hicn/transport/errors/errors.h
+++ b/libtransport/includes/hicn/transport/errors/errors.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/errors/indexing_exception.h b/libtransport/includes/hicn/transport/errors/indexing_exception.h
index 731314f0e..bdcc39aef 100644
--- a/libtransport/includes/hicn/transport/errors/indexing_exception.h
+++ b/libtransport/includes/hicn/transport/errors/indexing_exception.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/errors/invalid_ip_address_exception.h b/libtransport/includes/hicn/transport/errors/invalid_ip_address_exception.h
index 60226f576..26e0f98af 100644
--- a/libtransport/includes/hicn/transport/errors/invalid_ip_address_exception.h
+++ b/libtransport/includes/hicn/transport/errors/invalid_ip_address_exception.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/errors/malformed_ahpacket_exception.h b/libtransport/includes/hicn/transport/errors/malformed_ahpacket_exception.h
index f0cfe0b82..9b3ec7466 100644
--- a/libtransport/includes/hicn/transport/errors/malformed_ahpacket_exception.h
+++ b/libtransport/includes/hicn/transport/errors/malformed_ahpacket_exception.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/errors/malformed_name_exception.h b/libtransport/includes/hicn/transport/errors/malformed_name_exception.h
index 4ef45d2e8..57412cf7f 100644
--- a/libtransport/includes/hicn/transport/errors/malformed_name_exception.h
+++ b/libtransport/includes/hicn/transport/errors/malformed_name_exception.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/errors/malformed_packet_exception.h b/libtransport/includes/hicn/transport/errors/malformed_packet_exception.h
index ec5c97e6e..996d6a4ab 100644
--- a/libtransport/includes/hicn/transport/errors/malformed_packet_exception.h
+++ b/libtransport/includes/hicn/transport/errors/malformed_packet_exception.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/errors/not_implemented_exception.h b/libtransport/includes/hicn/transport/errors/not_implemented_exception.h
index e9869163d..3291fa425 100644
--- a/libtransport/includes/hicn/transport/errors/not_implemented_exception.h
+++ b/libtransport/includes/hicn/transport/errors/not_implemented_exception.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/errors/null_pointer_exception.h b/libtransport/includes/hicn/transport/errors/null_pointer_exception.h
index bd06485ed..7edb619b8 100644
--- a/libtransport/includes/hicn/transport/errors/null_pointer_exception.h
+++ b/libtransport/includes/hicn/transport/errors/null_pointer_exception.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/errors/runtime_exception.h b/libtransport/includes/hicn/transport/errors/runtime_exception.h
index ba5128a7e..498c41a7c 100644
--- a/libtransport/includes/hicn/transport/errors/runtime_exception.h
+++ b/libtransport/includes/hicn/transport/errors/runtime_exception.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/errors/tokenizer_exception.h b/libtransport/includes/hicn/transport/errors/tokenizer_exception.h
index 76eda838e..31f79644a 100644
--- a/libtransport/includes/hicn/transport/errors/tokenizer_exception.h
+++ b/libtransport/includes/hicn/transport/errors/tokenizer_exception.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/errors/unexpected_manifest_exception.h b/libtransport/includes/hicn/transport/errors/unexpected_manifest_exception.h
index 6f71471e4..c8e4eadd4 100644
--- a/libtransport/includes/hicn/transport/errors/unexpected_manifest_exception.h
+++ b/libtransport/includes/hicn/transport/errors/unexpected_manifest_exception.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/http/CMakeLists.txt b/libtransport/includes/hicn/transport/http/CMakeLists.txt
index 9f4cdaf39..36a2ca5ce 100644
--- a/libtransport/includes/hicn/transport/http/CMakeLists.txt
+++ b/libtransport/includes/hicn/transport/http/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2020 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/http/client_connection.h b/libtransport/includes/hicn/transport/http/client_connection.h
index 7e78e9c59..d5edf6cd0 100644
--- a/libtransport/includes/hicn/transport/http/client_connection.h
+++ b/libtransport/includes/hicn/transport/http/client_connection.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -31,7 +31,7 @@ namespace http {
 using namespace interface;
 using namespace core;
 
-class HTTPClientConnection {
+class HTTPClientConnection : private utils::NonCopyable {
   static constexpr uint32_t max_buffer_capacity = 64 * 1024;
 
  public:
@@ -39,7 +39,7 @@ class HTTPClientConnection {
    public:
     virtual void onBytesReceived(std::unique_ptr<utils::MemBuf> &&buffer) = 0;
     virtual void onSuccess(std::size_t bytes) = 0;
-    virtual void onError(const std::error_code ec) = 0;
+    virtual void onError(const std::error_code &ec) = 0;
   };
 
   enum class RC : uint32_t { DOWNLOAD_FAILED, DOWNLOAD_SUCCESS };
diff --git a/libtransport/includes/hicn/transport/http/default_values.h b/libtransport/includes/hicn/transport/http/default_values.h
index 2d5a6b821..8cf247e19 100644
--- a/libtransport/includes/hicn/transport/http/default_values.h
+++ b/libtransport/includes/hicn/transport/http/default_values.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/http/facade.h b/libtransport/includes/hicn/transport/http/facade.h
index 8a465ce94..c886a7588 100644
--- a/libtransport/includes/hicn/transport/http/facade.h
+++ b/libtransport/includes/hicn/transport/http/facade.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/http/message.h b/libtransport/includes/hicn/transport/http/message.h
index b8756224f..a07941413 100644
--- a/libtransport/includes/hicn/transport/http/message.h
+++ b/libtransport/includes/hicn/transport/http/message.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/http/request.h b/libtransport/includes/hicn/transport/http/request.h
index b62f5b061..9939fbcaf 100644
--- a/libtransport/includes/hicn/transport/http/request.h
+++ b/libtransport/includes/hicn/transport/http/request.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/http/response.h b/libtransport/includes/hicn/transport/http/response.h
index bab41acb8..79def27cd 100644
--- a/libtransport/includes/hicn/transport/http/response.h
+++ b/libtransport/includes/hicn/transport/http/response.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/interfaces/CMakeLists.txt b/libtransport/includes/hicn/transport/interfaces/CMakeLists.txt
index 40623dfe1..1acaadcf0 100644
--- a/libtransport/includes/hicn/transport/interfaces/CMakeLists.txt
+++ b/libtransport/includes/hicn/transport/interfaces/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -21,6 +21,7 @@ list(APPEND HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/global_conf_interface.h
   ${CMAKE_CURRENT_SOURCE_DIR}/statistics.h
   ${CMAKE_CURRENT_SOURCE_DIR}/portal.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/notification.h
 )
 
 if (${OPENSSL_VERSION} VERSION_EQUAL "1.1.1a" OR ${OPENSSL_VERSION} VERSION_GREATER "1.1.1a")
diff --git a/libtransport/includes/hicn/transport/interfaces/callbacks.h b/libtransport/includes/hicn/transport/interfaces/callbacks.h
index 22e111799..41e4fba3b 100644
--- a/libtransport/includes/hicn/transport/interfaces/callbacks.h
+++ b/libtransport/includes/hicn/transport/interfaces/callbacks.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,6 +16,7 @@
 #pragma once
 
 #include <hicn/transport/auth/policies.h>
+#include <hicn/transport/interfaces/notification.h>
 #include <hicn/transport/interfaces/statistics.h>
 
 #include <functional>
@@ -60,6 +61,12 @@ using ConsumerTimerCallback =
     std::function<void(ConsumerSocket &, const TransportStatistics &stats)>;
 
 /**
+ * The ConsumerTimerCallback is called when the forwarding/recovery stategy is
+ * changes.
+ */
+using StrategyCallback = std::function<void(notification::Strategy strategy)>;
+
+/**
  * The ProducerContentCallback will be called by the producer socket right after
  * a content has been segmented and published.
  */
diff --git a/hicn-light/src/hicn/config/controlAdd.h b/libtransport/includes/hicn/transport/interfaces/notification.h
index 7c160b5f7..a0945c3f0 100644
--- a/hicn-light/src/hicn/config/controlAdd.h
+++ b/libtransport/includes/hicn/transport/interfaces/notification.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2022 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,20 +13,19 @@
  * limitations under the License.
  */
 
-/**
- * @file control_Add.h
- * @brief Command-line "add" node
- *
- * Implements the "add" node of the CLI tree
- *
- *
- */
+#pragma once
+
+#include <variant>
+
+namespace transport {
+namespace interface {
+namespace notification {
 
-#ifndef control_Add_h
-#define control_Add_h
+enum class ForwardingStrategy { BEST_PATH, REPLICATION, BOTH, NONE };
+enum class RecoveryStrategy { RECOVERY_OFF, RTX_ONLY, FEC_ONLY, RTX_AND_FEC };
 
-#include <hicn/config/controlState.h>
+using Strategy = std::variant<ForwardingStrategy, RecoveryStrategy>;
 
-CommandOps *webControlAdd_Create(ControlState *state);
-CommandOps *controlAdd_CreateHelp(ControlState *state);
-#endif  // control_Add_h
+}  // namespace notification
+}  // namespace interface
+}  // namespace transport
\ No newline at end of file
diff --git a/libtransport/includes/hicn/transport/interfaces/p2psecure_socket_consumer.h b/libtransport/includes/hicn/transport/interfaces/p2psecure_socket_consumer.h
index 224493f00..a67634c1e 100644
--- a/libtransport/includes/hicn/transport/interfaces/p2psecure_socket_consumer.h
+++ b/libtransport/includes/hicn/transport/interfaces/p2psecure_socket_consumer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/interfaces/p2psecure_socket_producer.h b/libtransport/includes/hicn/transport/interfaces/p2psecure_socket_producer.h
index d86744514..e197a3658 100644
--- a/libtransport/includes/hicn/transport/interfaces/p2psecure_socket_producer.h
+++ b/libtransport/includes/hicn/transport/interfaces/p2psecure_socket_producer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -15,7 +15,6 @@
 
 #pragma once
 
-#include <hicn/transport/auth/identity.h>
 #include <hicn/transport/interfaces/socket_producer.h>
 
 namespace transport {
@@ -25,8 +24,8 @@ namespace interface {
 class P2PSecureProducerSocket : public ProducerSocket {
  public:
   P2PSecureProducerSocket();
-  P2PSecureProducerSocket(bool rtc,
-                          const std::shared_ptr<auth::Identity> &identity);
+  P2PSecureProducerSocket(bool rtc, std::string &keystore_path,
+                          std::string &keystore_pwd);
   ~P2PSecureProducerSocket() = default;
 };
 
diff --git a/libtransport/includes/hicn/transport/interfaces/portal.h b/libtransport/includes/hicn/transport/interfaces/portal.h
index 66fc84256..1a22b1f1d 100644
--- a/libtransport/includes/hicn/transport/interfaces/portal.h
+++ b/libtransport/includes/hicn/transport/interfaces/portal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -19,6 +19,8 @@
 #include <hicn/transport/core/content_object.h>
 #include <hicn/transport/core/interest.h>
 #include <hicn/transport/core/prefix.h>
+#include <hicn/transport/utils/event_thread.h>
+#include <hicn/transport/utils/noncopyable.h>
 
 #include <functional>
 
@@ -28,58 +30,18 @@ namespace transport {
 
 namespace interface {
 
-template <typename PrefixType>
-class BasicBindConfig {
-  static_assert(std::is_same<core::Prefix, PrefixType>::value,
-                "Prefix must be a Prefix type.");
-
-  const uint32_t standard_cs_reserved = 5000;
-
- public:
-  template <typename T>
-  BasicBindConfig(T &&prefix)
-      : prefix_(std::forward<T &&>(prefix)),
-        content_store_reserved_(standard_cs_reserved) {}
-
-  template <typename T>
-  BasicBindConfig(T &&prefix, uint32_t cs_reserved)
-      : prefix_(std::forward<T &&>(prefix)),
-        content_store_reserved_(cs_reserved) {}
-
-  TRANSPORT_ALWAYS_INLINE const PrefixType &prefix() const { return prefix_; }
-
-  TRANSPORT_ALWAYS_INLINE uint32_t csReserved() const {
-    return content_store_reserved_;
-  }
-
- private:
-  PrefixType prefix_;
-  uint32_t content_store_reserved_;
-};
-
-using BindConfig = BasicBindConfig<core::Prefix>;
-
-class Portal {
+class Portal : private utils::NonCopyable {
  public:
   /**
-   * Consumer callback is an abstract class containing two methods to be
-   * implemented by a consumer application.
+   * Transport callback is an abstract class containing two methods to be
+   * implemented by a consumer/producer application.
    */
-  class ConsumerCallback {
+  class TransportCallback {
    public:
+    virtual void onInterest(core::Interest &i) = 0;
     virtual void onContentObject(core::Interest &i, core::ContentObject &c) = 0;
     virtual void onTimeout(core::Interest::Ptr &i, const core::Name &n) = 0;
-    virtual void onError(std::error_code ec) = 0;
-  };
-
-  /**
-   * Producer callback is an abstract class containing two methods to be
-   * implemented by a producer application.
-   */
-  class ProducerCallback {
-   public:
-    virtual void onInterest(core::Interest &i) = 0;
-    virtual void onError(std::error_code ec) = 0;
+    virtual void onError(const std::error_code &ec) = 0;
   };
 
   using OnContentObjectCallback =
@@ -89,21 +51,14 @@ class Portal {
 
   Portal();
 
-  Portal(asio::io_service &io_service);
+  Portal(::utils::EventThread &worker);
 
   /**
-   * Set the consumer callback.
-   *
-   * @param consumer_callback - The pointer to the ConsumerCallback object.
-   */
-  void setConsumerCallback(ConsumerCallback *consumer_callback);
-
-  /**
-   * Set the producer callback.
+   * Set the transport protocl callback.
    *
    * @param producer_callback - The pointer to the ProducerCallback object.
    */
-  void setProducerCallback(ProducerCallback *producer_callback);
+  void registerTransportCallback(TransportCallback *transport_callback);
 
   /**
    * Connect the transport to the local hicn forwarder.
@@ -146,34 +101,12 @@ class Portal {
           UNSET_CALLBACK);
 
   /**
-   * Register a producer name to the local forwarder and optionally set the
-   * content store size in a per-face manner.
-   *
-   * @param config - The configuration for the local forwarder binding.
-   */
-  void bind(const BindConfig &config);
-
-  void runEventsLoop();
-
-  /**
-   * Run one event and return.
-   */
-  void runOneEvent();
-
-  /**
    * Send a data packet to the local forwarder. As opposite to sendInterest, the
    * ownership of the content object is not transferred to the portal.
    *
    * @param content_object - The data packet.
    */
   void sendContentObject(core::ContentObject &content_object);
-  /**
-   * Stop the event loop, canceling all the pending events in the event queue.
-   *
-   * Beware that stopping the event loop DOES NOT disconnect the transport from
-   * the local forwarder, the connector underneath will stay connected.
-   */
-  void stopEventsLoop();
 
   /**
    * Disconnect the transport from the local forwarder.
@@ -188,15 +121,26 @@ class Portal {
   /**
    * Get a reference to the io_service object.
    */
-  asio::io_service &getIoService();
+  utils::EventThread &getThread();
 
   /**
    * Register a route to the local forwarder.
    */
   void registerRoute(core::Prefix &prefix);
 
+  /**
+   * Send a MAP-Me command to traverse NATs.
+   */
+  void sendMapme();
+
+  /**
+   * Set forwarding strategy
+   */
+  void setForwardingStrategy(core::Prefix &prefix, std::string &strategy);
+
  private:
-  void *implementation_;
+  class Impl;
+  Impl *implementation_;
 };
 
 }  // namespace interface
diff --git a/libtransport/includes/hicn/transport/interfaces/publication_options.h b/libtransport/includes/hicn/transport/interfaces/publication_options.h
index 6910e5371..03a0763f5 100644
--- a/libtransport/includes/hicn/transport/interfaces/publication_options.h
+++ b/libtransport/includes/hicn/transport/interfaces/publication_options.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/interfaces/socket_consumer.h b/libtransport/includes/hicn/transport/interfaces/socket_consumer.h
index 5e0e81b9f..e26fe5a85 100644
--- a/libtransport/includes/hicn/transport/interfaces/socket_consumer.h
+++ b/libtransport/includes/hicn/transport/interfaces/socket_consumer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -23,6 +23,8 @@
 #include <hicn/transport/interfaces/callbacks.h>
 #include <hicn/transport/interfaces/socket_options_default_values.h>
 #include <hicn/transport/interfaces/socket_options_keys.h>
+#include <hicn/transport/utils/event_thread.h>
+#include <hicn/transport/utils/noncopyable.h>
 
 #define CONSUMER_FINISHED 0
 #define CONSUMER_BUSY 1
@@ -45,7 +47,7 @@ using namespace core;
  * It allows to retrieve an application data from one/many producers, by
  * hiding all the complexity of the transport protocol used underneath.
  */
-class ConsumerSocket {
+class ConsumerSocket : private utils::NonCopyable {
  public:
   /**
    * The ReadCallback is a class which can be used by the transport for both
@@ -124,7 +126,7 @@ class ConsumerSocket {
      *
      * @param ec - An error code describing the error.
      */
-    virtual void readError(const std::error_code ec) noexcept = 0;
+    virtual void readError(const std::error_code &ec) noexcept = 0;
 
     /**
      * This callback will be invoked when the whole content is retrieved. The
@@ -166,7 +168,12 @@ class ConsumerSocket {
    * 110, 104-117
    *  - RTC: Real time communication
    */
-  explicit ConsumerSocket(int protocol, asio::io_service &io_service);
+  explicit ConsumerSocket(int protocol, ::utils::EventThread &worker);
+
+  /**
+   * @brief Move contructor
+   */
+  ConsumerSocket(ConsumerSocket &&other) noexcept;
 
   /**
    * @brief Destroy the consumer socket.
@@ -200,12 +207,10 @@ class ConsumerSocket {
    * content retrieval succeeded. This information can be obtained from the
    * error code in CONTENT_RETRIEVED callback.
    */
-  int consume(const Name &name);
-  int asyncConsume(const Name &name);
+  int consume(const Name &name, bool blocking = false);
 
   /**
-   * Stops the consumer socket. If several downloads are queued (using
-   * asyncConsume), this call stops just the current one.
+   * Stops the consumer socket.
    */
   void stop();
 
@@ -255,6 +260,12 @@ class ConsumerSocket {
   int setSocketOption(int socket_option_key,
                       ConsumerTimerCallback socket_option_value);
 
+  int setSocketOption(int socket_option_key,
+                      StrategyCallback socket_option_value);
+
+  int setSocketOption(int socket_option_key,
+                      Packet::Format socket_option_value);
+
   int getSocketOption(int socket_option_key, double &socket_option_value);
 
   int getSocketOption(int socket_option_key, uint32_t &socket_option_value);
@@ -280,8 +291,14 @@ class ConsumerSocket {
                       ConsumerTimerCallback **socket_option_value);
 
   int getSocketOption(int socket_option_key,
+                      StrategyCallback **socket_option_value);
+
+  int getSocketOption(int socket_option_key,
                       interface::TransportStatistics **socket_option_value);
 
+  int getSocketOption(int socket_option_key,
+                      Packet::Format &socket_option_value);
+
  protected:
   ConsumerSocket();
   std::unique_ptr<implementation::ConsumerSocket> socket_;
diff --git a/libtransport/includes/hicn/transport/interfaces/socket_options_default_values.h b/libtransport/includes/hicn/transport/interfaces/socket_options_default_values.h
index f4945ac8a..04454852b 100644
--- a/libtransport/includes/hicn/transport/interfaces/socket_options_default_values.h
+++ b/libtransport/includes/hicn/transport/interfaces/socket_options_default_values.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -15,7 +15,10 @@
 
 #pragma once
 
+extern "C" {
 #include <hicn/base.h>
+#include <hicn/compat.h>
+}
 
 #include <chrono>
 #include <cstdint>
@@ -26,6 +29,16 @@ namespace interface {
 
 namespace default_values {
 
+// Packet format
+// #define NEW_PACKET_FORMAT
+static constexpr hicn_format_t packet_format =
+#ifdef NEW_PACKET_FORMAT
+    HF_INET6_UDP;
+#else
+    HF_INET6_TCP;
+#endif
+
+// Parameters
 static constexpr uint32_t interest_lifetime = 1001;  // milliseconds
 static constexpr uint32_t never_expire_time = HICN_MAX_LIFETIME;
 static constexpr uint32_t content_object_expiry_time =
@@ -40,6 +53,8 @@ static constexpr uint32_t key_locator_size = 60;          // bytes
 static constexpr uint32_t limit_guard = 80;               // bytes
 static constexpr uint32_t digest_size = 34;               // bytes
 static constexpr uint32_t max_out_of_order_segments = 3;  // content object
+static constexpr uint32_t max_unverified_delay = 2001;    // milliseconds
+static constexpr uint32_t manifest_capacity = 30;
 
 // RAAQM
 static constexpr int sample_number = 30;
diff --git a/libtransport/includes/hicn/transport/interfaces/socket_options_keys.h b/libtransport/includes/hicn/transport/interfaces/socket_options_keys.h
index 00cd44075..90f218770 100644
--- a/libtransport/includes/hicn/transport/interfaces/socket_options_keys.h
+++ b/libtransport/includes/hicn/transport/interfaces/socket_options_keys.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -26,15 +26,27 @@ namespace transport {
 namespace interface {
 
 typedef enum {
-  RAAQM = 0,
-  CBR = 1,
-  RTC = 2,
+  UNKNOWN = 0,
+  BYTE_STREAM = 1,
+  RTC_PROD = 2,
+} ProductionProtocolAlgorithms;
+
+typedef enum {
+  RAAQM = 10,
+  CBR = 11,
+  RTC = 12,
 } TransportProtocolAlgorithms;
 
 typedef enum {
-  BYTE_STREAM = 10,
-  RTC_PROD = 11,
-} ProductionProtocolAlgorithms;
+  RECOVERY_OFF = 20,
+  RTX_ONLY = 21,
+  FEC_ONLY = 22,
+  DELAY_BASED = 23,
+  LOW_RATE = 24,
+  LOW_RATE_AND_BESTPATH = 25,
+  LOW_RATE_AND_REPLICATION = 26,
+  LOW_RATE_AND_ALL_FWD_STRATEGIES = 27,
+} RtcTransportRecoveryStrategies;
 
 typedef enum {
   INPUT_BUFFER_SIZE = 101,
@@ -45,6 +57,8 @@ typedef enum {
   DATA_PACKET_SIZE = 106,
   INTEREST_LIFETIME = 107,
   CONTENT_OBJECT_EXPIRY_TIME = 108,
+  MAX_SEGMENT_SIZE = 109,
+  MAX_UNVERIFIED_TIME = 110,
   MIN_WINDOW_SIZE = 111,
   MAX_WINDOW_SIZE = 112,
   CURRENT_WINDOW_SIZE = 113,
@@ -57,7 +71,9 @@ typedef enum {
   SIGNER = 121,
   VERIFIER = 122,
   STATS_INTERVAL = 125,
-  SUFFIX_STRATEGY = 126
+  SUFFIX_STRATEGY = 126,
+  PACKET_FORMAT = 127,
+  FEC_TYPE = 128,
 } GeneralTransportOptions;
 
 typedef enum {
@@ -87,7 +103,9 @@ typedef enum {
   CONTENT_OBJECT_TO_VERIFY = 413,
   VERIFICATION_FAILED = 414,
   READ_CALLBACK = 415,
-  STATS_SUMMARY = 416
+  STATS_SUMMARY = 416,
+  FWD_STRATEGY_CHANGE = 417,
+  REC_STRATEGY_CHANGE = 418,
 } ConsumerCallbacksOptions;
 
 typedef enum {
@@ -100,7 +118,8 @@ typedef enum {
   CONTENT_OBJECT_READY = 510,
   CONTENT_OBJECT_OUTPUT = 511,
   CONTENT_PRODUCED = 512,
-  CONTENT_OBJECT_TO_SIGN = 513
+  CONTENT_OBJECT_TO_SIGN = 513,
+  PRODUCER_CALLBACK = 514,
 } ProducerCallbacksOptions;
 
 typedef enum { OUTPUT_INTERFACE = 601 } DataLinkOptions;
@@ -116,6 +135,11 @@ typedef enum {
   RSA_256 = 802,
 } SignatureType;
 
+typedef enum {
+  RECOVERY_STRATEGY = 901,
+  AGGREGATED_DATA = 902,
+} RtcTransportOptions;
+
 }  // namespace interface
 
 }  // end namespace transport
diff --git a/libtransport/includes/hicn/transport/interfaces/socket_producer.h b/libtransport/includes/hicn/transport/interfaces/socket_producer.h
index 27b603dfe..77b89742a 100644
--- a/libtransport/includes/hicn/transport/interfaces/socket_producer.h
+++ b/libtransport/includes/hicn/transport/interfaces/socket_producer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -23,6 +23,8 @@
 #include <hicn/transport/interfaces/callbacks.h>
 #include <hicn/transport/interfaces/socket_options_default_values.h>
 #include <hicn/transport/interfaces/socket_options_keys.h>
+#include <hicn/transport/utils/event_thread.h>
+#include <hicn/transport/utils/noncopyable.h>
 
 namespace transport {
 
@@ -34,12 +36,28 @@ namespace interface {
 
 using namespace core;
 
-class ProducerSocket {
+class ProducerSocket : private utils::NonCopyable {
  public:
+  /**
+   * @brief This class is used by the transport to notify events to the
+   * application.
+   */
+  class Callback {
+   public:
+    /**
+     * @brief This will invoked in an error occurred in the production protocol.
+     *
+     * @param ec - An error code describing the error.
+     */
+    virtual void produceError(const std::error_code &ec) noexcept = 0;
+  };
+
   explicit ProducerSocket(
       int protocol = ProductionProtocolAlgorithms::BYTE_STREAM);
 
-  explicit ProducerSocket(int protocol, asio::io_service &io_service);
+  explicit ProducerSocket(int protocol, ::utils::EventThread &worker);
+
+  ProducerSocket(ProducerSocket &&other) noexcept;
 
   virtual ~ProducerSocket();
 
@@ -63,21 +81,18 @@ class ProducerSocket {
   uint32_t produceDatagram(const Name &content_name,
                            std::unique_ptr<utils::MemBuf> &&buffer);
 
-  void asyncProduce(const Name &suffix, const uint8_t *buf, size_t buffer_size,
-                    bool is_last = true, uint32_t *start_offset = nullptr);
-
-  void asyncProduce(Name content_name, std::unique_ptr<utils::MemBuf> &&buffer,
-                    bool is_last, uint32_t offset,
-                    uint32_t **last_segment = nullptr);
-
   void produce(ContentObject &content_object);
 
-  void serveForever();
+  void sendMapme();
 
   void stop();
 
+  void start();
+
   asio::io_service &getIoService();
 
+  int setSocketOption(int socket_option_key, Callback *socket_option_value);
+
   int setSocketOption(int socket_option_key, uint32_t socket_option_value);
 
   int setSocketOption(int socket_option_key,
@@ -111,6 +126,9 @@ class ProducerSocket {
   int setSocketOption(int socket_option_key,
                       const std::string &socket_option_value);
 
+  int setSocketOption(int socket_option_key,
+                      Packet::Format socket_option_value);
+
   int getSocketOption(int socket_option_key, uint32_t &socket_option_value);
 
   int getSocketOption(int socket_option_key, bool &socket_option_value);
@@ -138,6 +156,9 @@ class ProducerSocket {
 
   int getSocketOption(int socket_option_key, std::string &socket_option_value);
 
+  int getSocketOption(int socket_option_key,
+                      Packet::Format &socket_option_value);
+
  protected:
   ProducerSocket(bool);
   std::unique_ptr<implementation::ProducerSocket> socket_;
diff --git a/libtransport/includes/hicn/transport/interfaces/statistics.h b/libtransport/includes/hicn/transport/interfaces/statistics.h
index 1ff6f3edd..4d9e1bfe2 100644
--- a/libtransport/includes/hicn/transport/interfaces/statistics.h
+++ b/libtransport/includes/hicn/transport/interfaces/statistics.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,6 +16,7 @@
 #pragma once
 
 #include <hicn/transport/portability/c_portability.h>
+#include <hicn/transport/utils/chrono_typedefs.h>
 
 #include <cstdint>
 
@@ -37,6 +38,8 @@ class TransportStatistics {
   static constexpr double default_alpha = 0.7;
 
  public:
+  enum class statsAlerts : uint8_t { CONGESTION, LATENCY, LOSSES };
+
   TransportStatistics(double alpha = default_alpha)
       : retx_count_(0),
         bytes_received_(0),
@@ -51,11 +54,15 @@ class TransportStatistics {
         lost_data_(0),
         definitely_lost_data_(0),
         recovered_data_(0),
-        status_(-1),
+        status_(0),
         // avg_data_rtt_(0),
         avg_pending_pkt_(0.0),
         received_nacks_(0),
-        received_fec_(0) {}
+        received_fec_(0),
+        in_congestion_(false),
+        residual_loss_rate_(0.0),
+        quality_score_(5),
+        alerts_(0) {}
 
   TRANSPORT_ALWAYS_INLINE void updateRetxCount(uint64_t retx) {
     retx_count_ += retx;
@@ -65,8 +72,11 @@ class TransportStatistics {
     bytes_received_ += bytes;
   }
 
-  TRANSPORT_ALWAYS_INLINE void updateAverageRtt(uint64_t rtt) {
-    average_rtt_ = (alpha_ * average_rtt_) + ((1. - alpha_) * double(rtt));
+  TRANSPORT_ALWAYS_INLINE void updateAverageRtt(
+      const utils::SteadyTime::Milliseconds &rtt) {
+    auto rtt_milliseconds = rtt.count();
+    average_rtt_ =
+        (alpha_ * average_rtt_) + ((1. - alpha_) * double(rtt_milliseconds));
   }
 
   TRANSPORT_ALWAYS_INLINE void updateAverageWindowSize(double current_window) {
@@ -120,6 +130,26 @@ class TransportStatistics {
     received_fec_ += pkt;
   }
 
+  TRANSPORT_ALWAYS_INLINE void updateResidualLossRate(double val) {
+    residual_loss_rate_ = val;
+  }
+
+  TRANSPORT_ALWAYS_INLINE void updateQualityScore(uint8_t val) {
+    quality_score_ = val;
+  }
+
+  TRANSPORT_ALWAYS_INLINE void updateCongestionState(bool state) {
+    in_congestion_ = state;
+  }
+
+  TRANSPORT_ALWAYS_INLINE void setAlert(statsAlerts x) {
+    alerts_ |= 1UL << (uint32_t)x;
+  }
+
+  TRANSPORT_ALWAYS_INLINE void clearAlert(statsAlerts x) {
+    alerts_ &= ~(1UL << (uint32_t)x);
+  }
+
   TRANSPORT_ALWAYS_INLINE uint64_t getRetxCount() const { return retx_count_; }
 
   TRANSPORT_ALWAYS_INLINE uint64_t getBytesRecv() const {
@@ -174,6 +204,18 @@ class TransportStatistics {
     return received_fec_;
   }
 
+  TRANSPORT_ALWAYS_INLINE double getResidualLossRate() const {
+    return residual_loss_rate_;
+  }
+
+  TRANSPORT_ALWAYS_INLINE uint8_t getQualityScore() const {
+    return quality_score_;
+  }
+
+  TRANSPORT_ALWAYS_INLINE bool isCongested() const { return in_congestion_; }
+
+  TRANSPORT_ALWAYS_INLINE uint32_t getAlerts() const { return alerts_; }
+
   TRANSPORT_ALWAYS_INLINE void setAlpha(double val) { alpha_ = val; }
 
   TRANSPORT_ALWAYS_INLINE void reset() {
@@ -193,6 +235,8 @@ class TransportStatistics {
     avg_pending_pkt_ = 0;
     received_nacks_ = 0;
     received_fec_ = 0;
+    in_congestion_ = false;
+    quality_score_ = 5;
   }
 
  private:
@@ -213,6 +257,14 @@ class TransportStatistics {
   double avg_pending_pkt_;
   uint32_t received_nacks_;
   uint32_t received_fec_;
+  bool in_congestion_;
+  double residual_loss_rate_;
+  uint8_t quality_score_;
+
+  // alerts is a bit vector used to signal to the upper layer that
+  // something bad is appening in the network, the encode is done accoding to
+  // the enum alerts;
+  uint32_t alerts_;
 };
 
 }  // namespace interface
diff --git a/libtransport/includes/hicn/transport/portability/CMakeLists.txt b/libtransport/includes/hicn/transport/portability/CMakeLists.txt
index 8094c0661..7a688b1f1 100644
--- a/libtransport/includes/hicn/transport/portability/CMakeLists.txt
+++ b/libtransport/includes/hicn/transport/portability/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -14,6 +14,7 @@
 list(APPEND HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/c_portability.h
   ${CMAKE_CURRENT_SOURCE_DIR}/portability.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/cpu.h
 )
 
 list(APPEND SOURCE_FILES
diff --git a/libtransport/includes/hicn/transport/portability/c_portability.h b/libtransport/includes/hicn/transport/portability/c_portability.h
index 2675de000..bc697d8b1 100644
--- a/libtransport/includes/hicn/transport/portability/c_portability.h
+++ b/libtransport/includes/hicn/transport/portability/c_portability.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Copyright 2017 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/libtransport/includes/hicn/transport/portability/cpu.h b/libtransport/includes/hicn/transport/portability/cpu.h
new file mode 100644
index 000000000..036bf9cd9
--- /dev/null
+++ b/libtransport/includes/hicn/transport/portability/cpu.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2022 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#if defined(__aarch64__) && defined(__ARM_NEON) || defined(__i686__)
+#define TRANSPORT_HAVE_VEC128
+#endif
+
+#if defined(__SSE4_2__) && __GNUC__ >= 4
+#define TRANSPORT_HAVE_VEC128
+#endif
+
+#if defined(__ALTIVEC__)
+#define TRANSPORT_HAVE_VEC128
+#endif
+
+#if defined(__AVX2__)
+#define TRANSPORT_HAVE_VEC256
+#if defined(__clang__) && __clang_major__ < 4
+#undef TRANSPORT_HAVE_VEC256
+#endif
+#endif
+
+#if defined(__AVX512BITALG__)
+#define TRANSPORT_HAVE_VEC512
+#endif
diff --git a/libtransport/includes/hicn/transport/portability/portability.h b/libtransport/includes/hicn/transport/portability/portability.h
index 24ef012f7..b093f8892 100644
--- a/libtransport/includes/hicn/transport/portability/portability.h
+++ b/libtransport/includes/hicn/transport/portability/portability.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Copyright 2017 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -28,9 +28,6 @@
 
 namespace portability {
 
-constexpr bool little_endian_arch = __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__;
-constexpr bool big_endian_arch = !little_endian_arch;
-
 // Generalize warning push/pop.
 #if defined(__GNUC__) || defined(__clang__)
 // Clang & GCC
diff --git a/libtransport/includes/hicn/transport/portability/win_portability.h b/libtransport/includes/hicn/transport/portability/win_portability.h
index 24c7a932a..81aa828cd 100644
--- a/libtransport/includes/hicn/transport/portability/win_portability.h
+++ b/libtransport/includes/hicn/transport/portability/win_portability.h
@@ -1,44 +1,44 @@
-/*

- * Copyright (c) 2017-2019 Cisco and/or its affiliates.

- * Copyright 2017 Facebook, Inc.

- *

- * Licensed under the Apache License, Version 2.0 (the "License");

- * you may not use this file except in compliance with the License.

- * You may obtain a copy of the License at

- *

- *   http://www.apache.org/licenses/LICENSE-2.0

- *

- * Unless required by applicable law or agreed to in writing, software

- * distributed under the License is distributed on an "AS IS" BASIS,

- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

- * See the License for the specific language governing permissions and

- * limitations under the License.

- */

-

-#pragma once

-#define WIN32_LEAN_AND_MEAN

-#ifndef NOMINMAX

-#define NOMINMAX

-#endif

-#include <fcntl.h>

-#include <io.h>

-#include <stdint.h>

-#include <stdio.h>

-#include <string.h>

-#include <sys/stat.h>

-#include <sys/types.h>

-#include <time.h>

-#include <windows.h>

-#include <winsock2.h>

-#include <ws2ipdef.h>

-#include <ws2tcpip.h>

-

-#include <algorithm>

-

-#define __ORDER_LITTLE_ENDIAN__ 0x41424344UL

-#define __ORDER_BIG_ENDIAN__ 0x44434241UL

-#define __BYTE_ORDER__ ('ABCD')

-#undef DELETE

-

-#define HAVE_STRUCT_TIMESPEC

+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Copyright 2017 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#define WIN32_LEAN_AND_MEAN
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <fcntl.h>
+#include <io.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+#include <windows.h>
+#include <winsock2.h>
+#include <ws2ipdef.h>
+#include <ws2tcpip.h>
+
+#include <algorithm>
+
+#define __ORDER_LITTLE_ENDIAN__ 0x41424344UL
+#define __ORDER_BIG_ENDIAN__ 0x44434241UL
+#define __BYTE_ORDER__ ('ABCD')
+#undef DELETE
+
+#define HAVE_STRUCT_TIMESPEC
 #include <pthread.h>
\ No newline at end of file
diff --git a/libtransport/includes/hicn/transport/utils/CMakeLists.txt b/libtransport/includes/hicn/transport/utils/CMakeLists.txt
index 75f727f03..bbd149e09 100644
--- a/libtransport/includes/hicn/transport/utils/CMakeLists.txt
+++ b/libtransport/includes/hicn/transport/utils/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -19,6 +19,7 @@ list(APPEND HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/chrono_typedefs.h
   ${CMAKE_CURRENT_SOURCE_DIR}/branch_prediction.h
   ${CMAKE_CURRENT_SOURCE_DIR}/ring_buffer.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_quality_score.h
   ${CMAKE_CURRENT_SOURCE_DIR}/literals.h
   ${CMAKE_CURRENT_SOURCE_DIR}/conversions.h
   ${CMAKE_CURRENT_SOURCE_DIR}/linux.h
diff --git a/libtransport/includes/hicn/transport/utils/array.h b/libtransport/includes/hicn/transport/utils/array.h
index 7c0ed65d8..d57bfabaf 100644
--- a/libtransport/includes/hicn/transport/utils/array.h
+++ b/libtransport/includes/hicn/transport/utils/array.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/utils/branch_prediction.h b/libtransport/includes/hicn/transport/utils/branch_prediction.h
index 8cbfaca76..626cb1573 100644
--- a/libtransport/includes/hicn/transport/utils/branch_prediction.h
+++ b/libtransport/includes/hicn/transport/utils/branch_prediction.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/utils/chrono_typedefs.h b/libtransport/includes/hicn/transport/utils/chrono_typedefs.h
index 8f28e763c..ddfbd00cd 100644
--- a/libtransport/includes/hicn/transport/utils/chrono_typedefs.h
+++ b/libtransport/includes/hicn/transport/utils/chrono_typedefs.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -17,11 +17,102 @@
 
 #include <chrono>
 
+namespace std {
+namespace chrono {
+namespace detail {
+
+template <typename From, typename To>
+struct posix_duration_cast;
+
+// chrono -> timespec caster
+template <typename Rep, typename Period>
+struct posix_duration_cast<std::chrono::duration<Rep, Period>,
+                           struct timespec> {
+  static struct timespec cast(std::chrono::duration<Rep, Period> const &d) {
+    struct timespec tv;
+
+    std::chrono::seconds const sec =
+        std::chrono::duration_cast<std::chrono::seconds>(d);
+
+    tv.tv_sec = sec.count();
+    tv.tv_nsec =
+        std::chrono::duration_cast<std::chrono::nanoseconds>(d - sec).count();
+
+    return tv;
+  }
+};
+
+// timespec -> chrono caster
+template <typename Rep, typename Period>
+struct posix_duration_cast<struct timespec,
+                           std::chrono::duration<Rep, Period>> {
+  static std::chrono::duration<Rep, Period> cast(struct timespec const &tv) {
+    return std::chrono::duration_cast<std::chrono::duration<Rep, Period>>(
+        std::chrono::seconds(tv.tv_sec) + std::chrono::nanoseconds(tv.tv_nsec));
+  }
+};
+
+}  // namespace detail
+
+// chrono -> timespec
+template <typename T, typename Rep, typename Period>
+auto duration_cast(std::chrono::duration<Rep, Period> const &d) ->
+    typename std::enable_if<std::is_same<T, struct timespec>::value,
+                            struct timespec>::type {
+  return detail::posix_duration_cast<std::chrono::duration<Rep, Period>,
+                                     timespec>::cast(d);
+}
+
+// timespec -> chrono
+template <typename Duration>
+Duration duration_cast(struct timespec const &tv) {
+  return detail::posix_duration_cast<struct timespec, Duration>::cast(tv);
+}
+
+}  // namespace chrono
+}  // namespace std
+
 namespace utils {
 
-using SteadyClock = std::chrono::steady_clock;
-using TimePoint = SteadyClock::time_point;
-using Milliseconds = std::chrono::milliseconds;
-using Microseconds = std::chrono::microseconds;
+template <typename T>
+class Time {
+ public:
+  using Clock = T;
+  using TimePoint = typename Clock::time_point;
+  using Rep = double;
+  using Seconds = std::chrono::duration<Rep>;
+  using Milliseconds = std::chrono::duration<Rep, std::milli>;
+  using Microseconds = std::chrono::duration<Rep, std::micro>;
+
+  static auto now() { return Clock::now(); }
+
+  // From epochs
+  static auto nowMs() {
+    return std::chrono::duration_cast<Milliseconds>(now().time_since_epoch());
+  }
+
+  // From epoch
+  static auto nowUs() {
+    return std::chrono::duration_cast<Microseconds>(now().time_since_epoch());
+  }
+
+  template <typename D>
+  static auto getDuration(const TimePoint &start, const TimePoint &end) {
+    return std::chrono::duration_cast<D>(end - start);
+  }
+
+  static auto getDurationS(const TimePoint &start, const TimePoint &end) {
+    return getDuration<Seconds>(start, end);
+  }
+  static auto getDurationMs(const TimePoint &start, const TimePoint &end) {
+    return getDuration<Milliseconds>(start, end);
+  }
+  static auto getDurationUs(const TimePoint &start, const TimePoint &end) {
+    return getDuration<Microseconds>(start, end);
+  }
+};
+
+using SteadyTime = Time<std::chrono::steady_clock>;
+using SystemTime = Time<std::chrono::system_clock>;
 
 }  // namespace utils
diff --git a/libtransport/includes/hicn/transport/utils/conversions.h b/libtransport/includes/hicn/transport/utils/conversions.h
index 52d3e3168..812803175 100644
--- a/libtransport/includes/hicn/transport/utils/conversions.h
+++ b/libtransport/includes/hicn/transport/utils/conversions.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/utils/daemonizator.h b/libtransport/includes/hicn/transport/utils/daemonizator.h
index 028d74865..1d0a0b309 100644
--- a/libtransport/includes/hicn/transport/utils/daemonizator.h
+++ b/libtransport/includes/hicn/transport/utils/daemonizator.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/utils/event_thread.h b/libtransport/includes/hicn/transport/utils/event_thread.h
index 15ec1d62c..2cd2f3aca 100644
--- a/libtransport/includes/hicn/transport/utils/event_thread.h
+++ b/libtransport/includes/hicn/transport/utils/event_thread.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -97,6 +97,19 @@ class EventThread {
     io_service_.get().dispatch(std::forward<Func&&>(f));
   }
 
+  template <typename Func>
+  void addAndWaitForExecution(Func&& f) {
+    auto promise = std::promise<void>();
+    auto future = promise.get_future();
+
+    asio::dispatch(io_service_.get(), [&promise, f = std::forward<Func>(f)]() {
+      f();
+      promise.set_value();
+    });
+
+    future.wait();
+  }
+
   void stop() {
     work_.reset();
 
diff --git a/libtransport/includes/hicn/transport/utils/fixed_block_allocator.h b/libtransport/includes/hicn/transport/utils/fixed_block_allocator.h
index 298b6f9d1..19b52b37e 100644
--- a/libtransport/includes/hicn/transport/utils/fixed_block_allocator.h
+++ b/libtransport/includes/hicn/transport/utils/fixed_block_allocator.h
@@ -1,23 +1,28 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  */
 
 #pragma once
 
 #include <hicn/transport/portability/c_portability.h>
+#include <hicn/transport/utils/branch_prediction.h>
 #include <hicn/transport/utils/singleton.h>
 #include <hicn/transport/utils/spinlock.h>
 #include <stdint.h>
 
 #include <cassert>
 #include <cstdlib>
+#include <list>
 #include <memory>
 
 namespace utils {
 template <std::size_t SIZE = 512, std::size_t OBJECTS = 4096>
 class FixedBlockAllocator
-    : public utils::Singleton<FixedBlockAllocator<SIZE, OBJECTS>> {
-  friend class utils::Singleton<FixedBlockAllocator<SIZE, OBJECTS>>;
+    : public utils::ThreadLocalSingleton<FixedBlockAllocator<SIZE, OBJECTS>> {
+  friend class utils::ThreadLocalSingleton<FixedBlockAllocator<SIZE, OBJECTS>>;
+
+  static inline const std::size_t BLOCK_SIZE = SIZE;
+  static inline const std::size_t BLOCKS_PER_POOL = OBJECTS;
 
  public:
   ~FixedBlockAllocator() {
@@ -26,19 +31,19 @@ class FixedBlockAllocator
     }
   }
 
-  void* allocateBlock(size_t size = SIZE) {
-    assert(size <= SIZE);
+  void* allocateBlock() {
     uint32_t index;
-
     SpinLock::Acquire locked(lock_);
     void* p_block = pop();
     if (!p_block) {
-      if (TRANSPORT_EXPECT_FALSE(current_pool_index_ >= max_objects_)) {
+      if (TRANSPORT_EXPECT_FALSE(current_pool_index_ >= BLOCKS_PER_POOL)) {
         // Allocate new memory block
         p_pools_.emplace_front(
-            new typename std::aligned_storage<SIZE>::type[max_objects_]);
+            new typename std::aligned_storage<SIZE>::type[BLOCKS_PER_POOL]);
         // reset current_pool_index_
         current_pool_index_ = 0;
+        // Increase total block count
+        block_count_ += BLOCKS_PER_POOL;
       }
 
       auto& latest = p_pools_.front();
@@ -59,7 +64,7 @@ class FixedBlockAllocator
   }
 
  public:
-  std::size_t blockSize() { return block_size_; }
+  std::size_t blockSize() { return BLOCK_SIZE; }
 
   uint32_t blockCount() { return block_count_; }
 
@@ -69,20 +74,32 @@ class FixedBlockAllocator
 
   uint32_t deallocations() { return deallocations_; }
 
+  void reset() {
+    p_head_ = nullptr;
+    blocks_in_use_ = 0;
+    allocations_ = 0;
+    deallocations_ = 0;
+    current_pool_index_ = 0;
+    block_count_ = BLOCKS_PER_POOL;
+
+    // Delete all memory pools but the first one
+    for (auto it = std::next(p_pools_.begin()); it != p_pools_.end();) {
+      delete[] * it;
+      it = p_pools_.erase(it);
+    }
+  }
+
  private:
   FixedBlockAllocator()
-      : block_size_(SIZE),
-        object_size_(SIZE),
-        max_objects_(OBJECTS),
-        p_head_(NULL),
+      : p_head_(NULL),
         current_pool_index_(0),
-        block_count_(0),
+        block_count_(BLOCKS_PER_POOL),
         blocks_in_use_(0),
         allocations_(0),
         deallocations_(0) {
     static_assert(SIZE >= sizeof(long*), "SIZE must be at least 8 bytes");
     p_pools_.emplace_front(
-        new typename std::aligned_storage<SIZE>::type[max_objects_]);
+        new typename std::aligned_storage<SIZE>::type[BLOCKS_PER_POOL]);
   }
 
   void push(void* p_memory) {
@@ -106,12 +123,6 @@ class FixedBlockAllocator
     Block* p_next;
   };
 
-  static std::unique_ptr<FixedBlockAllocator> instance_;
-
-  const std::size_t block_size_;
-  const std::size_t object_size_;
-  const std::size_t max_objects_;
-
   Block* p_head_;
   uint32_t current_pool_index_;
   std::list<typename std::aligned_storage<SIZE>::type*> p_pools_;
@@ -123,10 +134,6 @@ class FixedBlockAllocator
   SpinLock lock_;
 };
 
-template <std::size_t A, std::size_t B>
-std::unique_ptr<FixedBlockAllocator<A, B>>
-    FixedBlockAllocator<A, B>::instance_ = nullptr;
-
 /**
  * STL Allocator trait to be used with allocate_shared.
  */
diff --git a/libtransport/includes/hicn/transport/utils/hash.h b/libtransport/includes/hicn/transport/utils/hash.h
index 6815ca4bf..7943596e6 100644
--- a/libtransport/includes/hicn/transport/utils/hash.h
+++ b/libtransport/includes/hicn/transport/utils/hash.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Copyright 2017 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
diff --git a/libtransport/includes/hicn/transport/utils/linux.h b/libtransport/includes/hicn/transport/utils/linux.h
index 4fbf5f01e..03d29c1db 100644
--- a/libtransport/includes/hicn/transport/utils/linux.h
+++ b/libtransport/includes/hicn/transport/utils/linux.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/utils/literals.h b/libtransport/includes/hicn/transport/utils/literals.h
index bd00e0a58..531f67362 100644
--- a/libtransport/includes/hicn/transport/utils/literals.h
+++ b/libtransport/includes/hicn/transport/utils/literals.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/utils/log.h b/libtransport/includes/hicn/transport/utils/log.h
index 0947b755e..f4d39b6b1 100644
--- a/libtransport/includes/hicn/transport/utils/log.h
+++ b/libtransport/includes/hicn/transport/utils/log.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/utils/move_wrapper.h b/libtransport/includes/hicn/transport/utils/move_wrapper.h
index 5dc3b461d..73389948d 100644
--- a/libtransport/includes/hicn/transport/utils/move_wrapper.h
+++ b/libtransport/includes/hicn/transport/utils/move_wrapper.h
@@ -23,6 +23,7 @@ namespace utils {
 template <typename F>
 struct MoveWrapper : F {
   MoveWrapper(F&& f) : F(std::move(f)) {}
+  ~MoveWrapper() = default;
 
   MoveWrapper(MoveWrapper&&) = default;
   MoveWrapper& operator=(MoveWrapper&&) = default;
diff --git a/libtransport/includes/hicn/transport/utils/noncopyable.h b/libtransport/includes/hicn/transport/utils/noncopyable.h
index 83923e647..0c54d24a3 100644
--- a/libtransport/includes/hicn/transport/utils/noncopyable.h
+++ b/libtransport/includes/hicn/transport/utils/noncopyable.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/utils/object_pool.h b/libtransport/includes/hicn/transport/utils/object_pool.h
index d9b28e663..63288c655 100644
--- a/libtransport/includes/hicn/transport/utils/object_pool.h
+++ b/libtransport/includes/hicn/transport/utils/object_pool.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,6 +16,7 @@
 #pragma once
 
 #include <hicn/transport/utils/branch_prediction.h>
+#include <hicn/transport/utils/noncopyable.h>
 #include <hicn/transport/utils/spinlock.h>
 
 #include <deque>
@@ -25,7 +26,7 @@
 namespace utils {
 
 template <typename T>
-class ObjectPool {
+class ObjectPool : private utils::NonCopyable {
   class ObjectDeleter {
    public:
     ObjectDeleter(ObjectPool<T> *pool = nullptr) : pool_(pool) {}
@@ -47,8 +48,20 @@ class ObjectPool {
 
   ObjectPool() : destructor_(false) {}
 
-  // No copies
-  ObjectPool(const ObjectPool &other) = delete;
+  ObjectPool(ObjectPool &&other)
+      : object_pool_lock_(std::move(other.object_pool_lock_)),
+        object_pool_(std::move(other.object_pool_)),
+        destructor_(other.destructor_) {}
+
+  ObjectPool &operator=(ObjectPool &&other) {
+    if (this != &other) {
+      object_pool_lock_ = std::move(other.object_pool_lock_);
+      object_pool_ = std::move(other.object_pool_);
+      destructor_ = other.destructor_;
+    }
+
+    return *this;
+  }
 
   ~ObjectPool() {
     destructor_ = true;
diff --git a/libtransport/includes/hicn/transport/utils/ring_buffer.h b/libtransport/includes/hicn/transport/utils/ring_buffer.h
index 52629b82b..3032032c9 100644
--- a/libtransport/includes/hicn/transport/utils/ring_buffer.h
+++ b/libtransport/includes/hicn/transport/utils/ring_buffer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/utils/rtc_quality_score.h b/libtransport/includes/hicn/transport/utils/rtc_quality_score.h
new file mode 100644
index 000000000..2e8ca97d3
--- /dev/null
+++ b/libtransport/includes/hicn/transport/utils/rtc_quality_score.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+class RTCQualityScore {
+ public:
+  RTCQualityScore(){};
+  ~RTCQualityScore(){};
+
+  uint8_t getQualityScore(uint64_t RTT, uint32_t loss_rate) {
+    uint32_t delay_index = getDelay(RTT);
+    uint32_t loss_index = getLossRate(loss_rate);
+    return quality_score_[loss_index][delay_index];
+  }
+
+ private:
+  // see quality score map
+  uint8_t quality_score_[7][6]{{5, 5, 5, 4, 3, 1}, {5, 4, 3, 2, 1, 1},
+                               {5, 3, 2, 1, 1, 1}, {5, 2, 1, 1, 1, 1},
+                               {4, 1, 1, 1, 1, 1}, {3, 1, 1, 1, 1, 1},
+                               {1, 1, 1, 1, 1, 1}};
+
+  uint8_t getDelay(uint64_t RTT) {
+    uint64_t OWD = RTT / 2;
+    // we should never get a OWD of 0. so we take the first col if OWD is < 5ms
+    if (OWD < 5) return 0;
+    if (OWD < 50) return 1;
+    if (OWD < 100) return 2;
+    if (OWD < 200) return 3;
+    if (OWD < 300) return 4;
+    return 5;
+  }
+
+  uint8_t getLossRate(uint32_t loss_rate) {
+    // we use 3% as mean loss rate
+    if (loss_rate < 3) return 0;
+    if (loss_rate < 10) return 1;
+    if (loss_rate < 20) return 2;
+    if (loss_rate < 30) return 3;
+    if (loss_rate < 40) return 4;
+    if (loss_rate < 50) return 5;
+    return 6;
+  }
+};
+
+}  // namespace rtc
+
+}  // namespace protocol
+
+}  // namespace transport
diff --git a/libtransport/includes/hicn/transport/utils/singleton.h b/libtransport/includes/hicn/transport/utils/singleton.h
index 4b7b19c0a..cdd8b03bf 100644
--- a/libtransport/includes/hicn/transport/utils/singleton.h
+++ b/libtransport/includes/hicn/transport/utils/singleton.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -32,4 +32,17 @@ class Singleton : NonCopyable {
   ~Singleton() {}
 };
 
+template <typename T>
+class ThreadLocalSingleton : NonCopyable {
+ public:
+  static T& getInstance() {
+    static thread_local T instance;
+    return instance;
+  }
+
+ protected:
+  ThreadLocalSingleton() {}
+  ~ThreadLocalSingleton() {}
+};
+
 }  // namespace utils
\ No newline at end of file
diff --git a/libtransport/includes/hicn/transport/utils/spinlock.h b/libtransport/includes/hicn/transport/utils/spinlock.h
index 009a94454..40fc48de3 100644
--- a/libtransport/includes/hicn/transport/utils/spinlock.h
+++ b/libtransport/includes/hicn/transport/utils/spinlock.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/utils/string_tokenizer.h b/libtransport/includes/hicn/transport/utils/string_tokenizer.h
index 36630eb58..2b2b893a0 100644
--- a/libtransport/includes/hicn/transport/utils/string_tokenizer.h
+++ b/libtransport/includes/hicn/transport/utils/string_tokenizer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/utils/string_utils.h b/libtransport/includes/hicn/transport/utils/string_utils.h
index 313c28cc6..5f9cca13b 100644
--- a/libtransport/includes/hicn/transport/utils/string_utils.h
+++ b/libtransport/includes/hicn/transport/utils/string_utils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/includes/hicn/transport/utils/thread_pool.h b/libtransport/includes/hicn/transport/utils/thread_pool.h
new file mode 100644
index 000000000..e4e47209c
--- /dev/null
+++ b/libtransport/includes/hicn/transport/utils/thread_pool.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <hicn/transport/utils/event_thread.h>
+#include <hicn/transport/utils/noncopyable.h>
+
+#include <thread>
+#include <vector>
+
+namespace utils {
+
+class ThreadPool : public NonCopyable {
+ public:
+  explicit ThreadPool(
+      std::size_t n_threads = std::thread::hardware_concurrency())
+      : workers_(n_threads > 0 ? n_threads : 1) {}
+
+  std::size_t getNThreads() const { return workers_.size(); }
+  EventThread &getWorker(std::size_t i) { return workers_.at(i); }
+
+ private:
+  std::vector<EventThread> workers_;
+};
+
+}  // namespace utils
\ No newline at end of file
diff --git a/libtransport/includes/hicn/transport/utils/uri.h b/libtransport/includes/hicn/transport/utils/uri.h
index 7c28e8552..30675e880 100644
--- a/libtransport/includes/hicn/transport/utils/uri.h
+++ b/libtransport/includes/hicn/transport/utils/uri.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/CMakeLists.txt b/libtransport/src/CMakeLists.txt
index 5e0cd38e7..477a21cb1 100644
--- a/libtransport/src/CMakeLists.txt
+++ b/libtransport/src/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,10 +11,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-include(GNUInstallDirs)
-
-set(ASIO_STANDALONE 1)
-
+##############################################################
+# Source files
+##############################################################
 add_subdirectory(core)
 add_subdirectory(interfaces)
 add_subdirectory(protocols)
@@ -23,49 +22,131 @@ add_subdirectory(implementation)
 add_subdirectory(utils)
 add_subdirectory(http)
 
-include(Packager)
-extract_version()
-configure_file("config.h.in" "hicn/transport/config.h" @ONLY)
-install(
-  FILES ${CMAKE_CURRENT_BINARY_DIR}/hicn/transport/config.h
-  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hicn/transport
-  COMPONENT ${LIBTRANSPORT_COMPONENT}-dev
+
+##############################################################
+# Libraries to link
+##############################################################
+set(LIBRARIES
+  PRIVATE ${HICN_LIBRARIES}
+  PRIVATE ${CMAKE_THREAD_LIBS_INIT}
+  PRIVATE ${CMAKE_DL_LIBS}
+  PRIVATE ${OPENSSL_LIBRARIES}
+  PRIVATE ${LIBCONFIG_CPP_LIBRARIES}
+  PRIVATE ${THIRD_PARTY_LIBRARIES}
 )
 
-install(
-  FILES "transport.config"
-  DESTINATION ${CMAKE_INSTALL_FULL_SYSCONFDIR}/hicn
-  COMPONENT ${LIBTRANSPORT_COMPONENT}
+
+##############################################################
+# Include dirs
+##############################################################
+list(APPEND LIBTRANSPORT_INTERNAL_INCLUDE_DIRS
+  PRIVATE
+    ${CMAKE_THREADS_INCLUDE_DIRS}
+    ${ASIO_INCLUDE_DIRS}
+    ${WINDOWS_INCLUDE_DIRS}
+    ${LIBCONFIG_CPP_INCLUDE_DIRS}
+    ${THIRD_PARTY_INCLUDE_DIRS}
+  PUBLIC
+    ${ASIO_INCLUDE_DIRS}
+    ${OPENSSL_INCLUDE_DIR}
 )
 
-list(APPEND COMPILER_DEFINITIONS
-  "-DASIO_STANDALONE"
+list(APPEND LIBTRANSPORT_INTERNAL_INCLUDE_DIRS
+  PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/
+  PUBLIC
+    $<BUILD_INTERFACE:${Libhicntransport_INCLUDE_DIRS}>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
 )
 
-list(INSERT LIBTRANSPORT_INTERNAL_INCLUDE_DIRS 0
-  ${CMAKE_CURRENT_SOURCE_DIR}/
-  ${CMAKE_CURRENT_BINARY_DIR}/
+
+##############################################################
+# Dependencies
+##############################################################
+list(APPEND DEPENDENCIES
+  ${THIRD_PARTY_DEPENDENCIES}
 )
 
-set(LIBTRANSPORT_INCLUDE_DIRS
-  ${LIBTRANSPORT_INCLUDE_DIRS}
-  "" CACHE INTERNAL
-  "" FORCE
+##############################################################
+# Compiler definitions
+##############################################################
+list(APPEND COMPILER_DEFINITIONS
+  PUBLIC "-DASIO_STANDALONE"
+)
+
+if (ENABLE_RELY)
+  list(APPEND COMPILER_DEFINITIONS
+    PRIVATE "-DENABLE_RELY=1"
+  )
+endif()
+
+
+##############################################################
+# Compiler options
+##############################################################
+list(APPEND COMPILER_OPTIONS
+  ${DEFAULT_COMPILER_OPTIONS}
 )
 
 if (NOT WIN32)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
+  list(APPEND COMPILER_OPTIONS
+    PRIVATE "-pthread"
+  )
 else ()
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4200 -D_WIN32_WINDOWS=0x0400")
+  list(APPEND COMPILER_OPTIONS
+    PRIVATE "-/wd4200 -D_WIN32_WINDOWS=0x0400"
+  )
   if (CMAKE_BUILD_TYPE EQUAL "RELEASE")
-    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /NODEFAULTLIB:\"MSVCRTD\"" )
+    list(APPEND COMPILER_OPTIONS
+      PRIVATE "/NODEFAULTLIB:\"MSVCRTD\""
+    )
   endif ()
 endif ()
 
 if (${CMAKE_SYSTEM_NAME} MATCHES "Android")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++ -isystem -lm")
+  list(APPEND COMPILER_OPTIONS
+    PRIVATE "-stdlib=libc++"
+    PRIVATE "-isystem"
+    PRIVATE "-lm"
+  )
 endif()
 
+
+##############################################################
+# Configuration file
+##############################################################
+configure_file("config.h.in" "hicn/transport/config.h" @ONLY)
+install(
+  FILES ${CMAKE_CURRENT_BINARY_DIR}/hicn/transport/config.h
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hicn/transport
+  COMPONENT ${LIBTRANSPORT_COMPONENT}-dev
+)
+
+if (${CMAKE_SYSTEM_NAME} MATCHES Darwin OR ${CMAKE_SYSTEM_NAME} MATCHES Linux)
+  install(
+    FILES "transport.config"
+    DESTINATION ${CMAKE_INSTALL_FULL_SYSCONFDIR}/hicn
+    COMPONENT ${LIBTRANSPORT_COMPONENT}
+  )
+else ()
+  install(
+    FILES "transport.config"
+    DESTINATION ${CMAKE_INSTALL_PREFIX}/etc/hicn
+    COMPONENT ${LIBTRANSPORT_COMPONENT}
+  )
+endif()
+
+
+##############################################################
+# IO Modules
+##############################################################
+add_subdirectory(io_modules)
+
+
+##############################################################
+# Build type
+##############################################################
 set (BUILD_TYPES "STATIC")
 
 if (NOT DISABLE_SHARED_LIBRARIES)
@@ -74,8 +155,10 @@ if (NOT DISABLE_SHARED_LIBRARIES)
   )
 endif()
 
-add_subdirectory(io_modules)
 
+##############################################################
+# Build library
+##############################################################
 build_library(${LIBTRANSPORT}
   ${BUILD_TYPES}
   SOURCES ${SOURCE_FILES} ${HEADER_FILES}
@@ -84,12 +167,29 @@ build_library(${LIBTRANSPORT}
   OBJECT_LIBRARIES ${THIRD_PARTY_OBJECT_LIBRARIES}
   DEPENDS ${DEPENDENCIES}
   COMPONENT ${LIBTRANSPORT_COMPONENT}
-  INCLUDE_DIRS ${LIBTRANSPORT_INCLUDE_DIRS} ${LIBTRANSPORT_INTERNAL_INCLUDE_DIRS}
-  HEADER_ROOT_DIR hicn/transport
+  INCLUDE_DIRS ${LIBTRANSPORT_INTERNAL_INCLUDE_DIRS}
   DEFINITIONS ${COMPILER_DEFINITIONS}
-  VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REVISION}
+  VERSION ${CURRENT_VERSION}
+  EXPORT_NAME ${LIBTRANSPORT_COMPONENT}
+  COMPILE_OPTIONS ${COMPILER_OPTIONS}
 )
 
+
+##############################################################
+# Unit tests
+##############################################################
 if (${BUILD_TESTS})
   add_subdirectory(test)
 endif()
+
+
+##############################################################
+# Cmake config files
+##############################################################
+create_cmake_config (
+  ${LIBTRANSPORT_COMPONENT}
+  INCLUDE_DIRS ${Libhicntransport_INCLUDE_DIRS}
+  VERSION ${CURRENT_VERSION}
+  COMPONENT ${LIBTRANSPORT_COMPONENT}
+  NAMESPACE hicn
+)
diff --git a/libtransport/src/auth/CMakeLists.txt b/libtransport/src/auth/CMakeLists.txt
index 699bc1050..8d3286338 100644
--- a/libtransport/src/auth/CMakeLists.txt
+++ b/libtransport/src/auth/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -14,7 +14,6 @@
 list(APPEND SOURCE_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/signer.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/verifier.cc
-  ${CMAKE_CURRENT_SOURCE_DIR}/identity.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/crypto_hash.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/crypto_suite.cc
 )
diff --git a/libtransport/src/auth/crypto_hash.cc b/libtransport/src/auth/crypto_hash.cc
index b4b0a8b81..f60f46051 100644
--- a/libtransport/src/auth/crypto_hash.cc
+++ b/libtransport/src/auth/crypto_hash.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -15,8 +15,6 @@
 
 #include <hicn/transport/auth/crypto_hash.h>
 
-using namespace std;
-
 namespace transport {
 namespace auth {
 
@@ -28,7 +26,7 @@ CryptoHash::CryptoHash(const CryptoHash &other)
       digest_size_(other.digest_size_) {}
 
 CryptoHash::CryptoHash(CryptoHash &&other)
-    : digest_type_(move(other.digest_type_)),
+    : digest_type_(std::move(other.digest_type_)),
       digest_(other.digest_),
       digest_size_(other.digest_size_) {
   other.reset();
@@ -43,13 +41,16 @@ CryptoHash::CryptoHash(const uint8_t *hash, size_t size,
   memcpy(digest_.data(), hash, size);
 }
 
-CryptoHash::CryptoHash(const vector<uint8_t> &hash, CryptoHashType hash_type)
+CryptoHash::CryptoHash(const std::vector<uint8_t> &hash,
+                       CryptoHashType hash_type)
     : CryptoHash(hash.data(), hash.size(), hash_type) {}
 
 CryptoHash &CryptoHash::operator=(const CryptoHash &other) {
-  digest_type_ = other.digest_type_;
-  digest_ = other.digest_;
-  digest_size_ = other.digest_size_;
+  if (this != &other) {
+    digest_type_ = other.digest_type_;
+    digest_ = other.digest_;
+    digest_size_ = other.digest_size_;
+  }
   return *this;
 }
 
@@ -68,7 +69,7 @@ void CryptoHash::computeDigest(const uint8_t *buffer, size_t len) {
              (*hash_evp)(), nullptr);
 }
 
-void CryptoHash::computeDigest(const vector<uint8_t> &buffer) {
+void CryptoHash::computeDigest(const std::vector<uint8_t> &buffer) {
   computeDigest(buffer.data(), buffer.size());
 }
 
@@ -102,15 +103,15 @@ void CryptoHash::computeDigest(const utils::MemBuf *buffer) {
   EVP_MD_CTX_free(mcdtx);
 }
 
-vector<uint8_t> CryptoHash::getDigest() const { return digest_; }
+std::vector<uint8_t> CryptoHash::getDigest() const { return digest_; }
 
-string CryptoHash::getStringDigest() const {
-  stringstream string_digest;
+std::string CryptoHash::getStringDigest() const {
+  std::stringstream string_digest;
 
-  string_digest << hex << setfill('0');
+  string_digest << std::hex << std::setfill('0');
 
   for (auto byte : digest_) {
-    string_digest << hex << setw(2) << static_cast<int>(byte);
+    string_digest << std::hex << std::setw(2) << static_cast<int>(byte);
   }
 
   return string_digest.str();
@@ -130,23 +131,23 @@ void CryptoHash::setType(CryptoHashType hash_type) {
 void CryptoHash::display() {
   switch (digest_type_) {
     case CryptoHashType::SHA256:
-      cout << "SHA256";
+      std::cout << "SHA256";
       break;
     case CryptoHashType::SHA512:
-      cout << "SHA512";
+      std::cout << "SHA512";
       break;
     case CryptoHashType::BLAKE2S256:
-      cout << "BLAKE2s256";
+      std::cout << "BLAKE2s256";
       break;
     case CryptoHashType::BLAKE2B512:
-      cout << "BLAKE2b512";
+      std::cout << "BLAKE2b512";
       break;
     default:
-      cout << "UNKNOWN";
+      std::cout << "UNKNOWN";
       break;
   }
 
-  cout << ": " << getStringDigest() << endl;
+  std::cout << ": " << getStringDigest() << std::endl;
 }
 
 void CryptoHash::reset() {
@@ -159,19 +160,14 @@ CryptoHashEVP CryptoHash::getEVP(CryptoHashType hash_type) {
   switch (hash_type) {
     case CryptoHashType::SHA256:
       return &EVP_sha256;
-      break;
     case CryptoHashType::SHA512:
       return &EVP_sha512;
-      break;
     case CryptoHashType::BLAKE2S256:
       return &EVP_blake2s256;
-      break;
     case CryptoHashType::BLAKE2B512:
       return &EVP_blake2b512;
-      break;
     default:
       return nullptr;
-      break;
   }
 }
 
diff --git a/libtransport/src/auth/crypto_suite.cc b/libtransport/src/auth/crypto_suite.cc
index 7e898ef09..44de85212 100644
--- a/libtransport/src/auth/crypto_suite.cc
+++ b/libtransport/src/auth/crypto_suite.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -22,31 +22,61 @@ CryptoSuite getSuite(int nid) {
   switch (nid) {
     case NID_ecdsa_with_SHA256:
       return CryptoSuite::ECDSA_SHA256;
-      break;
     case NID_ecdsa_with_SHA512:
       return CryptoSuite::ECDSA_SHA512;
-      break;
     case NID_sha256WithRSAEncryption:
       return CryptoSuite::RSA_SHA256;
-      break;
     case NID_sha512WithRSAEncryption:
       return CryptoSuite::RSA_SHA512;
-      break;
     case NID_hmacWithSHA256:
       return CryptoSuite::HMAC_SHA256;
-      break;
     case NID_hmacWithSHA512:
       return CryptoSuite::HMAC_SHA512;
-      break;
     case NID_dsa_with_SHA256:
       return CryptoSuite::DSA_SHA256;
-      break;
     case NID_dsa_with_SHA512:
       return CryptoSuite::DSA_SHA512;
-      break;
     default:
       return CryptoSuite::UNKNOWN;
-      break;
+  }
+}
+
+std::string getStringSuite(CryptoSuite suite) {
+  switch (suite) {
+    case CryptoSuite::ECDSA_BLAKE2B512:
+      return "ECDSA_BLAKE2B512";
+    case CryptoSuite::ECDSA_BLAKE2S256:
+      return "ECDSA_BLAKE2S256";
+    case CryptoSuite::ECDSA_SHA256:
+      return "ECDSA_SHA256";
+    case CryptoSuite::ECDSA_SHA512:
+      return "ECDSA_SHA512";
+    case CryptoSuite::RSA_BLAKE2B512:
+      return "RSA_BLAKE2B512";
+    case CryptoSuite::RSA_BLAKE2S256:
+      return "RSA_BLAKE2S256";
+    case CryptoSuite::RSA_SHA256:
+      return "RSA_SHA256";
+    case CryptoSuite::RSA_SHA512:
+      return "RSA_SHA512";
+    case CryptoSuite::HMAC_BLAKE2B512:
+      return "HMAC_BLAKE2B512";
+    case CryptoSuite::HMAC_BLAKE2S256:
+      return "HMAC_BLAKE2S256";
+    case CryptoSuite::HMAC_SHA256:
+      return "HMAC_SHA256";
+    case CryptoSuite::HMAC_SHA512:
+      return "HMAC_SHA512";
+    case CryptoSuite::DSA_BLAKE2B512:
+      return "DSA_BLAKE2B512";
+    case CryptoSuite::DSA_BLAKE2S256:
+      return "DSA_BLAKE2S256";
+    case CryptoSuite::DSA_SHA256:
+      return "DSA_SHA256";
+    case CryptoSuite::DSA_SHA512:
+      return "DSA_SHA512";
+    default:
+      return "UNKNOWN";
   }
 }
 
diff --git a/libtransport/src/auth/identity.cc b/libtransport/src/auth/identity.cc
deleted file mode 100644
index f56532033..000000000
--- a/libtransport/src/auth/identity.cc
+++ /dev/null
@@ -1,288 +0,0 @@
-/*
- * 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 <hicn/transport/auth/identity.h>
-
-using namespace std;
-
-// function needed to create the a certificate
-static bool _addRandomSerial(X509 *cert) {
-  unsigned long serial = 0;
-  unsigned char serial_bytes[sizeof(serial)];
-
-  // Construct random positive serial number.
-  RAND_bytes(serial_bytes, sizeof(serial_bytes));
-  serial_bytes[0] &= 0x7F;
-  serial = 0;
-  for (size_t i = 0; i < sizeof(serial_bytes); i++) {
-    serial = (256 * serial) + serial_bytes[i];
-  }
-  ASN1_INTEGER_set(X509_get_serialNumber(cert), serial);
-  return true;
-}
-
-static bool _addValidityPeriod(X509 *cert, size_t validityDays) {
-  // Set the validity from now for the specified number of days.
-  X509_gmtime_adj(X509_get_notBefore(cert), (long)0);
-  X509_gmtime_adj(X509_get_notAfter(cert), (long)(60 * 60 * 24 * validityDays));
-  return true;
-}
-
-static bool _addSubjectName(X509 *cert, const char *subjectname) {
-  // Set up the simple subject name and issuer name for the certificate.
-  X509_NAME *name = X509_get_subject_name(cert);
-
-  if (X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC,
-                                 (unsigned char *)subjectname, -1, -1, 0)) {
-    if (X509_set_issuer_name(cert, name)) {
-      return true;
-    }
-  }
-  return false;
-}
-static bool _addCertificateExtensionWithContext(X509 *cert, int nid,
-                                                const char *value) {
-  X509_EXTENSION *extension;
-  X509V3_CTX context;
-
-  X509V3_set_ctx_nodb(&context);
-  X509V3_set_ctx(&context, cert, cert, NULL, NULL, 0);
-  extension = X509V3_EXT_conf_nid(NULL, &context, nid, value);
-  if (extension == NULL) {
-    return false;
-  }
-  X509_add_ext(cert, extension, -1);
-  X509_EXTENSION_free(extension);
-  return true;
-}
-static bool _addCertificateExtension(X509 *cert, int nid, const char *value) {
-  X509_EXTENSION *extension = X509V3_EXT_conf_nid(NULL, NULL, nid, value);
-  if (extension == NULL) {
-    return false;
-  }
-  X509_add_ext(cert, extension, -1);
-  X509_EXTENSION_free(extension);
-  return true;
-}
-
-static bool _addExtensions(X509 *cert) {
-  // Add the necessary extensions.
-  if (_addCertificateExtension(cert, NID_basic_constraints,
-                               "critical,CA:FALSE") == true) {
-    if (_addCertificateExtension(
-            cert, NID_key_usage,
-            "digitalSignature,nonRepudiation,keyEncipherment,dataEncipherment,"
-            "keyAgreement") == true) {
-      if (_addCertificateExtension(cert, NID_ext_key_usage, "clientAuth") ==
-          true) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-static bool _addKeyIdentifier(X509 *cert) {
-  unsigned char spkid[SHA256_DIGEST_LENGTH];
-  char spkid_hex[1 + 2 * SHA256_DIGEST_LENGTH];
-  if (ASN1_item_digest(ASN1_ITEM_rptr(X509_PUBKEY), EVP_sha256(),
-                       X509_get_X509_PUBKEY(cert), spkid, NULL)) {
-    for (int i = 0; i < 32; i++) {
-      snprintf(&spkid_hex[2 * i], 3, "%02X", (unsigned)spkid[i]);
-    }
-    if (_addCertificateExtension(cert, NID_subject_key_identifier, spkid_hex) ==
-        true) {
-      if (_addCertificateExtensionWithContext(
-              cert, NID_authority_key_identifier, "keyid:always") == true) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-namespace transport {
-namespace auth {
-
-Identity::Identity(const string &keystore_path, const string &keystore_pwd,
-                   CryptoSuite suite, unsigned int signature_len,
-                   unsigned int validity_days, const string &subject_name)
-    : cert_(X509_new(), ::X509_free) {
-  // create the file and complete it.
-  // first we create the certificate
-
-  // to create the cert we will need a private key
-
-  std::shared_ptr<EVP_PKEY> privateKey(EVP_PKEY_new(), EVP_PKEY_free);
-
-  if (suite == CryptoSuite::RSA_SHA512 || suite == CryptoSuite::RSA_SHA256) {
-    RSA *rsa = RSA_new();
-    BIGNUM *pub_exp;
-
-    pub_exp = BN_new();
-
-    BN_set_word(pub_exp, RSA_F4);
-    if (1 != RSA_generate_key_ex(rsa, signature_len, pub_exp, NULL))
-      throw errors::RuntimeException("can't generate the key");
-    if (1 != EVP_PKEY_set1_RSA(privateKey.get(), rsa))
-      throw errors::RuntimeException("can't generate the key");
-  } else if (suite == CryptoSuite::ECDSA_SHA256) {
-    int curve_params;
-    switch (signature_len) {
-      case 160u:
-        curve_params = NID_secp160k1;
-        break;
-      case 192u:
-        curve_params = NID_secp192k1;
-        break;
-      case 224u:
-        curve_params = NID_secp224k1;
-        break;
-      case 256u:
-        curve_params = NID_secp256k1;
-        break;
-      default:
-        curve_params = -1;
-        break;
-    }
-    if (curve_params == -1)
-      throw errors::RuntimeException("can't generate the key");
-    EC_KEY *ec_key = EC_KEY_new_by_curve_name(curve_params);
-    if (ec_key == NULL)
-      throw errors::RuntimeException("can't create ecdsa key from curve");
-    EC_KEY_set_asn1_flag(ec_key, OPENSSL_EC_NAMED_CURVE);
-    if (EC_KEY_generate_key(ec_key) == 0)
-      throw errors::RuntimeException("can't generate the ecdsa key");
-    if (EVP_PKEY_set1_EC_KEY(privateKey.get(), ec_key) == 0)
-      throw errors::RuntimeException("can't generate the ecdsa key");
-  } else if (suite == CryptoSuite::DSA_SHA256) {
-    DSA *dsa = DSA_new();
-    unsigned char buffer[32];
-    if (RAND_bytes(buffer, sizeof(buffer)) != 1) {
-      throw errors::RuntimeException("can't generate the key");
-    }
-    if (DSA_generate_parameters_ex(dsa, signature_len, buffer, sizeof(buffer),
-                                   NULL, NULL, NULL) != 1)
-      throw errors::RuntimeException("can't generate the key");
-    if (DSA_generate_key(dsa) != 1)
-      throw errors::RuntimeException("can't generate the key");
-    if (EVP_PKEY_set1_DSA(privateKey.get(), dsa) != 1)
-      throw errors::RuntimeException("can't generate the key");
-  }
-  bool success = true;
-  success = success && (X509_set_version(cert_.get(), 2) == 1);  // 2 => X509v3
-  success = success && _addRandomSerial(cert_.get());
-  success = success && _addValidityPeriod(cert_.get(), validity_days);
-  success = success && (X509_set_pubkey(cert_.get(), privateKey.get()) == 1);
-  success = success && _addSubjectName(cert_.get(), subject_name.c_str());
-  success = success && _addExtensions(cert_.get());
-  success =
-      success && (X509_sign(cert_.get(), privateKey.get(), EVP_sha256()) != 0);
-  success = success && _addKeyIdentifier(cert_.get());
-  if (!success) {
-    throw errors::RuntimeException("error while creating the certificate");
-  }
-  // the certificate is created. We create the pkcs12 object to write the p12
-  // file
-  PKCS12 *p12 = PKCS12_create(
-      keystore_pwd.c_str(), "ccnxuser", privateKey.get(), cert_.get(), NULL, 0,
-      0, 0 /*default iter*/, PKCS12_DEFAULT_ITER /*mac_iter*/, 0);
-  filename_ = keystore_path;
-  int fp = open(filename_.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0600);
-  if (fp == -1) throw errors::RuntimeException("impossible to create the file");
-  FILE *fp_f = fdopen(fp, "wb");
-  if (fp_f == NULL)
-    throw errors::RuntimeException("impossible to create the file");
-  i2d_PKCS12_fp(fp_f, p12);
-  fclose(fp_f);
-  close(fp);
-  std::shared_ptr<EVP_PKEY> publickey(X509_get_pubkey(cert_.get()),
-                                      EVP_PKEY_free);
-  signer_ = std::shared_ptr<AsymmetricSigner>(
-      new AsymmetricSigner(suite, privateKey, publickey));
-  signer_->signature_len_ = signature_len;
-}
-
-Identity::Identity(string &keystore_path, string &keystore_pwd,
-                   CryptoHashType hash_type)
-    : cert_(X509_new(), ::X509_free) {
-  filename_ = keystore_path;
-  pwd_ = keystore_path;
-  // get the key and certificate by first opening the keystore file
-  FILE *p12file = fopen(keystore_path.c_str(), "r");
-  if (p12file == NULL)
-    throw errors::RuntimeException("impossible open keystore");
-  PKCS12 *p12 = d2i_PKCS12_fp(p12file, NULL);
-  EVP_PKEY *privatekey;
-  EVP_PKEY *publickey;
-  X509 *cert = cert_.get();
-  // now we parse the file to get the first key and certificate
-  if (1 != PKCS12_parse(p12, keystore_pwd.c_str(), &privatekey, &cert, NULL))
-    throw errors::RuntimeException("impossible to get the private key");
-  publickey = X509_get_pubkey(cert);
-  // to have the cryptosuite we use the nid number that is used to identify the
-  // suite.
-  CryptoSuite suite = getSuite(X509_get_signature_nid(cert));
-  signer_ = std::shared_ptr<AsymmetricSigner>(new AsymmetricSigner(
-      suite, std::shared_ptr<EVP_PKEY>(privatekey, EVP_PKEY_free),
-      std::shared_ptr<EVP_PKEY>(publickey, EVP_PKEY_free)));
-  PKCS12_free(p12);
-}
-
-Identity::Identity(const Identity &other) {
-  pwd_ = other.pwd_;
-  filename_ = other.filename_;
-  signer_ = other.signer_;
-  cert_ = other.cert_;
-}
-
-Identity::Identity(Identity &&other) {
-  signer_ = std::move(other.signer_);
-  other.signer_.reset();
-  cert_ = std::move(other.cert_);
-  other.cert_.reset();
-  pwd_ = other.pwd_;
-  other.pwd_ = "";
-  filename_ = other.filename_;
-  other.filename_ = "";
-  signer_ = other.signer_;
-  other.signer_ = nullptr;
-}
-
-Identity::~Identity() {}
-
-shared_ptr<AsymmetricSigner> Identity::getSigner() const { return signer_; }
-
-string Identity::getFilename() const { return filename_; }
-
-std::shared_ptr<X509> Identity::getCertificate() const { return cert_; }
-std::shared_ptr<EVP_PKEY> Identity::getPrivateKey() const {
-  return signer_->key_;
-}
-
-string Identity::getPassword() const { return pwd_; }
-
-Identity Identity::generateIdentity(const string &subject_name) {
-  string keystore_name = "keystore";
-  string keystore_password = "password";
-  size_t key_length = 1024;
-  unsigned int validity_days = 30;
-  CryptoSuite suite = CryptoSuite::RSA_SHA256;
-
-  return Identity(keystore_name, keystore_password, suite,
-                  (unsigned int)key_length, validity_days, subject_name);
-}
-
-}  // namespace auth
-}  // namespace transport
diff --git a/libtransport/src/auth/signer.cc b/libtransport/src/auth/signer.cc
index 884e850ca..e74e2f1b8 100644
--- a/libtransport/src/auth/signer.cc
+++ b/libtransport/src/auth/signer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,9 +13,9 @@
  * limitations under the License.
  */
 
+#include <glog/logging.h>
 #include <hicn/transport/auth/signer.h>
-
-using namespace std;
+#include <hicn/transport/utils/chrono_typedefs.h>
 
 namespace transport {
 namespace auth {
@@ -29,31 +29,29 @@ Signer::Signer()
 Signer::~Signer() {}
 
 void Signer::signPacket(PacketPtr packet) {
-  assert(key_ != nullptr);
+  DCHECK(key_ != nullptr);
   core::Packet::Format format = packet->getFormat();
 
-  if (!packet->authenticationHeader()) {
+  if (!packet->hasAH()) {
     throw errors::MalformedAHPacketException();
   }
 
   // Set signature size
   size_t signature_field_len = getSignatureFieldSize();
-  packet->setSignatureSize(signature_field_len);
-  packet->setSignatureSizeGap(0u);
+  packet->setSignatureFieldSize(signature_field_len);
+  packet->updateLength();  // update IP payload length
 
   // Copy IP+TCP / ICMP header before zeroing them
   hicn_header_t header_copy;
   hicn_packet_copy_header(format, packet->packet_start_, &header_copy, false);
 
   // Fill in the hICN AH header
-  auto now = chrono::duration_cast<chrono::milliseconds>(
-                 chrono::system_clock::now().time_since_epoch())
-                 .count();
+  auto now = utils::SteadyTime::nowMs().count();
   packet->setSignatureTimestamp(now);
   packet->setValidationAlgorithm(suite_);
 
   // Set key ID
-  vector<uint8_t> key_id = key_id_.getDigest();
+  std::vector<uint8_t> key_id = key_id_.getDigest();
   packet->setKeyId({key_id.data(), key_id.size()});
 
   // Reset fields to compute the packet hash
@@ -61,22 +59,22 @@ void Signer::signPacket(PacketPtr packet) {
 
   // Compute the signature and put it in the packet
   signBuffer(packet);
-  hicn_packet_copy_header(format, &header_copy, packet->packet_start_, false);
+  packet->setSignature(signature_);
+  packet->setSignatureSize(signature_len_);
 
-  // Set the gap between the signature field size and the signature real size.
-  packet->setSignatureSizeGap(signature_field_len - signature_len_);
-  memcpy(packet->getSignature(), signature_.data(), signature_len_);
+  // Restore header
+  hicn_packet_copy_header(format, &header_copy, packet->packet_start_, false);
 }
 
 void Signer::signBuffer(const std::vector<uint8_t> &buffer) {
-  assert(key_ != nullptr);
+  DCHECK(key_ != nullptr);
   CryptoHashEVP hash_evp = CryptoHash::getEVP(getHashType());
 
   if (hash_evp == nullptr) {
     throw errors::RuntimeException("Unknown hash type");
   }
 
-  shared_ptr<EVP_MD_CTX> mdctx(EVP_MD_CTX_create(), EVP_MD_CTX_free);
+  std::shared_ptr<EVP_MD_CTX> mdctx(EVP_MD_CTX_create(), EVP_MD_CTX_free);
 
   if (mdctx == nullptr) {
     throw errors::RuntimeException("Digest context allocation failed");
@@ -106,7 +104,7 @@ void Signer::signBuffer(const std::vector<uint8_t> &buffer) {
 }
 
 void Signer::signBuffer(const utils::MemBuf *buffer) {
-  assert(key_ != nullptr);
+  DCHECK(key_ != nullptr);
   CryptoHashEVP hash_evp = CryptoHash::getEVP(getHashType());
 
   if (hash_evp == nullptr) {
@@ -114,7 +112,7 @@ void Signer::signBuffer(const utils::MemBuf *buffer) {
   }
 
   const utils::MemBuf *p = buffer;
-  shared_ptr<EVP_MD_CTX> mdctx(EVP_MD_CTX_create(), EVP_MD_CTX_free);
+  std::shared_ptr<EVP_MD_CTX> mdctx(EVP_MD_CTX_create(), EVP_MD_CTX_free);
 
   if (mdctx == nullptr) {
     throw errors::RuntimeException("Digest context allocation failed");
@@ -147,7 +145,18 @@ void Signer::signBuffer(const utils::MemBuf *buffer) {
   signature_.resize(signature_len_);
 }
 
-vector<uint8_t> Signer::getSignature() const { return signature_; }
+std::vector<uint8_t> Signer::getSignature() const { return signature_; }
+
+std::string Signer::getStringSignature() const {
+  std::stringstream string_sig;
+  string_sig << std::hex << std::setfill('0');
+
+  for (auto byte : signature_) {
+    string_sig << std::hex << std::setw(2) << static_cast<int>(byte);
+  }
+
+  return string_sig.str();
+}
 
 size_t Signer::getSignatureSize() const { return signature_len_; }
 
@@ -159,36 +168,75 @@ size_t Signer::getSignatureFieldSize() const {
   return (signature_len_ + 4) - (signature_len_ % 4);
 }
 
+CryptoSuite Signer::getSuite() const { return suite_; }
+
 CryptoHashType Signer::getHashType() const {
   return ::transport::auth::getHashType(suite_);
 }
 
-CryptoSuite Signer::getSuite() const { return suite_; }
+void Signer::display() {
+  std::cout << getStringSuite(suite_) << ": " << getStringSignature()
+            << std::endl;
+}
 
 // ---------------------------------------------------------
 // Void Signer
 // ---------------------------------------------------------
-void VoidSigner::signPacket(PacketPtr packet){};
+void VoidSigner::signPacket(PacketPtr packet) {}
 
-void VoidSigner::signBuffer(const std::vector<uint8_t> &buffer){};
+void VoidSigner::signBuffer(const std::vector<uint8_t> &buffer) {}
 
-void VoidSigner::signBuffer(const utils::MemBuf *buffer){};
+void VoidSigner::signBuffer(const utils::MemBuf *buffer) {}
 
 // ---------------------------------------------------------
 // Asymmetric Signer
 // ---------------------------------------------------------
-AsymmetricSigner::AsymmetricSigner(CryptoSuite suite, shared_ptr<EVP_PKEY> key,
-                                   shared_ptr<EVP_PKEY> pub_key) {
+AsymmetricSigner::AsymmetricSigner(CryptoSuite suite,
+                                   std::shared_ptr<EVP_PKEY> key,
+                                   std::shared_ptr<EVP_PKEY> pub_key) {
+  setKey(suite, key, pub_key);
+}
+
+AsymmetricSigner::AsymmetricSigner(std::string keystore_path,
+                                   std::string password) {
+  FILE *p12file = fopen(keystore_path.c_str(), "r");
+
+  if (p12file == nullptr) {
+    throw errors::RuntimeException("failed to read keystore");
+  }
+
+  std::unique_ptr<PKCS12, decltype(&PKCS12_free)> p12(
+      d2i_PKCS12_fp(p12file, nullptr), &PKCS12_free);
+  X509 *cert_raw;
+  EVP_PKEY *key_raw;
+
+  if (PKCS12_parse(p12.get(), password.c_str(), &key_raw, &cert_raw, nullptr) !=
+      1) {
+    fclose(p12file);
+    throw errors::RuntimeException("failed to parse keystore");
+  }
+
+  std::shared_ptr<EVP_PKEY> key(key_raw, EVP_PKEY_free);
+  std::shared_ptr<EVP_PKEY> pub_key(X509_get_pubkey(cert_raw), EVP_PKEY_free);
+
+  setKey(transport::auth::getSuite(X509_get_signature_nid(cert_raw)), key,
+         pub_key);
+
+  fclose(p12file);
+}
+
+void AsymmetricSigner::setKey(CryptoSuite suite, std::shared_ptr<EVP_PKEY> key,
+                              std::shared_ptr<EVP_PKEY> pub_key) {
   suite_ = suite;
   key_ = key;
-  key_id_ = CryptoHash(getHashType());
+  signature_len_ = EVP_PKEY_size(key.get());
+  signature_.resize(signature_len_);
 
-  vector<uint8_t> pbk(i2d_PublicKey(pub_key.get(), nullptr));
+  std::vector<uint8_t> pbk(i2d_PublicKey(pub_key.get(), nullptr));
   uint8_t *pbk_ptr = pbk.data();
   int len = i2d_PublicKey(pub_key.get(), &pbk_ptr);
 
-  signature_len_ = EVP_PKEY_size(key.get());
-  signature_.resize(signature_len_);
+  key_id_ = CryptoHash(getHashType());
   key_id_.computeDigest(pbk_ptr, len);
 }
 
@@ -205,9 +253,10 @@ size_t AsymmetricSigner::getSignatureFieldSize() const {
 // ---------------------------------------------------------
 // Symmetric Signer
 // ---------------------------------------------------------
-SymmetricSigner::SymmetricSigner(CryptoSuite suite, const string &passphrase) {
+SymmetricSigner::SymmetricSigner(CryptoSuite suite,
+                                 const std::string &passphrase) {
   suite_ = suite;
-  key_ = shared_ptr<EVP_PKEY>(
+  key_ = std::shared_ptr<EVP_PKEY>(
       EVP_PKEY_new_raw_private_key(EVP_PKEY_HMAC, nullptr,
                                    (const unsigned char *)passphrase.c_str(),
                                    passphrase.size()),
diff --git a/libtransport/src/auth/verifier.cc b/libtransport/src/auth/verifier.cc
index c9ac1650f..0c35437f3 100644
--- a/libtransport/src/auth/verifier.cc
+++ b/libtransport/src/auth/verifier.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,12 +16,10 @@
 #include <hicn/transport/auth/verifier.h>
 #include <protocols/errors.h>
 
-using namespace std;
-
 namespace transport {
 namespace auth {
 
-const vector<VerificationPolicy> Verifier::DEFAULT_FAILED_POLICIES = {
+const std::vector<VerificationPolicy> Verifier::DEFAULT_FAILED_POLICIES = {
     VerificationPolicy::DROP,
     VerificationPolicy::ABORT,
 };
@@ -38,24 +36,21 @@ Verifier::~Verifier() {}
 bool Verifier::verifyPacket(PacketPtr packet) {
   core::Packet::Format format = packet->getFormat();
 
-  if (!packet->authenticationHeader()) {
+  if (!packet->hasAH()) {
     throw errors::MalformedAHPacketException();
   }
 
   // Get crypto suite, hash type, signature length
   CryptoSuite suite = packet->getValidationAlgorithm();
   CryptoHashType hash_type = getHashType(suite);
-  size_t signature_len = packet->getSignatureSizeReal();
 
   // Copy IP+TCP / ICMP header before zeroing them
   hicn_header_t header_copy;
   hicn_packet_copy_header(format, packet->packet_start_, &header_copy, false);
-  packet->setSignatureSizeGap(0u);
 
   // Retrieve packet signature
-  uint8_t *packet_signature = packet->getSignature();
-  vector<uint8_t> signature_raw(packet_signature,
-                                packet_signature + signature_len);
+  std::vector<uint8_t> signature_raw = packet->getSignature();
+  signature_raw.resize(packet->getSignatureSize());
 
   // Reset fields that are not used to compute signature
   packet->resetForHash();
@@ -66,12 +61,14 @@ bool Verifier::verifyPacket(PacketPtr packet) {
 
   // Restore header
   hicn_packet_copy_header(format, &header_copy, packet->packet_start_, false);
-  packet->setSignatureSizeGap(packet->getSignatureSize() - signature_len);
+  packet->setSignature(signature_raw);
+  packet->setSignatureSize(signature_raw.size());
 
   return valid_packet;
 }
 
-Verifier::PolicyMap Verifier::verifyPackets(const vector<PacketPtr> &packets) {
+Verifier::PolicyMap Verifier::verifyPackets(
+    const std::vector<PacketPtr> &packets) {
   PolicyMap policies;
 
   for (const auto &packet : packets) {
@@ -82,8 +79,8 @@ Verifier::PolicyMap Verifier::verifyPackets(const vector<PacketPtr> &packets) {
       policy = VerificationPolicy::ACCEPT;
     }
 
+    callVerificationFailedCallback(suffix, policy);
     policies[suffix] = policy;
-    callVerificationFailedCallback(packet, policy);
   }
 
   return policies;
@@ -105,14 +102,15 @@ Verifier::PolicyMap Verifier::verifyHashes(const SuffixMap &packet_map,
       }
     }
 
+    callVerificationFailedCallback(packet_hash.first, policy);
     policies[packet_hash.first] = policy;
   }
 
   return policies;
 }
 
-Verifier::PolicyMap Verifier::verifyPackets(const vector<PacketPtr> &packets,
-                                            const SuffixMap &suffix_map) {
+Verifier::PolicyMap Verifier::verifyPackets(
+    const std::vector<PacketPtr> &packets, const SuffixMap &suffix_map) {
   PolicyMap policies;
 
   for (const auto &packet : packets) {
@@ -130,8 +128,8 @@ Verifier::PolicyMap Verifier::verifyPackets(const vector<PacketPtr> &packets,
       }
     }
 
+    callVerificationFailedCallback(suffix, policy);
     policies[suffix] = policy;
-    callVerificationFailedCallback(packet, policy);
   }
 
   return policies;
@@ -139,7 +137,7 @@ Verifier::PolicyMap Verifier::verifyPackets(const vector<PacketPtr> &packets,
 
 void Verifier::setVerificationFailedCallback(
     VerificationFailedCallback verfication_failed_cb,
-    const vector<VerificationPolicy> &failed_policies) {
+    const std::vector<VerificationPolicy> &failed_policies) {
   verification_failed_cb_ = verfication_failed_cb;
   failed_policies_ = failed_policies;
 }
@@ -149,7 +147,7 @@ void Verifier::getVerificationFailedCallback(
   *verfication_failed_cb = &verification_failed_cb_;
 }
 
-void Verifier::callVerificationFailedCallback(PacketPtr packet,
+void Verifier::callVerificationFailedCallback(Suffix suffix,
                                               VerificationPolicy &policy) {
   if (verification_failed_cb_ == interface::VOID_HANDLER) {
     return;
@@ -157,10 +155,7 @@ void Verifier::callVerificationFailedCallback(PacketPtr packet,
 
   if (find(failed_policies_.begin(), failed_policies_.end(), policy) !=
       failed_policies_.end()) {
-    policy = verification_failed_cb_(
-        static_cast<const core::ContentObject &>(*packet),
-        make_error_code(
-            protocol::protocol_error::signature_verification_failed));
+    policy = verification_failed_cb_(suffix, policy);
   }
 }
 
@@ -169,71 +164,75 @@ void Verifier::callVerificationFailedCallback(PacketPtr packet,
 // ---------------------------------------------------------
 bool VoidVerifier::verifyPacket(PacketPtr packet) { return true; }
 
-bool VoidVerifier::verifyBuffer(const vector<uint8_t> &buffer,
-                                const vector<uint8_t> &signature,
+bool VoidVerifier::verifyBuffer(const std::vector<uint8_t> &buffer,
+                                const std::vector<uint8_t> &signature,
                                 CryptoHashType hash_type) {
   return true;
 }
 
 bool VoidVerifier::verifyBuffer(const utils::MemBuf *buffer,
-                                const vector<uint8_t> &signature,
+                                const std::vector<uint8_t> &signature,
                                 CryptoHashType hash_type) {
   return true;
 }
 
 Verifier::PolicyMap VoidVerifier::verifyPackets(
-    const vector<PacketPtr> &packets) {
+    const std::vector<PacketPtr> &packets) {
   PolicyMap policies;
 
   for (const auto &packet : packets) {
-    policies[packet->getName().getSuffix()] = VerificationPolicy::ACCEPT;
+    auth::Suffix suffix = packet->getName().getSuffix();
+    VerificationPolicy policy = VerificationPolicy::ACCEPT;
+    callVerificationFailedCallback(suffix, policy);
+    policies[suffix] = policy;
   }
 
   return policies;
 }
 
 Verifier::PolicyMap VoidVerifier::verifyPackets(
-    const vector<PacketPtr> &packets, const SuffixMap &suffix_map) {
+    const std::vector<PacketPtr> &packets, const SuffixMap &suffix_map) {
   return verifyPackets(packets);
 }
 
 // ---------------------------------------------------------
 // Asymmetric Verifier
 // ---------------------------------------------------------
-AsymmetricVerifier::AsymmetricVerifier(shared_ptr<EVP_PKEY> key) {
+AsymmetricVerifier::AsymmetricVerifier(std::shared_ptr<EVP_PKEY> key) {
   setKey(key);
 }
 
-AsymmetricVerifier::AsymmetricVerifier(const string &cert_path) {
+AsymmetricVerifier::AsymmetricVerifier(const std::string &cert_path) {
   useCertificate(cert_path);
 }
 
-AsymmetricVerifier::AsymmetricVerifier(shared_ptr<X509> cert) {
+AsymmetricVerifier::AsymmetricVerifier(std::shared_ptr<X509> cert) {
   useCertificate(cert);
 }
 
-void AsymmetricVerifier::setKey(shared_ptr<EVP_PKEY> key) { key_ = key; };
+void AsymmetricVerifier::setKey(std::shared_ptr<EVP_PKEY> key) { key_ = key; };
 
-void AsymmetricVerifier::useCertificate(const string &cert_path) {
+void AsymmetricVerifier::useCertificate(const std::string &cert_path) {
   FILE *certf = fopen(cert_path.c_str(), "rb");
 
   if (certf == nullptr) {
     throw errors::RuntimeException("Certificate not found");
   }
 
-  shared_ptr<X509> cert = shared_ptr<X509>(
+  std::shared_ptr<X509> cert = std::shared_ptr<X509>(
       PEM_read_X509(certf, nullptr, nullptr, nullptr), ::X509_free);
   useCertificate(cert);
 
   fclose(certf);
 }
 
-void AsymmetricVerifier::useCertificate(shared_ptr<X509> cert) {
-  key_ = shared_ptr<EVP_PKEY>(X509_get_pubkey(cert.get()), ::EVP_PKEY_free);
+void AsymmetricVerifier::useCertificate(std::shared_ptr<X509> cert) {
+  key_ =
+      std::shared_ptr<EVP_PKEY>(X509_get_pubkey(cert.get()), ::EVP_PKEY_free);
 }
 
-bool AsymmetricVerifier::verifyBuffer(const vector<uint8_t> &buffer,
-                                      const vector<uint8_t> &signature,
+bool AsymmetricVerifier::verifyBuffer(const std::vector<uint8_t> &buffer,
+                                      const std::vector<uint8_t> &signature,
                                       CryptoHashType hash_type) {
   CryptoHashEVP hash_evp = CryptoHash::getEVP(hash_type);
 
@@ -241,7 +240,7 @@ bool AsymmetricVerifier::verifyBuffer(const vector<uint8_t> &buffer,
     throw errors::RuntimeException("Unknown hash type");
   }
 
-  shared_ptr<EVP_MD_CTX> mdctx(EVP_MD_CTX_create(), EVP_MD_CTX_free);
+  std::shared_ptr<EVP_MD_CTX> mdctx(EVP_MD_CTX_create(), EVP_MD_CTX_free);
 
   if (mdctx == nullptr) {
     throw errors::RuntimeException("Digest context allocation failed");
@@ -261,7 +260,7 @@ bool AsymmetricVerifier::verifyBuffer(const vector<uint8_t> &buffer,
 }
 
 bool AsymmetricVerifier::verifyBuffer(const utils::MemBuf *buffer,
-                                      const vector<uint8_t> &signature,
+                                      const std::vector<uint8_t> &signature,
                                       CryptoHashType hash_type) {
   CryptoHashEVP hash_evp = CryptoHash::getEVP(hash_type);
 
@@ -270,7 +269,7 @@ bool AsymmetricVerifier::verifyBuffer(const utils::MemBuf *buffer,
   }
 
   const utils::MemBuf *p = buffer;
-  shared_ptr<EVP_MD_CTX> mdctx(EVP_MD_CTX_create(), EVP_MD_CTX_free);
+  std::shared_ptr<EVP_MD_CTX> mdctx(EVP_MD_CTX_create(), EVP_MD_CTX_free);
 
   if (mdctx == nullptr) {
     throw errors::RuntimeException("Digest context allocation failed");
@@ -296,21 +295,21 @@ bool AsymmetricVerifier::verifyBuffer(const utils::MemBuf *buffer,
 // ---------------------------------------------------------
 // Symmetric Verifier
 // ---------------------------------------------------------
-SymmetricVerifier::SymmetricVerifier(const string &passphrase) {
+SymmetricVerifier::SymmetricVerifier(const std::string &passphrase) {
   setPassphrase(passphrase);
 }
 
 // Create and set a symmetric key from a passphrase.
-void SymmetricVerifier::setPassphrase(const string &passphrase) {
-  key_ = shared_ptr<EVP_PKEY>(
+void SymmetricVerifier::setPassphrase(const std::string &passphrase) {
+  key_ = std::shared_ptr<EVP_PKEY>(
       EVP_PKEY_new_raw_private_key(EVP_PKEY_HMAC, nullptr,
                                    (const unsigned char *)passphrase.c_str(),
                                    passphrase.size()),
       EVP_PKEY_free);
 }
 
-bool SymmetricVerifier::verifyBuffer(const vector<uint8_t> &buffer,
-                                     const vector<uint8_t> &signature,
+bool SymmetricVerifier::verifyBuffer(const std::vector<uint8_t> &buffer,
+                                     const std::vector<uint8_t> &signature,
                                      CryptoHashType hash_type) {
   CryptoHashEVP hash_evp = CryptoHash::getEVP(hash_type);
 
@@ -318,9 +317,9 @@ bool SymmetricVerifier::verifyBuffer(const vector<uint8_t> &buffer,
     throw errors::RuntimeException("Unknown hash type");
   }
 
-  vector<uint8_t> signature_bis(signature.size());
+  std::vector<uint8_t> signature_bis(signature.size());
   size_t signature_bis_len;
-  shared_ptr<EVP_MD_CTX> mdctx(EVP_MD_CTX_create(), EVP_MD_CTX_free);
+  std::shared_ptr<EVP_MD_CTX> mdctx(EVP_MD_CTX_create(), EVP_MD_CTX_free);
 
   if (mdctx == nullptr) {
     throw errors::RuntimeException("Digest context allocation failed");
@@ -344,7 +343,7 @@ bool SymmetricVerifier::verifyBuffer(const vector<uint8_t> &buffer,
 }
 
 bool SymmetricVerifier::verifyBuffer(const utils::MemBuf *buffer,
-                                     const vector<uint8_t> &signature,
+                                     const std::vector<uint8_t> &signature,
                                      CryptoHashType hash_type) {
   CryptoHashEVP hash_evp = CryptoHash::getEVP(hash_type);
 
@@ -353,9 +352,9 @@ bool SymmetricVerifier::verifyBuffer(const utils::MemBuf *buffer,
   }
 
   const utils::MemBuf *p = buffer;
-  vector<uint8_t> signature_bis(signature.size());
+  std::vector<uint8_t> signature_bis(signature.size());
   size_t signature_bis_len;
-  shared_ptr<EVP_MD_CTX> mdctx(EVP_MD_CTX_create(), EVP_MD_CTX_free);
+  std::shared_ptr<EVP_MD_CTX> mdctx(EVP_MD_CTX_create(), EVP_MD_CTX_free);
 
   if (mdctx == nullptr) {
     throw errors::RuntimeException("Digest context allocation failed");
diff --git a/libtransport/src/config.h.in b/libtransport/src/config.h.in
index 73a326a84..231a370aa 100644
--- a/libtransport/src/config.h.in
+++ b/libtransport/src/config.h.in
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -19,13 +19,12 @@
 
 #define HICNTRANSPORT_VERSION_MAJOR "@VERSION_MAJOR@"
 #define HICNTRANSPORT_VERSION_MINOR "@VERSION_MINOR@"
-#define HICNTRANSPORT_VERSION_REVISION "@VERSION_REVISION@"
+#define HICNTRANSPORT_VERSION_PATCH "@VERSION_PATCH@"
 
 #ifndef ASIO_STANDALONE
 #cmakedefine ASIO_STANDALONE
 #endif
 
 #define RAAQM_CONFIG_PATH "@raaqm_config_path@"
-#define ENABLE_RELY @ENABLE_RELY@
 
 #cmakedefine __vpp__
diff --git a/libtransport/src/core/CMakeLists.txt b/libtransport/src/core/CMakeLists.txt
index e442bb863..b9b024d60 100644
--- a/libtransport/src/core/CMakeLists.txt
+++ b/libtransport/src/core/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -22,6 +22,9 @@ list(APPEND HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/errors.h
   ${CMAKE_CURRENT_SOURCE_DIR}/global_configuration.h
   ${CMAKE_CURRENT_SOURCE_DIR}/local_connector.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/global_workers.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/udp_connector.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/udp_listener.h
 )
 
 list(APPEND SOURCE_FILES
@@ -36,7 +39,21 @@ list(APPEND SOURCE_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/global_configuration.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/io_module.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/local_connector.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/udp_connector.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/udp_listener.cc
 )
 
+if (NOT ${CMAKE_SYSTEM_NAME} MATCHES Android)
+  if (UNIX AND NOT APPLE)
+    list(APPEND SOURCE_FILES
+      ${CMAKE_CURRENT_SOURCE_DIR}/memif_connector.cc
+    )
+
+    list(APPEND HEADER_FILES
+      ${CMAKE_CURRENT_SOURCE_DIR}/memif_connector.h
+    )
+  endif()
+endif()
+
 set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
 set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
\ No newline at end of file
diff --git a/libtransport/src/core/content_object.cc b/libtransport/src/core/content_object.cc
index 411494fdf..643e0388e 100644
--- a/libtransport/src/core/content_object.cc
+++ b/libtransport/src/core/content_object.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -35,6 +35,11 @@ namespace core {
 ContentObject::ContentObject(const Name &name, Packet::Format format,
                              std::size_t additional_header_size)
     : Packet(format, additional_header_size) {
+  if (TRANSPORT_EXPECT_FALSE(hicn_packet_set_data(format_, packet_start_) <
+                             0)) {
+    throw errors::MalformedPacketException();
+  }
+
   if (TRANSPORT_EXPECT_FALSE(
           hicn_data_set_name(format, packet_start_, &name.name_) < 0)) {
     throw errors::RuntimeException("Error filling the packet name.");
@@ -47,15 +52,20 @@ ContentObject::ContentObject(const Name &name, Packet::Format format,
   }
 }
 
-#ifdef __ANDROID__
 ContentObject::ContentObject(hicn_format_t format,
                              std::size_t additional_header_size)
-    : ContentObject(Name("0::0|0"), format, additional_header_size) {}
+    : ContentObject(
+#ifdef __ANDROID__
+          Name("0::0|0"),
 #else
-ContentObject::ContentObject(hicn_format_t format,
-                             std::size_t additional_header_size)
-    : ContentObject(Packet::base_name, format, additional_header_size) {}
+          Packet::base_name,
 #endif
+          format, additional_header_size) {
+  if (TRANSPORT_EXPECT_FALSE(hicn_packet_set_data(format_, packet_start_) <
+                             0)) {
+    throw errors::MalformedPacketException();
+  }
+}
 
 ContentObject::ContentObject(const Name &name, hicn_format_t format,
                              std::size_t additional_header_size,
@@ -167,6 +177,23 @@ void ContentObject::resetForHash() {
   }
 }
 
+bool ContentObject::isLast() const {
+  int is_last = 0;
+  if (hicn_data_is_last(format_, packet_start_, &is_last) < 0) {
+    throw errors::RuntimeException(
+        "Impossible to get last data flag from packet header.");
+  }
+
+  return is_last;
+}
+
+void ContentObject::setLast() {
+  if (hicn_data_set_last(format_, packet_start_) < 0) {
+    throw errors::RuntimeException(
+        "Impossible to set last data flag to packet header.");
+  }
+}
+
 }  // end namespace core
 
 }  // end namespace transport
diff --git a/libtransport/src/core/errors.cc b/libtransport/src/core/errors.cc
index 82647a60b..68fd7bf38 100644
--- a/libtransport/src/core/errors.cc
+++ b/libtransport/src/core/errors.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -39,6 +39,15 @@ std::string core_category_impl::message(int ev) const {
     case core_error::configuration_not_applied: {
       return "Configuration was not applied due to wrong parameters.";
     }
+    case core_error::send_failed: {
+      return "Error sending data to socket.";
+    }
+    case core_error::send_buffer_allocation_failed: {
+      return "Error allocating buffers to send data.";
+    }
+    case core_error::receive_failed: {
+      return "Error receiving data from socket.";
+    }
     default: {
       return "Unknown core error";
     }
diff --git a/libtransport/src/core/errors.h b/libtransport/src/core/errors.h
index a46f1dbcd..4532e6dc5 100644
--- a/libtransport/src/core/errors.h
+++ b/libtransport/src/core/errors.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -36,7 +36,10 @@ const std::error_category& core_category();
 enum class core_error {
   success = 0,
   configuration_parse_failed,
-  configuration_not_applied
+  configuration_not_applied,
+  send_failed,
+  send_buffer_allocation_failed,
+  receive_failed
 };
 
 /**
diff --git a/libtransport/src/core/facade.h b/libtransport/src/core/facade.h
index 199081271..1ad4437e2 100644
--- a/libtransport/src/core/facade.h
+++ b/libtransport/src/core/facade.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/core/global_workers.h b/libtransport/src/core/global_workers.h
new file mode 100644
index 000000000..1ac254188
--- /dev/null
+++ b/libtransport/src/core/global_workers.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <hicn/transport/utils/singleton.h>
+#include <hicn/transport/utils/thread_pool.h>
+
+#include <atomic>
+#include <mutex>
+
+namespace transport {
+namespace core {
+
+class GlobalWorkers : public utils::Singleton<GlobalWorkers> {
+ public:
+  friend class utils::Singleton<GlobalWorkers>;
+
+  ::utils::EventThread& getWorker() {
+    return thread_pool_.getWorker(counter_++ % thread_pool_.getNThreads());
+  }
+
+ private:
+  GlobalWorkers() : counter_(0), thread_pool_() {}
+
+  std::atomic_uint16_t counter_;
+  ::utils::ThreadPool thread_pool_;
+};
+
+}  // namespace core
+}  // namespace transport
\ No newline at end of file
diff --git a/libtransport/src/core/interest.cc b/libtransport/src/core/interest.cc
index 9d868ced0..b7719b3ed 100644
--- a/libtransport/src/core/interest.cc
+++ b/libtransport/src/core/interest.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -34,6 +34,10 @@ namespace core {
 Interest::Interest(const Name &interest_name, Packet::Format format,
                    std::size_t additional_header_size)
     : Packet(format, additional_header_size) {
+  if (hicn_packet_set_interest(format_, packet_start_) < 0) {
+    throw errors::MalformedPacketException();
+  }
+
   if (hicn_interest_set_name(format_, packet_start_,
                              interest_name.getConstStructReference()) < 0) {
     throw errors::MalformedPacketException();
@@ -45,13 +49,18 @@ Interest::Interest(const Name &interest_name, Packet::Format format,
   }
 }
 
-#ifdef __ANDROID__
 Interest::Interest(hicn_format_t format, std::size_t additional_header_size)
-    : Interest(Name("0::0|0"), format, additional_header_size) {}
+    : Interest(
+#ifdef __ANDROID__
+          Name("0::0|0"),
 #else
-Interest::Interest(hicn_format_t format, std::size_t additional_header_size)
-    : Interest(base_name, format, additional_header_size) {}
+          base_name,
 #endif
+          format, additional_header_size) {
+  if (hicn_packet_set_interest(format_, packet_start_) < 0) {
+    throw errors::MalformedPacketException();
+  }
+}
 
 Interest::Interest(MemBuf &&buffer) : Packet(std::move(buffer)) {
   if (hicn_interest_get_name(format_, packet_start_,
diff --git a/libtransport/src/core/io_module.cc b/libtransport/src/core/io_module.cc
index a751eabf5..69e4e8bcf 100644
--- a/libtransport/src/core/io_module.cc
+++ b/libtransport/src/core/io_module.cc
@@ -19,8 +19,10 @@
 #include <glog/logging.h>
 #include <hicn/transport/core/io_module.h>
 
+#include <iostream>
+
 #ifdef ANDROID
-#include <io_modules/udp/hicn_forwarder_module.h>
+#include <io_modules/hicn-light-ng/hicn_forwarder_module.h>
 #elif _WIN32
 #include <hicn/util/windows/windows_utils.h>
 #endif
@@ -55,8 +57,9 @@ IoModule *IoModule::load(const char *module_name) {
   if (!creator) {
     if ((error = dlerror()) != 0) {
       LOG(ERROR) << error;
-      return 0;
     }
+
+    return 0;
   }
 
   // create object and return it
@@ -85,4 +88,4 @@ bool IoModule::unload(IoModule *module) {
 }
 
 }  // namespace core
-}  // namespace transport
\ No newline at end of file
+}  // namespace transport
diff --git a/libtransport/src/core/local_connector.cc b/libtransport/src/core/local_connector.cc
index 50dadc677..f27be2e5c 100644
--- a/libtransport/src/core/local_connector.cc
+++ b/libtransport/src/core/local_connector.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -32,13 +32,17 @@ void LocalConnector::send(Packet &packet) {
     return;
   }
 
+  auto buffer =
+      std::static_pointer_cast<utils::MemBuf>(packet.shared_from_this());
+
   DLOG_IF(INFO, VLOG_IS_ON(3)) << "Sending packet to local socket.";
-  io_service_.get().post([this, p{packet.shared_from_this()}]() mutable {
-    receive_callback_(this, *p, std::make_error_code(std::errc(0)));
+  io_service_.get().post([this, buffer]() mutable {
+    std::vector<utils::MemBuf::Ptr> v{std::move(buffer)};
+    receive_callback_(this, v, std::make_error_code(std::errc(0)));
   });
 }
 
-void LocalConnector::send(const uint8_t *packet, std::size_t len) {
+void LocalConnector::send(const utils::MemBuf::Ptr &buffer) {
   throw errors::NotImplementedException();
 }
 
diff --git a/libtransport/src/core/local_connector.h b/libtransport/src/core/local_connector.h
index 0e2d8f676..eede89e74 100644
--- a/libtransport/src/core/local_connector.h
+++ b/libtransport/src/core/local_connector.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -42,7 +42,7 @@ class LocalConnector : public Connector {
 
   void send(Packet &packet) override;
 
-  void send(const uint8_t *packet, std::size_t len) override;
+  void send(const utils::MemBuf::Ptr &buffer) override;
 
   void close() override;
 
diff --git a/libtransport/src/core/manifest.cc b/libtransport/src/core/manifest.cc
index 3f890f3d0..da2689426 100644
--- a/libtransport/src/core/manifest.cc
+++ b/libtransport/src/core/manifest.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/core/manifest.h b/libtransport/src/core/manifest.h
index 9b25ebd67..5bdbfc6ff 100644
--- a/libtransport/src/core/manifest.h
+++ b/libtransport/src/core/manifest.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,6 +16,7 @@
 #pragma once
 
 #include <core/manifest_format.h>
+#include <glog/logging.h>
 #include <hicn/transport/core/content_object.h>
 #include <hicn/transport/core/name.h>
 
@@ -40,17 +41,20 @@ class Manifest : public Base {
   using Encoder = typename FormatTraits::Encoder;
   using Decoder = typename FormatTraits::Decoder;
 
-  Manifest(std::size_t signature_size = 0)
-      : Base(HF_INET6_TCP_AH, signature_size),
+  Manifest(Packet::Format format, std::size_t signature_size = 0)
+      : Base(format, signature_size),
         encoder_(*this, signature_size),
         decoder_(*this) {
+    DCHECK(_is_ah(format));
     Base::setPayloadType(PayloadType::MANIFEST);
   }
 
-  Manifest(const core::Name &name, std::size_t signature_size = 0)
-      : Base(name, HF_INET6_TCP_AH, signature_size),
+  Manifest(Packet::Format format, const core::Name &name,
+           std::size_t signature_size = 0)
+      : Base(name, format, signature_size),
         encoder_(*this, signature_size),
         decoder_(*this) {
+    DCHECK(_is_ah(format));
     Base::setPayloadType(PayloadType::MANIFEST);
   }
 
@@ -62,6 +66,11 @@ class Manifest : public Base {
     Base::setPayloadType(PayloadType::MANIFEST);
   }
 
+  // Useful for decoding manifests while avoiding packet copy
+  template <typename T>
+  Manifest(T &base)
+      : Base(base.getFormat()), encoder_(base, 0, false), decoder_(base) {}
+
   virtual ~Manifest() = default;
 
   std::size_t estimateManifestSize(std::size_t additional_entries = 0) {
@@ -78,24 +87,27 @@ class Manifest : public Base {
   Manifest &decode() {
     Manifest::decoder_.decode();
 
-    manifest_type_ = decoder_.getManifestType();
+    manifest_type_ = decoder_.getType();
+    manifest_transport_type_ = decoder_.getTransportType();
     hash_algorithm_ = decoder_.getHashAlgorithm();
-    is_last_ = decoder_.getIsFinalManifest();
+    is_last_ = decoder_.getIsLast();
 
     return static_cast<ManifestImpl &>(*this).decodeImpl();
   }
 
-  static std::size_t getManifestHeaderSize() {
-    return Encoder::getManifestHeaderSize();
+  static std::size_t manifestHeaderSize(
+      interface::ProductionProtocolAlgorithms transport_type =
+          interface::ProductionProtocolAlgorithms::UNKNOWN) {
+    return Encoder::manifestHeaderSize(transport_type);
   }
 
-  static std::size_t getManifestEntrySize() {
-    return Encoder::getManifestEntrySize();
+  static std::size_t manifestEntrySize() {
+    return Encoder::manifestEntrySize();
   }
 
-  Manifest &setManifestType(ManifestType type) {
+  Manifest &setType(ManifestType type) {
     manifest_type_ = type;
-    encoder_.setManifestType(manifest_type_);
+    encoder_.setType(manifest_type_);
     return *this;
   }
 
@@ -105,31 +117,46 @@ class Manifest : public Base {
     return *this;
   }
 
-  auth::CryptoHashType getHashAlgorithm() { return hash_algorithm_; }
+  auth::CryptoHashType getHashAlgorithm() const { return hash_algorithm_; }
 
-  ManifestType getManifestType() const { return manifest_type_; }
+  ManifestType getType() const { return manifest_type_; }
+
+  interface::ProductionProtocolAlgorithms getTransportType() const {
+    return manifest_transport_type_;
+  }
 
-  bool isFinalManifest() const { return is_last_; }
+  bool getIsLast() const { return is_last_; }
 
   Manifest &setVersion(ManifestVersion version) {
     encoder_.setVersion(version);
     return *this;
   }
 
-  Manifest &setFinalBlockNumber(std::uint32_t final_block_number) {
-    encoder_.setFinalBlockNumber(final_block_number);
+  Manifest &setParamsBytestream(const ParamsBytestream &params) {
+    manifest_transport_type_ =
+        interface::ProductionProtocolAlgorithms::BYTE_STREAM;
+    encoder_.setParamsBytestream(params);
     return *this;
   }
 
-  uint32_t getFinalBlockNumber() const {
-    return decoder_.getFinalBlockNumber();
+  Manifest &setParamsRTC(const ParamsRTC &params) {
+    manifest_transport_type_ =
+        interface::ProductionProtocolAlgorithms::RTC_PROD;
+    encoder_.setParamsRTC(params);
+    return *this;
+  }
+
+  ParamsBytestream getParamsBytestream() const {
+    return decoder_.getParamsBytestream();
   }
 
+  ParamsRTC getParamsRTC() const { return decoder_.getParamsRTC(); }
+
   ManifestVersion getVersion() const { return decoder_.getVersion(); }
 
-  Manifest &setFinalManifest(bool is_final_manifest) {
-    encoder_.setIsFinalManifest(is_final_manifest);
-    is_last_ = is_final_manifest;
+  Manifest &setIsLast(bool is_last) {
+    encoder_.setIsLast(is_last);
+    is_last_ = is_last;
     return *this;
   }
 
@@ -141,6 +168,7 @@ class Manifest : public Base {
 
  protected:
   ManifestType manifest_type_;
+  interface::ProductionProtocolAlgorithms manifest_transport_type_;
   auth::CryptoHashType hash_algorithm_;
   bool is_last_;
 
diff --git a/libtransport/src/core/manifest_format.h b/libtransport/src/core/manifest_format.h
index 90d221f5e..38f26067e 100644
--- a/libtransport/src/core/manifest_format.h
+++ b/libtransport/src/core/manifest_format.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -17,6 +17,7 @@
 
 #include <hicn/transport/auth/crypto_hash.h>
 #include <hicn/transport/core/name.h>
+#include <hicn/transport/interfaces/socket_options_keys.h>
 
 #include <cinttypes>
 #include <type_traits>
@@ -26,15 +27,6 @@ namespace transport {
 
 namespace core {
 
-enum class ManifestFields : uint8_t {
-  VERSION,
-  HASH_ALGORITHM,
-  SEGMENT_CALCULATION_STRATEGY,
-  FINAL_MANIFEST,
-  NAME_HASH_LIST,
-  BASE_NAME
-};
-
 enum class ManifestVersion : uint8_t {
   VERSION_1 = 1,
 };
@@ -45,18 +37,24 @@ enum class ManifestType : uint8_t {
   FLIC_MANIFEST = 3,
 };
 
-/**
- * INCREMENTAL: Manifests will be received inline with the data with no specific
- * assumption regarding the manifest capacity. Consumers can send interests
- * using a +1 heuristic.
- *
- * MANIFEST_CAPACITY_BASED: manifests with capacity N have a suffix multiple of
- * N+1: 0, N+1, 2(N+1) etc. Contents have a suffix incremented by 1 except when
- * it conflicts with a manifest: 1, 2, ..., N, N+2, N+3, ..., 2N+1, 2N+3
- */
-enum class NextSegmentCalculationStrategy : uint8_t {
-  INCREMENTAL = 1,
-  MANIFEST_CAPACITY_BASED = 2,
+struct ParamsRTC {
+  std::uint64_t timestamp;
+  std::uint32_t prod_rate;
+  std::uint32_t prod_seg;
+  std::uint32_t support_fec;
+
+  bool operator==(const ParamsRTC &other) const {
+    return (timestamp == other.timestamp && prod_rate == other.prod_rate &&
+            prod_seg == other.prod_seg && support_fec == other.support_fec);
+  }
+};
+
+struct ParamsBytestream {
+  std::uint32_t final_segment;
+
+  bool operator==(const ParamsBytestream &other) const {
+    return (final_segment == other.final_segment);
+  }
 };
 
 template <typename T>
@@ -84,24 +82,14 @@ class ManifestEncoder {
     return static_cast<Implementation &>(*this).clearImpl();
   }
 
-  ManifestEncoder &setManifestType(ManifestType type) {
-    return static_cast<Implementation &>(*this).setManifestTypeImpl(type);
+  ManifestEncoder &setType(ManifestType type) {
+    return static_cast<Implementation &>(*this).setTypeImpl(type);
   }
 
   ManifestEncoder &setHashAlgorithm(auth::CryptoHashType hash) {
     return static_cast<Implementation &>(*this).setHashAlgorithmImpl(hash);
   }
 
-  ManifestEncoder &setFinalChunkNumber(uint32_t final_chunk) {
-    return static_cast<Implementation &>(*this).setFinalChunkImpl(final_chunk);
-  }
-
-  ManifestEncoder &setNextSegmentCalculationStrategy(
-      NextSegmentCalculationStrategy strategy) {
-    return static_cast<Implementation &>(*this)
-        .setNextSegmentCalculationStrategyImpl(strategy);
-  }
-
   template <
       typename T,
       typename = std::enable_if_t<std::is_same<
@@ -116,8 +104,8 @@ class ManifestEncoder {
         suffix, std::forward<Hash &&>(hash));
   }
 
-  ManifestEncoder &setIsFinalManifest(bool is_last) {
-    return static_cast<Implementation &>(*this).setIsFinalManifestImpl(is_last);
+  ManifestEncoder &setIsLast(bool is_last) {
+    return static_cast<Implementation &>(*this).setIsLastImpl(is_last);
   }
 
   ManifestEncoder &setVersion(ManifestVersion version) {
@@ -133,17 +121,22 @@ class ManifestEncoder {
     return static_cast<Implementation &>(*this).updateImpl();
   }
 
-  ManifestEncoder &setFinalBlockNumber(std::uint32_t final_block_number) {
-    return static_cast<Implementation &>(*this).setFinalBlockNumberImpl(
-        final_block_number);
+  ManifestEncoder &setParamsBytestream(const ParamsBytestream &params) {
+    return static_cast<Implementation &>(*this).setParamsBytestreamImpl(params);
+  }
+
+  ManifestEncoder &setParamsRTC(const ParamsRTC &params) {
+    return static_cast<Implementation &>(*this).setParamsRTCImpl(params);
   }
 
-  static std::size_t getManifestHeaderSize() {
-    return Implementation::getManifestHeaderSizeImpl();
+  static std::size_t manifestHeaderSize(
+      interface::ProductionProtocolAlgorithms transport_type =
+          interface::ProductionProtocolAlgorithms::UNKNOWN) {
+    return Implementation::manifestHeaderSizeImpl(transport_type);
   }
 
-  static std::size_t getManifestEntrySize() {
-    return Implementation::getManifestEntrySizeImpl();
+  static std::size_t manifestEntrySize() {
+    return Implementation::manifestEntrySizeImpl();
   }
 };
 
@@ -158,21 +151,16 @@ class ManifestDecoder {
 
   void decode() { static_cast<Implementation &>(*this).decodeImpl(); }
 
-  ManifestType getManifestType() const {
-    return static_cast<const Implementation &>(*this).getManifestTypeImpl();
-  }
-
-  auth::CryptoHashType getHashAlgorithm() const {
-    return static_cast<const Implementation &>(*this).getHashAlgorithmImpl();
+  ManifestType getType() const {
+    return static_cast<const Implementation &>(*this).getTypeImpl();
   }
 
-  uint32_t getFinalChunkNumber() const {
-    return static_cast<const Implementation &>(*this).getFinalChunkImpl();
+  interface::ProductionProtocolAlgorithms getTransportType() const {
+    return static_cast<const Implementation &>(*this).getTransportTypeImpl();
   }
 
-  NextSegmentCalculationStrategy getNextSegmentCalculationStrategy() const {
-    return static_cast<const Implementation &>(*this)
-        .getNextSegmentCalculationStrategyImpl();
+  auth::CryptoHashType getHashAlgorithm() const {
+    return static_cast<const Implementation &>(*this).getHashAlgorithmImpl();
   }
 
   core::Name getBaseName() const {
@@ -183,8 +171,8 @@ class ManifestDecoder {
     return static_cast<Implementation &>(*this).getSuffixHashListImpl();
   }
 
-  bool getIsFinalManifest() const {
-    return static_cast<const Implementation &>(*this).getIsFinalManifestImpl();
+  bool getIsLast() const {
+    return static_cast<const Implementation &>(*this).getIsLastImpl();
   }
 
   ManifestVersion getVersion() const {
@@ -196,8 +184,12 @@ class ManifestDecoder {
         .estimateSerializedLengthImpl(number_of_entries);
   }
 
-  uint32_t getFinalBlockNumber() const {
-    return static_cast<const Implementation &>(*this).getFinalBlockNumberImpl();
+  ParamsBytestream getParamsBytestream() const {
+    return static_cast<const Implementation &>(*this).getParamsBytestreamImpl();
+  }
+
+  ParamsRTC getParamsRTC() const {
+    return static_cast<const Implementation &>(*this).getParamsRTCImpl();
   }
 };
 
diff --git a/libtransport/src/core/manifest_format_fixed.cc b/libtransport/src/core/manifest_format_fixed.cc
index 11d4a56cb..4c8a5e031 100644
--- a/libtransport/src/core/manifest_format_fixed.cc
+++ b/libtransport/src/core/manifest_format_fixed.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -27,164 +27,288 @@ FixedManifestEncoder::FixedManifestEncoder(Packet &packet,
                                            bool clear)
     : packet_(packet),
       max_size_(Packet::default_mtu - packet_.headerSize()),
-      manifest_header_(reinterpret_cast<ManifestHeader *>(
-          packet_.writableData() + packet_.headerSize())),
-      manifest_entries_(
-          reinterpret_cast<ManifestEntry *>(manifest_header_ + 1)),
-      current_entry_(0),
-      signature_size_(signature_size) {
+      signature_size_(signature_size),
+      transport_type_(interface::ProductionProtocolAlgorithms::UNKNOWN),
+      encoded_(false),
+      params_bytestream_({0}),
+      params_rtc_({0}) {
+  manifest_meta_ = reinterpret_cast<ManifestMeta *>(packet_.writableData() +
+                                                    packet_.headerSize());
+  manifest_entry_meta_ =
+      reinterpret_cast<ManifestEntryMeta *>(manifest_meta_ + 1);
+
   if (clear) {
-    *manifest_header_ = {0};
+    *manifest_meta_ = {0};
+    *manifest_entry_meta_ = {0};
   }
 }
 
 FixedManifestEncoder::~FixedManifestEncoder() {}
 
 FixedManifestEncoder &FixedManifestEncoder::encodeImpl() {
-  packet_.append(sizeof(ManifestHeader) +
-                 manifest_header_->number_of_entries * sizeof(ManifestEntry));
+  if (encoded_) {
+    return *this;
+  }
+
+  manifest_meta_->transport_type = static_cast<uint8_t>(transport_type_);
+  manifest_entry_meta_->nb_entries = manifest_entries_.size();
+
+  packet_.append(FixedManifestEncoder::manifestHeaderSizeImpl());
   packet_.updateLength();
+
+  switch (transport_type_) {
+    case interface::ProductionProtocolAlgorithms::BYTE_STREAM:
+      packet_.appendPayload(
+          reinterpret_cast<const uint8_t *>(&params_bytestream_),
+          MANIFEST_PARAMS_BYTESTREAM_SIZE);
+      break;
+    case interface::ProductionProtocolAlgorithms::RTC_PROD:
+      packet_.appendPayload(reinterpret_cast<const uint8_t *>(&params_rtc_),
+                            MANIFEST_PARAMS_RTC_SIZE);
+      break;
+    default:
+      break;
+  }
+
+  packet_.appendPayload(
+      reinterpret_cast<const uint8_t *>(manifest_entries_.data()),
+      manifest_entries_.size() * FixedManifestEncoder::manifestEntrySizeImpl());
+
+  if (TRANSPORT_EXPECT_FALSE(packet_.payloadSize() <
+                             estimateSerializedLengthImpl())) {
+    throw errors::RuntimeException("Error encoding the manifest");
+  }
+
+  encoded_ = true;
   return *this;
 }
 
 FixedManifestEncoder &FixedManifestEncoder::clearImpl() {
-  packet_.trimEnd(sizeof(ManifestHeader) +
-                  manifest_header_->number_of_entries * sizeof(ManifestEntry));
-  current_entry_ = 0;
-  *manifest_header_ = {0};
+  if (encoded_) {
+    packet_.trimEnd(FixedManifestEncoder::manifestHeaderSizeImpl() +
+                    manifest_entries_.size() *
+                        FixedManifestEncoder::manifestEntrySizeImpl());
+  }
+
+  transport_type_ = interface::ProductionProtocolAlgorithms::UNKNOWN;
+  encoded_ = false;
+  params_bytestream_ = {0};
+  params_rtc_ = {0};
+  *manifest_meta_ = {0};
+  *manifest_entry_meta_ = {0};
+  manifest_entries_.clear();
+
   return *this;
 }
 
-FixedManifestEncoder &FixedManifestEncoder::setHashAlgorithmImpl(
-    auth::CryptoHashType algorithm) {
-  manifest_header_->hash_algorithm = static_cast<uint8_t>(algorithm);
+FixedManifestEncoder &FixedManifestEncoder::updateImpl() {
+  max_size_ = Packet::default_mtu - packet_.headerSize() - signature_size_;
+  return *this;
+}
+
+FixedManifestEncoder &FixedManifestEncoder::setVersionImpl(
+    ManifestVersion version) {
+  manifest_meta_->version = static_cast<uint8_t>(version);
   return *this;
 }
 
-FixedManifestEncoder &FixedManifestEncoder::setManifestTypeImpl(
+FixedManifestEncoder &FixedManifestEncoder::setTypeImpl(
     ManifestType manifest_type) {
-  manifest_header_->manifest_type = static_cast<uint8_t>(manifest_type);
+  manifest_meta_->type = static_cast<uint8_t>(manifest_type);
+  return *this;
+}
+
+FixedManifestEncoder &FixedManifestEncoder::setHashAlgorithmImpl(
+    auth::CryptoHashType algorithm) {
+  manifest_meta_->hash_algorithm = static_cast<uint8_t>(algorithm);
   return *this;
 }
 
-FixedManifestEncoder &
-FixedManifestEncoder::setNextSegmentCalculationStrategyImpl(
-    NextSegmentCalculationStrategy strategy) {
-  manifest_header_->next_segment_strategy = static_cast<uint8_t>(strategy);
+FixedManifestEncoder &FixedManifestEncoder::setIsLastImpl(bool is_last) {
+  manifest_meta_->is_last = static_cast<uint8_t>(is_last);
   return *this;
 }
 
 FixedManifestEncoder &FixedManifestEncoder::setBaseNameImpl(
     const core::Name &base_name) {
-  base_name.copyToDestination(
-      reinterpret_cast<uint8_t *>(&manifest_header_->prefix[0]), false);
-  manifest_header_->flags.ipv6 =
+  manifest_entry_meta_->is_ipv6 =
       base_name.getAddressFamily() == AF_INET6 ? 1_U8 : 0_U8;
+  base_name.copyPrefixToDestination(
+      reinterpret_cast<uint8_t *>(&manifest_entry_meta_->prefix[0]));
   return *this;
 }
 
-FixedManifestEncoder &FixedManifestEncoder::addSuffixAndHashImpl(
-    uint32_t suffix, const auth::CryptoHash &hash) {
-  auto _hash = hash.getDigest();
-  addSuffixHashBytes(suffix, _hash.data(), _hash.size());
+FixedManifestEncoder &FixedManifestEncoder::setParamsBytestreamImpl(
+    const ParamsBytestream &params) {
+  transport_type_ = interface::ProductionProtocolAlgorithms::BYTE_STREAM;
+  params_bytestream_ = TransportParamsBytestream{
+      .final_segment = params.final_segment,
+  };
   return *this;
 }
 
-void FixedManifestEncoder::addSuffixHashBytes(uint32_t suffix,
-                                              const uint8_t *hash,
-                                              std::size_t length) {
-  manifest_entries_[current_entry_].suffix = htonl(suffix);
-  //  std::copy(hash, hash + length,
-  //            manifest_entries_[current_entry_].hash);
-  std::memcpy(
-      reinterpret_cast<uint8_t *>(manifest_entries_[current_entry_].hash), hash,
-      length);
+FixedManifestEncoder &FixedManifestEncoder::setParamsRTCImpl(
+    const ParamsRTC &params) {
+  transport_type_ = interface::ProductionProtocolAlgorithms::RTC_PROD;
+  params_rtc_ = TransportParamsRTC{
+      .timestamp = params.timestamp,
+      .prod_rate = params.prod_rate,
+      .prod_seg = params.prod_seg,
+      .support_fec = params.support_fec,
+  };
+  return *this;
+}
 
-  manifest_header_->number_of_entries++;
-  current_entry_++;
+FixedManifestEncoder &FixedManifestEncoder::addSuffixAndHashImpl(
+    uint32_t suffix, const auth::CryptoHash &hash) {
+  std::vector<uint8_t> _hash = hash.getDigest();
+
+  manifest_entries_.push_back(ManifestEntry{
+      .suffix = htonl(suffix),
+      .hash = {0},
+  });
+
+  std::memcpy(reinterpret_cast<uint8_t *>(manifest_entries_.back().hash),
+              _hash.data(), _hash.size());
 
   if (TRANSPORT_EXPECT_FALSE(estimateSerializedLengthImpl() > max_size_)) {
     throw errors::RuntimeException("Manifest size exceeded the packet MTU!");
   }
-}
-
-FixedManifestEncoder &FixedManifestEncoder::setIsFinalManifestImpl(
-    bool is_last) {
-  manifest_header_->flags.is_last = static_cast<uint8_t>(is_last);
-  return *this;
-}
 
-FixedManifestEncoder &FixedManifestEncoder::setVersionImpl(
-    ManifestVersion version) {
-  manifest_header_->version = static_cast<uint8_t>(version);
   return *this;
 }
 
 std::size_t FixedManifestEncoder::estimateSerializedLengthImpl(
     std::size_t additional_entries) {
-  return sizeof(ManifestHeader) +
-         (manifest_header_->number_of_entries + additional_entries) *
-             sizeof(ManifestEntry);
+  return FixedManifestEncoder::manifestHeaderSizeImpl(transport_type_) +
+         (manifest_entries_.size() + additional_entries) *
+             FixedManifestEncoder::manifestEntrySizeImpl();
 }
 
-FixedManifestEncoder &FixedManifestEncoder::updateImpl() {
-  max_size_ = Packet::default_mtu - packet_.headerSize() - signature_size_;
-  return *this;
-}
-
-FixedManifestEncoder &FixedManifestEncoder::setFinalBlockNumberImpl(
-    std::uint32_t final_block_number) {
-  manifest_header_->final_block_number = htonl(final_block_number);
-  return *this;
-}
+std::size_t FixedManifestEncoder::manifestHeaderSizeImpl(
+    interface::ProductionProtocolAlgorithms transport_type) {
+  uint32_t params_size = 0;
+
+  switch (transport_type) {
+    case interface::ProductionProtocolAlgorithms::BYTE_STREAM:
+      params_size = MANIFEST_PARAMS_BYTESTREAM_SIZE;
+      break;
+    case interface::ProductionProtocolAlgorithms::RTC_PROD:
+      params_size = MANIFEST_PARAMS_RTC_SIZE;
+      break;
+    default:
+      break;
+  }
 
-std::size_t FixedManifestEncoder::getManifestHeaderSizeImpl() {
-  return sizeof(ManifestHeader);
+  return MANIFEST_META_SIZE + MANIFEST_ENTRY_META_SIZE + params_size;
 }
 
-std::size_t FixedManifestEncoder::getManifestEntrySizeImpl() {
-  return sizeof(ManifestEntry);
+std::size_t FixedManifestEncoder::manifestEntrySizeImpl() {
+  return MANIFEST_ENTRY_SIZE;
 }
 
 FixedManifestDecoder::FixedManifestDecoder(Packet &packet)
-    : packet_(packet),
-      manifest_header_(reinterpret_cast<ManifestHeader *>(
-          packet_.getPayload()->writableData())),
-      manifest_entries_(reinterpret_cast<ManifestEntry *>(
-          packet_.getPayload()->writableData() + sizeof(ManifestHeader))) {}
+    : packet_(packet), decoded_(false) {
+  manifest_meta_ =
+      reinterpret_cast<ManifestMeta *>(packet_.getPayload()->writableData());
+  manifest_entry_meta_ =
+      reinterpret_cast<ManifestEntryMeta *>(manifest_meta_ + 1);
+  transport_type_ = getTransportTypeImpl();
+
+  switch (transport_type_) {
+    case interface::ProductionProtocolAlgorithms::BYTE_STREAM:
+      params_bytestream_ = reinterpret_cast<TransportParamsBytestream *>(
+          manifest_entry_meta_ + 1);
+      manifest_entries_ =
+          reinterpret_cast<ManifestEntry *>(params_bytestream_ + 1);
+      break;
+    case interface::ProductionProtocolAlgorithms::RTC_PROD:
+      params_rtc_ =
+          reinterpret_cast<TransportParamsRTC *>(manifest_entry_meta_ + 1);
+      manifest_entries_ = reinterpret_cast<ManifestEntry *>(params_rtc_ + 1);
+      break;
+    default:
+      manifest_entries_ =
+          reinterpret_cast<ManifestEntry *>(manifest_entry_meta_ + 1);
+      break;
+  }
+}
 
 FixedManifestDecoder::~FixedManifestDecoder() {}
 
 void FixedManifestDecoder::decodeImpl() {
+  if (decoded_) {
+    return;
+  }
+
   std::size_t packet_size = packet_.payloadSize();
 
-  if (packet_size < sizeof(ManifestHeader) ||
+  if (packet_size <
+          FixedManifestEncoder::manifestHeaderSizeImpl(transport_type_) ||
       packet_size < estimateSerializedLengthImpl()) {
     throw errors::RuntimeException(
         "The packet does not match expected manifest size.");
   }
+
+  decoded_ = true;
+}
+
+FixedManifestDecoder &FixedManifestDecoder::clearImpl() {
+  decoded_ = false;
+  return *this;
 }
 
-FixedManifestDecoder &FixedManifestDecoder::clearImpl() { return *this; }
+ManifestType FixedManifestDecoder::getTypeImpl() const {
+  return static_cast<ManifestType>(manifest_meta_->type);
+}
 
-ManifestType FixedManifestDecoder::getManifestTypeImpl() const {
-  return static_cast<ManifestType>(manifest_header_->manifest_type);
+ManifestVersion FixedManifestDecoder::getVersionImpl() const {
+  return static_cast<ManifestVersion>(manifest_meta_->version);
+}
+
+interface::ProductionProtocolAlgorithms
+FixedManifestDecoder::getTransportTypeImpl() const {
+  return static_cast<interface::ProductionProtocolAlgorithms>(
+      manifest_meta_->transport_type);
 }
 
 auth::CryptoHashType FixedManifestDecoder::getHashAlgorithmImpl() const {
-  return static_cast<auth::CryptoHashType>(manifest_header_->hash_algorithm);
+  return static_cast<auth::CryptoHashType>(manifest_meta_->hash_algorithm);
 }
 
-NextSegmentCalculationStrategy
-FixedManifestDecoder::getNextSegmentCalculationStrategyImpl() const {
-  return static_cast<NextSegmentCalculationStrategy>(
-      manifest_header_->next_segment_strategy);
+bool FixedManifestDecoder::getIsLastImpl() const {
+  return static_cast<bool>(manifest_meta_->is_last);
+}
+
+core::Name FixedManifestDecoder::getBaseNameImpl() const {
+  if (static_cast<bool>(manifest_entry_meta_->is_ipv6)) {
+    return core::Name(
+        AF_INET6, reinterpret_cast<uint8_t *>(&manifest_entry_meta_->prefix));
+  } else {
+    return core::Name(
+        AF_INET, reinterpret_cast<uint8_t *>(&manifest_entry_meta_->prefix));
+  }
+}
+
+ParamsBytestream FixedManifestDecoder::getParamsBytestreamImpl() const {
+  return ParamsBytestream{
+      .final_segment = params_bytestream_->final_segment,
+  };
+}
+
+ParamsRTC FixedManifestDecoder::getParamsRTCImpl() const {
+  return ParamsRTC{
+      .timestamp = params_rtc_->timestamp,
+      .prod_rate = params_rtc_->prod_rate,
+      .prod_seg = params_rtc_->prod_seg,
+      .support_fec = params_rtc_->support_fec,
+  };
 }
 
 typename Fixed::SuffixList FixedManifestDecoder::getSuffixHashListImpl() {
   typename Fixed::SuffixList hash_list;
 
-  for (int i = 0; i < manifest_header_->number_of_entries; i++) {
+  for (int i = 0; i < manifest_entry_meta_->nb_entries; i++) {
     hash_list.insert(hash_list.end(),
                      std::make_pair(ntohl(manifest_entries_[i].suffix),
                                     reinterpret_cast<uint8_t *>(
@@ -194,33 +318,11 @@ typename Fixed::SuffixList FixedManifestDecoder::getSuffixHashListImpl() {
   return hash_list;
 }
 
-core::Name FixedManifestDecoder::getBaseNameImpl() const {
-  if (static_cast<bool>(manifest_header_->flags.ipv6)) {
-    return core::Name(AF_INET6,
-                      reinterpret_cast<uint8_t *>(&manifest_header_->prefix));
-  } else {
-    return core::Name(AF_INET,
-                      reinterpret_cast<uint8_t *>(&manifest_header_->prefix));
-  }
-}
-
-bool FixedManifestDecoder::getIsFinalManifestImpl() const {
-  return static_cast<bool>(manifest_header_->flags.is_last);
-}
-
-ManifestVersion FixedManifestDecoder::getVersionImpl() const {
-  return static_cast<ManifestVersion>(manifest_header_->version);
-}
-
 std::size_t FixedManifestDecoder::estimateSerializedLengthImpl(
     std::size_t additional_entries) const {
-  return sizeof(ManifestHeader) +
-         (additional_entries + manifest_header_->number_of_entries) *
-             sizeof(ManifestEntry);
-}
-
-uint32_t FixedManifestDecoder::getFinalBlockNumberImpl() const {
-  return ntohl(manifest_header_->final_block_number);
+  return FixedManifestEncoder::manifestHeaderSizeImpl(transport_type_) +
+         (manifest_entry_meta_->nb_entries + additional_entries) *
+             FixedManifestEncoder::manifestEntrySizeImpl();
 }
 
 }  // end namespace core
diff --git a/libtransport/src/core/manifest_format_fixed.h b/libtransport/src/core/manifest_format_fixed.h
index 56ad4ef6d..ade4bf02c 100644
--- a/libtransport/src/core/manifest_format_fixed.h
+++ b/libtransport/src/core/manifest_format_fixed.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -24,26 +24,74 @@ namespace transport {
 
 namespace core {
 
-//   0                   1                   2                   3
-//   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-//  |Version| MType |HashAlg|NextStr|     Flags     |NumberOfEntries|
-//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-//  |                       Final Block Number                      |
-//  +---------------------------------------------------------------|
-//  |                                                               |
-//  +                                                               +
-//  |                                                               |
-//  +                             Prefix                            +
-//  |                                                               |
-//  +                                                               +
-//  |                                                               |
-//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-//  |                             Suffix                            |
-//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-//  |                           Hash Value                          |
-//  |                                                               |
-//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Manifest Metadata:
+//  0                   1                   2                   3
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |Version|  Type | Transport Type| Hash Algorithm|L|   Reserved  |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+// Manifest Entry Metadata:
+//  0                   1                   2                   3
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |   Nb entries  |I|                   Reserved                  |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                                                               |
+// +                                                               +
+// |                                                               |
+// +                             Prefix                            +
+// |                                                               |
+// +                                                               +
+// |                                                               |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+// Manifest Transport Parameters - Bytestream:
+//  0                   1                   2                   3
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                         Final Segment                         |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+// Manifest Transport Parameters - RTC:
+//  0                   1                   2                   3
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                                                               |
+// +                           Timestamp                           +
+// |                                                               |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                        Production Rate                        |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                        Current Segment                        |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |F|                                                             |
+// +               Reserved for future parameters                  +
+// |                                                               |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+// Manifest Entry:
+//  0                   1                   2                   3
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                         Packet Suffix                         |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                                                               |
+// +                                                               +
+// |                                                               |
+// +                                                               +
+// |                                                               |
+// +                                                               +
+// |                                                               |
+// +                         Packet Digest                         +
+// |                                                               |
+// +                                                               +
+// |                                                               |
+// +                                                               +
+// |                                                               |
+// +                                                               +
+// |                                                               |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 class FixedManifestEncoder;
 class FixedManifestDecoder;
@@ -58,28 +106,47 @@ struct Fixed {
   using SuffixList = std::list<std::pair<uint32_t, uint8_t *>>;
 };
 
-struct Flags {
-  std::uint8_t ipv6 : 1;
-  std::uint8_t is_last : 1;
-  std::uint8_t unused : 6;
+const size_t MANIFEST_META_SIZE = 4;
+struct __attribute__((__packed__)) ManifestMeta {
+  std::uint8_t version : 4;
+  std::uint8_t type : 4;
+  std::uint8_t transport_type;
+  std::uint8_t hash_algorithm;
+  std::uint8_t is_last;
 };
+static_assert(sizeof(ManifestMeta) == MANIFEST_META_SIZE);
 
-struct ManifestEntry {
-  std::uint32_t suffix;
-  std::uint32_t hash[8];
+const size_t MANIFEST_ENTRY_META_SIZE = 20;
+struct __attribute__((__packed__)) ManifestEntryMeta {
+  std::uint8_t nb_entries;
+  std::uint8_t is_ipv6;
+  std::uint16_t unused;
+  std::uint32_t prefix[4];
 };
+static_assert(sizeof(ManifestEntryMeta) == MANIFEST_ENTRY_META_SIZE);
 
-struct ManifestHeader {
-  std::uint8_t version : 4;
-  std::uint8_t manifest_type : 4;
-  std::uint8_t hash_algorithm : 4;
-  std::uint8_t next_segment_strategy : 4;
-  Flags flags;
-  std::uint8_t number_of_entries;
-  std::uint32_t final_block_number;
-  std::uint32_t prefix[4];
-  ManifestEntry entries[0];
+const size_t MANIFEST_PARAMS_BYTESTREAM_SIZE = 4;
+struct __attribute__((__packed__)) TransportParamsBytestream {
+  std::uint32_t final_segment;
+};
+static_assert(sizeof(TransportParamsBytestream) ==
+              MANIFEST_PARAMS_BYTESTREAM_SIZE);
+
+const size_t MANIFEST_PARAMS_RTC_SIZE = 20;
+struct __attribute__((__packed__)) TransportParamsRTC {
+  std::uint64_t timestamp;
+  std::uint32_t prod_rate;
+  std::uint32_t prod_seg;
+  std::uint32_t support_fec;
+};
+static_assert(sizeof(TransportParamsRTC) == MANIFEST_PARAMS_RTC_SIZE);
+
+const size_t MANIFEST_ENTRY_SIZE = 36;
+struct __attribute__((__packed__)) ManifestEntry {
+  std::uint32_t suffix;
+  std::uint32_t hash[8];
 };
+static_assert(sizeof(ManifestEntry) == MANIFEST_ENTRY_SIZE);
 
 static const constexpr std::uint8_t manifest_version = 1;
 
@@ -91,46 +158,48 @@ class FixedManifestEncoder : public ManifestEncoder<FixedManifestEncoder> {
   ~FixedManifestEncoder();
 
   FixedManifestEncoder &encodeImpl();
-
   FixedManifestEncoder &clearImpl();
+  FixedManifestEncoder &updateImpl();
 
-  FixedManifestEncoder &setManifestTypeImpl(ManifestType manifest_type);
-
+  // ManifestMeta
+  FixedManifestEncoder &setVersionImpl(ManifestVersion version);
+  FixedManifestEncoder &setTypeImpl(ManifestType manifest_type);
   FixedManifestEncoder &setHashAlgorithmImpl(Fixed::HashType algorithm);
+  FixedManifestEncoder &setIsLastImpl(bool is_last);
 
-  FixedManifestEncoder &setNextSegmentCalculationStrategyImpl(
-      NextSegmentCalculationStrategy strategy);
-
+  // ManifestEntryMeta
   FixedManifestEncoder &setBaseNameImpl(const core::Name &base_name);
 
+  // TransportParams
+  FixedManifestEncoder &setParamsBytestreamImpl(const ParamsBytestream &params);
+  FixedManifestEncoder &setParamsRTCImpl(const ParamsRTC &params);
+
+  // ManifestEntry
   FixedManifestEncoder &addSuffixAndHashImpl(uint32_t suffix,
                                              const Fixed::Hash &hash);
 
-  FixedManifestEncoder &setIsFinalManifestImpl(bool is_last);
-
-  FixedManifestEncoder &setVersionImpl(ManifestVersion version);
-
   std::size_t estimateSerializedLengthImpl(std::size_t additional_entries = 0);
 
-  FixedManifestEncoder &updateImpl();
-
-  FixedManifestEncoder &setFinalBlockNumberImpl(
-      std::uint32_t final_block_number);
-
-  static std::size_t getManifestHeaderSizeImpl();
-
-  static std::size_t getManifestEntrySizeImpl();
+  static std::size_t manifestHeaderSizeImpl(
+      interface::ProductionProtocolAlgorithms transport_type =
+          interface::ProductionProtocolAlgorithms::UNKNOWN);
+  static std::size_t manifestEntrySizeImpl();
 
  private:
-  void addSuffixHashBytes(uint32_t suffix, const uint8_t *hash,
-                          std::size_t length);
-
   Packet &packet_;
   std::size_t max_size_;
-  ManifestHeader *manifest_header_;
-  ManifestEntry *manifest_entries_;
-  std::size_t current_entry_;
   std::size_t signature_size_;
+  interface::ProductionProtocolAlgorithms transport_type_;
+  bool encoded_;
+
+  // Manifest Header
+  ManifestMeta *manifest_meta_;
+  ManifestEntryMeta *manifest_entry_meta_;
+  TransportParamsBytestream params_bytestream_;
+  TransportParamsRTC params_rtc_;
+
+  // Manifest Entries
+  std::vector<ManifestEntry> manifest_entries_;
 };
 
 class FixedManifestDecoder : public ManifestDecoder<FixedManifestDecoder> {
@@ -140,31 +209,40 @@ class FixedManifestDecoder : public ManifestDecoder<FixedManifestDecoder> {
   ~FixedManifestDecoder();
 
   void decodeImpl();
-
   FixedManifestDecoder &clearImpl();
 
-  ManifestType getManifestTypeImpl() const;
-
+  // ManifestMeta
+  ManifestVersion getVersionImpl() const;
+  ManifestType getTypeImpl() const;
+  interface::ProductionProtocolAlgorithms getTransportTypeImpl() const;
   Fixed::HashType getHashAlgorithmImpl() const;
+  bool getIsLastImpl() const;
 
-  NextSegmentCalculationStrategy getNextSegmentCalculationStrategyImpl() const;
-
-  typename Fixed::SuffixList getSuffixHashListImpl();
-
+  // ManifestEntryMeta
   core::Name getBaseNameImpl() const;
 
-  bool getIsFinalManifestImpl() const;
+  // TransportParams
+  ParamsBytestream getParamsBytestreamImpl() const;
+  ParamsRTC getParamsRTCImpl() const;
+
+  // ManifestEntry
+  typename Fixed::SuffixList getSuffixHashListImpl();
 
   std::size_t estimateSerializedLengthImpl(
       std::size_t additional_entries = 0) const;
 
-  ManifestVersion getVersionImpl() const;
-
-  uint32_t getFinalBlockNumberImpl() const;
-
  private:
   Packet &packet_;
-  ManifestHeader *manifest_header_;
+  interface::ProductionProtocolAlgorithms transport_type_;
+  bool decoded_;
+
+  // Manifest Header
+  ManifestMeta *manifest_meta_;
+  ManifestEntryMeta *manifest_entry_meta_;
+  TransportParamsBytestream *params_bytestream_;
+  TransportParamsRTC *params_rtc_;
+
+  // Manifest Entries
   ManifestEntry *manifest_entries_;
 };
 
diff --git a/libtransport/src/core/manifest_inline.h b/libtransport/src/core/manifest_inline.h
index a487ccfe3..ca48a4a79 100644
--- a/libtransport/src/core/manifest_inline.h
+++ b/libtransport/src/core/manifest_inline.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -40,25 +40,26 @@ class ManifestInline
  public:
   ManifestInline() : ManifestBase() {}
 
-  ManifestInline(const core::Name &name, std::size_t signature_size = 0)
-      : ManifestBase(name, signature_size) {}
+  ManifestInline(Packet::Format format, const core::Name &name,
+                 std::size_t signature_size = 0)
+      : ManifestBase(format, name, signature_size) {}
 
   template <typename T>
   ManifestInline(T &&base) : ManifestBase(std::forward<T &&>(base)) {}
 
+  template <typename T>
+  ManifestInline(T &base) : ManifestBase(base) {}
+
   static TRANSPORT_ALWAYS_INLINE ManifestInline *createManifest(
-      const core::Name &manifest_name, ManifestVersion version,
-      ManifestType type, HashType algorithm, bool is_last,
-      const Name &base_name, NextSegmentCalculationStrategy strategy,
-      std::size_t signature_size) {
-    auto manifest = new ManifestInline(manifest_name, signature_size);
+      Packet::Format format, const core::Name &manifest_name,
+      ManifestVersion version, ManifestType type, bool is_last,
+      const Name &base_name, HashType hash_algo, std::size_t signature_size) {
+    auto manifest = new ManifestInline(format, manifest_name, signature_size);
     manifest->setVersion(version);
-    manifest->setManifestType(type);
-    manifest->setHashAlgorithm(algorithm);
-    manifest->setFinalManifest(is_last);
+    manifest->setType(type);
+    manifest->setHashAlgorithm(hash_algo);
+    manifest->setIsLast(is_last);
     manifest->setBaseName(base_name);
-    manifest->setNextSegmentCalculationStrategy(strategy);
-
     return manifest;
   }
 
@@ -69,8 +70,6 @@ class ManifestInline
 
   ManifestInline &decodeImpl() {
     base_name_ = ManifestBase::decoder_.getBaseName();
-    next_segment_strategy_ =
-        ManifestBase::decoder_.getNextSegmentCalculationStrategy();
     suffix_hash_map_ = ManifestBase::decoder_.getSuffixHashList();
 
     return *this;
@@ -96,18 +95,6 @@ class ManifestInline
   // Call this function only after the decode function!
   const SuffixList &getSuffixList() { return suffix_hash_map_; }
 
-  ManifestInline &setNextSegmentCalculationStrategy(
-      NextSegmentCalculationStrategy strategy) {
-    next_segment_strategy_ = strategy;
-    ManifestBase::encoder_.setNextSegmentCalculationStrategy(
-        next_segment_strategy_);
-    return *this;
-  }
-
-  NextSegmentCalculationStrategy getNextSegmentCalculationStrategy() {
-    return next_segment_strategy_;
-  }
-
   // Convert several manifests into a single map from suffixes to packet hashes.
   // All manifests must have been decoded beforehand.
   static std::unordered_map<Suffix, Hash> getSuffixMap(
@@ -134,7 +121,6 @@ class ManifestInline
 
  private:
   core::Name base_name_;
-  NextSegmentCalculationStrategy next_segment_strategy_;
   SuffixList suffix_hash_map_;
 };
 
diff --git a/libtransport/src/core/memif_connector.cc b/libtransport/src/core/memif_connector.cc
new file mode 100644
index 000000000..fb38a6e23
--- /dev/null
+++ b/libtransport/src/core/memif_connector.cc
@@ -0,0 +1,497 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <core/errors.h>
+#include <core/memif_connector.h>
+#include <glog/logging.h>
+#include <hicn/transport/errors/not_implemented_exception.h>
+#include <sys/epoll.h>
+
+#include <cstdlib>
+
+/* sstrncpy */
+#include <hicn/util/sstrncpy.h>
+
+#define CANCEL_TIMER 1
+
+namespace transport {
+
+namespace core {
+
+MemifConnector::MemifConnector(PacketReceivedCallback &&receive_callback,
+                               PacketSentCallback &&packet_sent,
+                               OnCloseCallback &&close_callback,
+                               OnReconnectCallback &&on_reconnect,
+                               asio::io_service &io_service,
+                               std::string app_name)
+    : Connector(std::move(receive_callback), std::move(packet_sent),
+                std::move(close_callback), std::move(on_reconnect)),
+      event_reactor_(),
+      memif_worker_(std::bind(&MemifConnector::threadMain, this)),
+      timer_set_(false),
+      send_timer_(event_reactor_),
+      disconnect_timer_(event_reactor_),
+      io_service_(io_service),
+      work_(asio::make_work_guard(io_service_)),
+      memif_connection_({0}),
+      tx_buf_counter_(0),
+      is_reconnection_(false),
+      data_available_(false),
+      app_name_(app_name),
+      socket_filename_(""),
+      buffer_size_(kbuf_size),
+      log2_ring_size_(klog2_ring_size),
+      max_memif_bufs_(1 << klog2_ring_size) {}
+
+MemifConnector::~MemifConnector() { close(); }
+
+void MemifConnector::connect(uint32_t memif_id, long memif_mode,
+                             const std::string &socket_filename,
+                             std::size_t buffer_size,
+                             std::size_t log2_ring_size) {
+  state_ = State::CONNECTING;
+
+  memif_id_ = memif_id;
+  socket_filename_ = socket_filename;
+  buffer_size_ = buffer_size;
+  log2_ring_size_ = log2_ring_size;
+  max_memif_bufs_ = 1 << log2_ring_size;
+  createMemif(memif_id, memif_mode);
+}
+
+int MemifConnector::createMemif(uint32_t index, uint8_t is_master) {
+  int err = MEMIF_ERR_SUCCESS;
+
+  memif_socket_args_t socket_args;
+  memif_conn_args_t args;
+  memset(&socket_args, 0, sizeof(memif_socket_args_t));
+  memset(&args, 0, sizeof(memif_conn_args_t));
+
+  // Setup memif socket first
+
+  int rc = strcpy_s(socket_args.path, sizeof(socket_args.path) - 1,
+                    socket_filename_.c_str());
+  if (rc != EOK) {
+    std::string error = "Provided socket path is larger than " +
+                        std::to_string(sizeof(socket_args.path)) + " bytes.";
+    throw errors::RuntimeException(error);
+  }
+
+  rc = strcpy_s(socket_args.app_name, sizeof(socket_args.app_name) - 1,
+                app_name_.c_str());
+  if (rc != EOK) {
+    std::string error = "Provided app_name is larger than " +
+                        std::to_string(sizeof(socket_args.app_name)) +
+                        " bytes.";
+    throw errors::RuntimeException(error);
+  }
+
+  socket_args.on_control_fd_update = controlFdUpdate;
+  socket_args.alloc = nullptr;
+  socket_args.realloc = nullptr;
+  socket_args.free = nullptr;
+
+  err = memif_create_socket(&args.socket, &socket_args, this);
+
+  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
+    throw errors::RuntimeException(memif_strerror(err));
+  }
+
+  // Setup memif connection using provided memif_socket_handle_t
+  args.is_master = is_master;
+  args.log2_ring_size = log2_ring_size_;
+  args.buffer_size = buffer_size_;
+  args.num_s2m_rings = 1;
+  args.num_m2s_rings = 1;
+  strcpy_s((char *)args.interface_name, sizeof(args.interface_name), IF_NAME);
+  args.mode = memif_interface_mode_t::MEMIF_INTERFACE_MODE_IP;
+  args.interface_id = index;
+  err = memif_create(&memif_connection_.conn, &args, onConnect, onDisconnect,
+                     onInterrupt, this);
+
+  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
+    throw errors::RuntimeException(memif_strerror(err));
+  }
+
+  memif_connection_.index = (uint16_t)index;
+  memif_connection_.tx_qid = 0;
+  /* alloc memif buffers */
+  memif_connection_.rx_buf_num = 0;
+  memif_connection_.rx_bufs = static_cast<memif_buffer_t *>(
+      malloc(sizeof(memif_buffer_t) * max_memif_bufs_));
+  memif_connection_.tx_buf_num = 0;
+  memif_connection_.tx_bufs = static_cast<memif_buffer_t *>(
+      malloc(sizeof(memif_buffer_t) * max_memif_bufs_));
+
+  return 0;
+}
+
+int MemifConnector::deleteMemif() {
+  if (memif_connection_.rx_bufs) {
+    free(memif_connection_.rx_bufs);
+  }
+
+  memif_connection_.rx_bufs = nullptr;
+  memif_connection_.rx_buf_num = 0;
+
+  if (memif_connection_.tx_bufs) {
+    free(memif_connection_.tx_bufs);
+  }
+
+  memif_connection_.tx_bufs = nullptr;
+  memif_connection_.tx_buf_num = 0;
+
+  int err;
+  /* disconenct then delete memif connection */
+  err = memif_delete(&memif_connection_.conn);
+
+  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
+    LOG(ERROR) << "memif_delete: " << memif_strerror(err);
+  }
+
+  if (TRANSPORT_EXPECT_FALSE(memif_connection_.conn != nullptr)) {
+    LOG(ERROR) << "memif delete fail";
+  }
+
+  state_ = State::CLOSED;
+
+  return 0;
+}
+
+int MemifConnector::controlFdUpdate(memif_fd_event_t fde, void *private_ctx) {
+  auto self = reinterpret_cast<MemifConnector *>(private_ctx);
+  uint32_t evt = 0;
+
+  /* convert memif event definitions to epoll events */
+  auto events = fde.type;
+  auto fd = fde.fd;
+
+  if (events & MEMIF_FD_EVENT_ERROR) {
+    LOG(ERROR) << "memif fd event: Error";
+    return -1;
+  }
+
+  if (events & MEMIF_FD_EVENT_DEL) {
+    DLOG_IF(INFO, VLOG_IS_ON(4)) << "memif fd event: DEL fd " << fd;
+    return self->event_reactor_.delFileDescriptor(fd);
+  }
+
+  if (events & MEMIF_FD_EVENT_MOD) {
+    DLOG_IF(INFO, VLOG_IS_ON(4)) << "memif fd event: MOD fd " << fd;
+    return self->event_reactor_.modFileDescriptor(fd, evt);
+  }
+
+  if (events & MEMIF_FD_EVENT_READ) {
+    evt |= EPOLLIN;
+  }
+
+  if (events & MEMIF_FD_EVENT_WRITE) {
+    evt |= EPOLLOUT;
+  }
+
+  DLOG_IF(INFO, VLOG_IS_ON(4)) << "memif fd event: ADD fd " << fd;
+  return self->event_reactor_.addFileDescriptor(
+      fd, evt, [fde](const utils::Event &evt) -> int {
+        int event = 0;
+        int memif_err = 0;
+
+        if (evt.events & EPOLLIN) {
+          event |= MEMIF_FD_EVENT_READ;
+        }
+
+        if (evt.events & EPOLLOUT) {
+          event |= MEMIF_FD_EVENT_WRITE;
+        }
+
+        if (evt.events & EPOLLERR) {
+          event |= MEMIF_FD_EVENT_ERROR;
+        }
+
+        memif_err = memif_control_fd_handler(fde.private_ctx,
+                                             memif_fd_event_type_t(event));
+
+        if (TRANSPORT_EXPECT_FALSE(memif_err != MEMIF_ERR_SUCCESS)) {
+          LOG(ERROR) << "memif_control_fd_handler: "
+                     << memif_strerror(memif_err);
+        }
+
+        return 0;
+      });
+}
+
+uint16_t MemifConnector::bufferAlloc(long n, uint16_t qid,
+                                     std::error_code &ec) {
+  int err;
+  uint16_t r = 0;
+  /* set data pointer to shared memory and set buffer_len to shared mmeory
+   * buffer len */
+  err = memif_buffer_alloc(memif_connection_.conn, qid,
+                           memif_connection_.tx_bufs, n, &r, buffer_size_);
+
+  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
+    ec = make_error_code(core_error::send_buffer_allocation_failed);
+  }
+
+  memif_connection_.tx_buf_num += r;
+  return r;
+}
+
+uint16_t MemifConnector::txBurst(uint16_t qid, std::error_code &ec) {
+  int err = MEMIF_ERR_SUCCESS;
+  ec = make_error_code(core_error::success);
+  uint16_t tx = 0;
+
+  /* inform peer memif interface about data in shared memory buffers */
+  /* mark memif buffers as free */
+  err = memif_tx_burst(memif_connection_.conn, qid, memif_connection_.tx_bufs,
+                       memif_connection_.tx_buf_num, &tx);
+
+  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
+    ec = make_error_code(core_error::send_failed);
+  }
+
+  memif_connection_.tx_buf_num -= tx;
+  return tx;
+}
+
+void MemifConnector::scheduleSend(std::uint64_t delay) {
+  if (!timer_set_) {
+    timer_set_ = true;
+    send_timer_.expiresFromNow(std::chrono::microseconds(delay));
+    send_timer_.asyncWait(
+        std::bind(&MemifConnector::sendCallback, this, std::placeholders::_1));
+  }
+}
+
+void MemifConnector::sendCallback(const std::error_code &ec) {
+  timer_set_ = false;
+
+  if (TRANSPORT_EXPECT_TRUE(!ec && state_ == State::CONNECTED)) {
+    doSend();
+  }
+}
+
+/* informs user about connected status. private_ctx is used by user to identify
+   connection (multiple connections WIP) */
+int MemifConnector::onConnect(memif_conn_handle_t conn, void *private_ctx) {
+  auto self = reinterpret_cast<MemifConnector *>(private_ctx);
+  self->state_ = State::CONNECTED;
+  memif_refill_queue(conn, 0, -1, 0);
+
+  DLOG_IF(INFO, VLOG_IS_ON(3)) << "Memif " << self->app_name_ << " connected";
+
+  // We are connected. Notify higher layers.
+  self->io_service_.post([self]() {
+    self->on_reconnect_callback_(self, make_error_code(core_error::success));
+  });
+
+  self->doSend();
+
+  return 0;
+}
+
+/* informs user about disconnected status. private_ctx is used by user to
+   identify connection (multiple connections WIP) */
+int MemifConnector::onDisconnect(memif_conn_handle_t conn, void *private_ctx) {
+  MemifConnector *connector = (MemifConnector *)private_ctx;
+  DLOG_IF(INFO, VLOG_IS_ON(3))
+      << "Memif " << connector->app_name_ << " disconnected";
+  return 0;
+}
+
+void MemifConnector::threadMain() { event_reactor_.runEventLoop(200); }
+
+int MemifConnector::onInterrupt(memif_conn_handle_t conn, void *private_ctx,
+                                uint16_t qid) {
+  MemifConnector *connector = (MemifConnector *)private_ctx;
+
+  Details &c = connector->memif_connection_;
+  std::weak_ptr<MemifConnector> self = connector->shared_from_this();
+  std::vector<::utils::MemBuf::Ptr> v;
+  std::error_code ec = make_error_code(core_error::success);
+
+  int err = MEMIF_ERR_SUCCESS, ret_val;
+  uint16_t rx = 0;
+
+  do {
+    err = memif_rx_burst(conn, qid, c.rx_bufs, max_burst, &rx);
+    ret_val = err;
+
+    if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS &&
+                               err != MEMIF_ERR_NOBUF)) {
+      ec = make_error_code(core_error::receive_failed);
+      LOG(ERROR) << "memif_rx_burst: " << memif_strerror(err);
+      goto error;
+    }
+
+    c.rx_buf_num += rx;
+
+    if (TRANSPORT_EXPECT_FALSE(connector->io_service_.stopped())) {
+      LOG(ERROR) << "socket stopped: ignoring " << rx << " packets";
+      goto error;
+    }
+
+    std::size_t packet_length;
+    v.reserve(rx);
+    for (int i = 0; i < rx; i++) {
+      auto buffer = connector->getRawBuffer();
+      packet_length = (c.rx_bufs + i)->len;
+      std::memcpy(buffer.first, (c.rx_bufs + i)->data, packet_length);
+      auto packet = connector->getPacketFromBuffer(buffer.first, packet_length);
+      v.emplace_back(std::move(packet));
+    }
+
+    /* mark memif buffers and shared memory buffers as free */
+    /* free processed buffers */
+
+    err = memif_refill_queue(conn, qid, rx, 0);
+
+    if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
+      LOG(ERROR) << "memif_buffer_free: " << memif_strerror(err);
+    }
+
+    c.rx_buf_num -= rx;
+
+  } while (ret_val == MEMIF_ERR_NOBUF);
+
+  connector->io_service_.post([self, buffers = std::move(v)]() {
+    if (auto c = self.lock()) {
+      c->receive_callback_(c.get(), buffers,
+                           std::make_error_code(std::errc(0)));
+    }
+  });
+
+  return 0;
+
+error:
+  err = memif_refill_queue(c.conn, qid, rx, 0);
+
+  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
+    LOG(ERROR) << "memif_buffer_free: " << memif_strerror(err);
+  }
+  c.rx_buf_num -= rx;
+
+  connector->io_service_.post([self, ec]() {
+    if (auto c = self.lock()) {
+      c->receive_callback_(c.get(), {}, ec);
+    }
+  });
+
+  return 0;
+}
+
+void MemifConnector::close() {
+  if (state_ != State::CLOSED) {
+    disconnect_timer_.expiresFromNow(std::chrono::microseconds(50));
+    disconnect_timer_.asyncWait([this](const std::error_code &ec) {
+      deleteMemif();
+      event_reactor_.stop();
+    });
+  }
+
+  if (memif_worker_.joinable()) {
+    memif_worker_.join();
+  }
+}
+
+void MemifConnector::send(Packet &packet) { send(packet.shared_from_this()); }
+
+void MemifConnector::send(const utils::MemBuf::Ptr &buffer) {
+  {
+    utils::SpinLock::Acquire locked(write_msgs_lock_);
+    output_buffer_.push_back(buffer);
+  }
+#if CANCEL_TIMER
+  scheduleSend(50);
+#endif
+}
+
+int MemifConnector::doSend() {
+  std::size_t max = 0;
+  std::size_t size = 0;
+  std::error_code ec = make_error_code(core_error::success);
+  int ret = 0;
+  uint64_t delay = 50;  // microseconds
+
+  utils::SpinLock::Acquire locked(write_msgs_lock_);
+
+  // Check if there are pending buffers to send
+  if (memif_connection_.tx_buf_num > 0) {
+    ret = txBurst(memif_connection_.tx_qid, ec);
+    if (TRANSPORT_EXPECT_FALSE(ec.operator bool())) {
+      delay = 200;
+      goto done;
+    }
+  }
+
+  // Continue trying to send buffers in output_buffer_
+  size = output_buffer_.size();
+  max = size < max_burst ? size : max_burst;
+
+  ret = bufferAlloc(max, memif_connection_.tx_qid, ec);
+  if (TRANSPORT_EXPECT_FALSE(ec.operator bool() && ret == 0)) {
+    delay = 200;
+    goto done;
+  }
+
+  // Fill allocated buffers and remove them from output_buffer_
+  for (uint16_t i = 0; i < ret; i++) {
+    auto packet = output_buffer_.front().get();
+    const utils::MemBuf *current = packet;
+    std::size_t offset = 0;
+    uint8_t *shared_buffer =
+        reinterpret_cast<uint8_t *>(memif_connection_.tx_bufs[i].data);
+    do {
+      std::memcpy(shared_buffer + offset, current->data(), current->length());
+      offset += current->length();
+      current = current->next();
+    } while (current != packet);
+
+    memif_connection_.tx_bufs[i].len = uint32_t(offset);
+    output_buffer_.pop_front();
+  }
+
+  // Try to send them
+  ret = txBurst(memif_connection_.tx_qid, ec);
+  if (TRANSPORT_EXPECT_FALSE(ec.operator bool())) {
+    LOG(ERROR) << "Tx burst failed " << ec.message();
+    delay = 200;
+    goto done;
+  }
+
+done:
+  memif_refill_queue(memif_connection_.conn, memif_connection_.tx_qid, ret, 0);
+
+  // If there are still packets to send, schedule another send
+  if (memif_connection_.tx_buf_num > 0 || !output_buffer_.empty()) {
+    scheduleSend(delay);
+  }
+
+  // If error, signal to upper layers
+  if (ec.operator bool()) {
+    std::weak_ptr<MemifConnector> self = shared_from_this();
+    io_service_.post([self, ec]() {
+      if (auto c = self.lock()) {
+        c->sent_callback_(c.get(), ec);
+      }
+    });
+  }
+
+  return 0;
+}
+
+}  // end namespace core
+
+}  // end namespace transport
diff --git a/libtransport/src/io_modules/memif/memif_connector.h b/libtransport/src/core/memif_connector.h
index 0a189f893..d36be4616 100644
--- a/libtransport/src/io_modules/memif/memif_connector.h
+++ b/libtransport/src/core/memif_connector.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,27 +25,48 @@
 #include <utils/fd_deadline_timer.h>
 
 #include <deque>
+#include <future>
 #include <mutex>
 #include <thread>
 
+extern "C" {
+#include <libmemif.h>
+};
+
 #define _Static_assert static_assert
 
 namespace transport {
 
 namespace core {
 
-typedef struct memif_connection memif_connection_t;
-
 #define APP_NAME "libtransport"
 #define IF_NAME "vpp_connection"
 
-#define MEMIF_BUF_SIZE 2048
-#define MEMIF_LOG2_RING_SIZE 13
-#define MAX_MEMIF_BUFS (1 << MEMIF_LOG2_RING_SIZE)
-
 class MemifConnector : public Connector {
-  using memif_conn_handle_t = void *;
+  static inline std::size_t kbuf_size = 2048;
+  static inline std::size_t klog2_ring_size = 13;
+
   using PacketRing = utils::CircularFifo<utils::MemBuf::Ptr, queue_size>;
+  struct Details {
+    // index
+    uint16_t index;
+    // memif conenction handle
+    memif_conn_handle_t conn;
+    // transmit queue id
+    uint16_t tx_qid;
+    // tx buffers
+    memif_buffer_t *tx_bufs;
+    // allocated tx buffers counter
+    // number of tx buffers pointing to shared memory
+    uint16_t tx_buf_num;
+    // rx buffers
+    memif_buffer_t *rx_bufs;
+    // allocated rx buffers counter
+    // number of rx buffers pointing to shared memory
+    uint16_t rx_buf_num;
+    // interface ip address
+    uint8_t ip_addr[4];
+  };
 
  public:
   MemifConnector(PacketReceivedCallback &&receive_callback,
@@ -59,11 +80,14 @@ class MemifConnector : public Connector {
 
   void send(Packet &packet) override;
 
-  void send(const uint8_t *packet, std::size_t len) override;
+  void send(const utils::MemBuf::Ptr &buffer) override;
 
   void close() override;
 
-  void connect(uint32_t memif_id, long memif_mode);
+  void connect(uint32_t memif_id, long memif_mode,
+               const std::string &socket_filename,
+               std::size_t buffer_size = kbuf_size,
+               std::size_t log2_ring_size = klog2_ring_size);
 
   TRANSPORT_ALWAYS_INLINE uint32_t getMemifId() { return memif_id_; };
 
@@ -72,13 +96,13 @@ class MemifConnector : public Connector {
 
   int doSend();
 
-  int createMemif(uint32_t index, uint8_t mode, char *s);
+  int createMemif(uint32_t index, uint8_t is_master);
 
   uint32_t getMemifConfiguration();
 
   int deleteMemif();
 
-  static int controlFdUpdate(int fd, uint8_t events, void *private_ctx);
+  static int controlFdUpdate(memif_fd_event_t fde, void *private_ctx);
 
   static int onConnect(memif_conn_handle_t conn, void *private_ctx);
 
@@ -89,27 +113,26 @@ class MemifConnector : public Connector {
 
   void threadMain();
 
-  int txBurst(uint16_t qid);
+  uint16_t txBurst(uint16_t qid, std::error_code &ec);
+
+  uint16_t bufferAlloc(long n, uint16_t qid, std::error_code &ec);
 
-  int bufferAlloc(long n, uint16_t qid);
+  void scheduleSend(std::uint64_t delay);
 
   void sendCallback(const std::error_code &ec);
 
-  void processInputBuffer(std::uint16_t total_packets);
+  auto shared_from_this() { return utils::shared_from(this); }
 
  private:
-  static utils::EpollEventReactor main_event_reactor_;
-  static std::unique_ptr<std::thread> main_worker_;
-
   int epfd;
-  std::unique_ptr<std::thread> memif_worker_;
   utils::EpollEventReactor event_reactor_;
+  std::thread memif_worker_;
   std::atomic_bool timer_set_;
-  std::unique_ptr<utils::FdDeadlineTimer> send_timer_;
-  std::unique_ptr<utils::FdDeadlineTimer> disconnect_timer_;
+  utils::FdDeadlineTimer send_timer_;
+  utils::FdDeadlineTimer disconnect_timer_;
   asio::io_service &io_service_;
   asio::executor_work_guard<asio::io_context::executor_type> work_;
-  std::unique_ptr<memif_connection_t> memif_connection_;
+  Details memif_connection_;
   uint16_t tx_buf_counter_;
 
   PacketRing input_buffer_;
@@ -121,8 +144,9 @@ class MemifConnector : public Connector {
   uint16_t transmission_index_;
   utils::SpinLock write_msgs_lock_;
   std::string socket_filename_;
-
-  static std::once_flag flag_;
+  std::size_t buffer_size_;
+  std::size_t log2_ring_size_;
+  std::size_t max_memif_bufs_;
 };
 
 }  // end namespace core
diff --git a/libtransport/src/core/name.cc b/libtransport/src/core/name.cc
index 795c8a697..98091eea5 100644
--- a/libtransport/src/core/name.cc
+++ b/libtransport/src/core/name.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -26,30 +26,28 @@ namespace core {
 
 Name::Name() { name_ = {}; }
 
+/**
+ * XXX This function does not use the name API provided by libhicn
+ */
 Name::Name(int family, const uint8_t *ip_address, std::uint32_t suffix)
     : name_({}) {
-  name_.type = HNT_UNSPEC;
   std::size_t length;
   uint8_t *dst = NULL;
 
   if (family == AF_INET) {
-    dst = name_.ip4.prefix_as_u8;
+    dst = name_.prefix.v4.as_u8;
     length = IPV4_ADDR_LEN;
-    name_.type = HNT_CONTIGUOUS_V4;
   } else if (family == AF_INET6) {
-    dst = name_.ip6.prefix_as_u8;
+    dst = name_.prefix.v6.as_u8;
     length = IPV6_ADDR_LEN;
-    name_.type = HNT_CONTIGUOUS_V6;
   } else {
     throw errors::RuntimeException("Specified name family does not exist.");
   }
 
   std::memcpy(dst, ip_address, length);
-  *reinterpret_cast<std::uint32_t *>(dst + length) = suffix;
+  name_.suffix = suffix;
 }
-
 Name::Name(const char *name, uint32_t segment) {
-  name_.type = HNT_UNSPEC;
   if (hicn_name_create(name, segment, &name_) < 0) {
     throw errors::InvalidIpAddressException();
   }
@@ -59,7 +57,6 @@ Name::Name(const std::string &uri, uint32_t segment)
     : Name(uri.c_str(), segment) {}
 
 Name::Name(const std::string &uri) {
-  name_.type = HNT_UNSPEC;
   utils::StringTokenizer tokenizer(uri, "|");
   std::string ip_address;
   std::string seq_number;
@@ -80,9 +77,13 @@ Name::Name(const std::string &uri) {
 
 Name::Name(const Name &name) { this->name_ = name.name_; }
 
+Name::~Name() {}
+
 Name &Name::operator=(const Name &name) {
-  if (hicn_name_copy(&this->name_, &name.name_) < 0) {
-    throw errors::MalformedNameException();
+  if (this != &name) {
+    if (hicn_name_copy(&this->name_, &name.name_) < 0) {
+      throw errors::MalformedNameException();
+    }
   }
 
   return *this;
@@ -129,9 +130,13 @@ uint32_t Name::getHash32(bool consider_suffix) const {
   return hash;
 }
 
-void Name::clear() { name_.type = HNT_UNSPEC; };
+void Name::clear() { std::memset(&name_, 0, sizeof(name_)); };
 
-Name::Type Name::getType() const { return name_.type; }
+Name::Type Name::getType() const {
+  int family;
+  hicn_name_get_family(&name_, &family);
+  return family == AF_INET ? Name::Type::V4 : Name::Type::V6;
+}
 
 uint32_t Name::getSuffix() const {
   uint32_t ret = 0;
@@ -151,29 +156,6 @@ Name &Name::setSuffix(uint32_t seq_number) {
   return *this;
 }
 
-std::shared_ptr<Sockaddr> Name::getAddress() const {
-  Sockaddr *ret = nullptr;
-
-  switch (name_.type) {
-    case HNT_CONTIGUOUS_V4:
-    case HNT_IOV_V4:
-      ret = (Sockaddr *)new Sockaddr4;
-      break;
-    case HNT_CONTIGUOUS_V6:
-    case HNT_IOV_V6:
-      ret = (Sockaddr *)new Sockaddr6;
-      break;
-    default:
-      throw errors::MalformedNameException();
-  }
-
-  if (hicn_name_to_sockaddr_address((hicn_name_t *)&name_, ret) < 0) {
-    throw errors::MalformedNameException();
-  }
-
-  return std::shared_ptr<Sockaddr>(ret);
-}
-
 ip_prefix_t Name::toIpAddress() const {
   ip_prefix_t ret;
   std::memset(&ret, 0, sizeof(ret));
@@ -195,8 +177,8 @@ int Name::getAddressFamily() const {
   return ret;
 }
 
-void Name::copyToDestination(uint8_t *destination, bool include_suffix) const {
-  if (hicn_name_copy_to_destination(destination, &name_, include_suffix) < 0) {
+void Name::copyPrefixToDestination(uint8_t *destination) const {
+  if (hicn_name_copy_prefix_to_destination(destination, &name_) < 0) {
     throw errors::RuntimeException(
         "Impossibe to copy the name into the "
         "provided destination");
diff --git a/libtransport/src/core/packet.cc b/libtransport/src/core/packet.cc
index 51337201f..df27444af 100644
--- a/libtransport/src/core/packet.cc
+++ b/libtransport/src/core/packet.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -41,13 +41,6 @@ Packet::Packet(Format format, std::size_t additional_header_size)
   setFormat(format_, additional_header_size);
 }
 
-Packet::Packet(MemBuf &&buffer)
-    : utils::MemBuf(std::move(buffer)),
-      packet_start_(reinterpret_cast<hicn_header_t *>(writableData())),
-      header_offset_(0),
-      format_(getFormatFromBuffer(data(), length())),
-      payload_type_(PayloadType::UNSPECIFIED) {}
-
 Packet::Packet(CopyBufferOp, const uint8_t *buffer, std::size_t size)
     : utils::MemBuf(COPY_BUFFER, buffer, size),
       packet_start_(reinterpret_cast<hicn_header_t *>(writableData())),
@@ -74,11 +67,11 @@ Packet::Packet(CreateOp, uint8_t *buffer, std::size_t length, std::size_t size,
   setFormat(format_, additional_header_size);
 }
 
-Packet::Packet(const Packet &other)
-    : utils::MemBuf(other),
+Packet::Packet(MemBuf &&buffer)
+    : utils::MemBuf(std::move(buffer)),
       packet_start_(reinterpret_cast<hicn_header_t *>(writableData())),
-      header_offset_(other.header_offset_),
-      format_(other.format_),
+      header_offset_(0),
+      format_(getFormatFromBuffer(data(), length())),
       payload_type_(PayloadType::UNSPECIFIED) {}
 
 Packet::Packet(Packet &&other)
@@ -92,6 +85,13 @@ Packet::Packet(Packet &&other)
   other.header_offset_ = 0;
 }
 
+Packet::Packet(const Packet &other)
+    : utils::MemBuf(other),
+      packet_start_(reinterpret_cast<hicn_header_t *>(writableData())),
+      header_offset_(other.header_offset_),
+      format_(other.format_),
+      payload_type_(PayloadType::UNSPECIFIED) {}
+
 Packet::~Packet() {}
 
 Packet &Packet::operator=(const Packet &other) {
@@ -103,29 +103,19 @@ Packet &Packet::operator=(const Packet &other) {
   return *this;
 }
 
-std::size_t Packet::getHeaderSizeFromBuffer(Format format,
-                                            const uint8_t *buffer) {
-  size_t header_length;
-
-  if (hicn_packet_get_header_length(format, (hicn_header_t *)buffer,
-                                    &header_length) < 0) {
-    throw errors::MalformedPacketException();
-  }
-
-  return header_length;
+std::shared_ptr<utils::MemBuf> Packet::acquireMemBufReference() {
+  return std::static_pointer_cast<utils::MemBuf>(shared_from_this());
 }
 
-bool Packet::isInterest(const uint8_t *buffer) {
-  bool is_interest = false;
-
-  if (TRANSPORT_EXPECT_FALSE(hicn_packet_test_ece(HF_INET6_TCP,
-                                                  (const hicn_header_t *)buffer,
-                                                  &is_interest) < 0)) {
-    throw errors::RuntimeException(
-        "Impossible to retrieve ece flag from packet");
+Packet::Format Packet::getFormat() const {
+  // We check packet start because after a movement it will result in a nullptr
+  if (format_ == HF_UNSPEC && length()) {
+    if (hicn_packet_get_format(packet_start_, &format_) < 0) {
+      LOG(ERROR) << "Unexpected packet format HF_UNSPEC.";
+    }
   }
 
-  return !is_interest;
+  return format_;
 }
 
 void Packet::setFormat(Packet::Format format,
@@ -136,47 +126,43 @@ void Packet::setFormat(Packet::Format format,
   }
 
   auto header_size = getHeaderSizeFromFormat(format_);
-  assert(header_size <= tailroom());
+  DCHECK(header_size <= tailroom());
   append(header_size);
 
-  assert(additional_header_size <= tailroom());
+  DCHECK(additional_header_size <= tailroom());
   append(additional_header_size);
 
   header_offset_ = length();
 }
 
-bool Packet::isInterest() { return Packet::isInterest(data()); }
+PayloadType Packet::getPayloadType() const {
+  if (payload_type_ == PayloadType::UNSPECIFIED) {
+    hicn_payload_type_t ret;
 
-std::size_t Packet::getPayloadSizeFromBuffer(Format format,
-                                             const uint8_t *buffer) {
-  std::size_t payload_length;
-  if (TRANSPORT_EXPECT_FALSE(
-          hicn_packet_get_payload_length(format, (hicn_header_t *)buffer,
-                                         &payload_length) < 0)) {
-    throw errors::MalformedPacketException();
+    if (hicn_packet_get_payload_type(format_, packet_start_, &ret) < 0) {
+      throw errors::RuntimeException("Impossible to retrieve payload type.");
+    }
+
+    payload_type_ = (PayloadType)ret;
   }
 
-  return payload_length;
+  return payload_type_;
 }
 
-std::size_t Packet::payloadSize() const {
-  std::size_t ret = 0;
-
-  if (length()) {
-    ret = getPayloadSizeFromBuffer(format_,
-                                   reinterpret_cast<uint8_t *>(packet_start_));
+Packet &Packet::setPayloadType(PayloadType payload_type) {
+  if (hicn_packet_set_payload_type(format_, packet_start_,
+                                   hicn_payload_type_t(payload_type)) < 0) {
+    throw errors::RuntimeException("Error setting payload type of the packet.");
   }
 
-  return ret;
+  payload_type_ = payload_type;
+  return *this;
 }
 
-std::size_t Packet::headerSize() const {
-  if (header_offset_ == 0 && length()) {
-    const_cast<Packet *>(this)->header_offset_ = getHeaderSizeFromBuffer(
-        format_, reinterpret_cast<uint8_t *>(packet_start_));
-  }
-
-  return header_offset_;
+std::unique_ptr<utils::MemBuf> Packet::getPayload() const {
+  auto ret = clone();
+  ret->trimStart(headerSize());
+  return ret;
 }
 
 Packet &Packet::appendPayload(std::unique_ptr<utils::MemBuf> &&payload) {
@@ -196,12 +182,56 @@ Packet &Packet::appendPayload(const uint8_t *buffer, std::size_t length) {
   return *this;
 }
 
-std::unique_ptr<utils::MemBuf> Packet::getPayload() const {
-  auto ret = clone();
-  ret->trimStart(headerSize());
+std::size_t Packet::headerSize() const {
+  if (header_offset_ == 0 && length()) {
+    const_cast<Packet *>(this)->header_offset_ = getHeaderSizeFromBuffer(
+        format_, reinterpret_cast<uint8_t *>(packet_start_));
+  }
+
+  return header_offset_;
+}
+
+std::size_t Packet::payloadSize() const {
+  std::size_t ret = 0;
+
+  if (length()) {
+    ret = getPayloadSizeFromBuffer(format_,
+                                   reinterpret_cast<uint8_t *>(packet_start_));
+  }
+
   return ret;
 }
 
+auth::CryptoHash Packet::computeDigest(auth::CryptoHashType algorithm) const {
+  auth::CryptoHash hash;
+  hash.setType(algorithm);
+
+  // Copy IP+TCP/ICMP header before zeroing them
+  hicn_header_t header_copy;
+  hicn_packet_copy_header(format_, packet_start_, &header_copy, false);
+  const_cast<Packet *>(this)->resetForHash();
+
+  hash.computeDigest(this);
+  hicn_packet_copy_header(format_, &header_copy, packet_start_, false);
+
+  return hash;
+}
+
+void Packet::reset() {
+  clear();
+  packet_start_ = reinterpret_cast<hicn_header_t *>(writableData());
+  header_offset_ = 0;
+  format_ = HF_UNSPEC;
+  payload_type_ = PayloadType::UNSPECIFIED;
+  name_.clear();
+
+  if (isChained()) {
+    separateChain(next(), prev());
+  }
+}
+
+bool Packet::isInterest() { return Packet::isInterest(data(), format_); }
+
 Packet &Packet::updateLength(std::size_t length) {
   std::size_t total_length = length;
 
@@ -221,47 +251,6 @@ Packet &Packet::updateLength(std::size_t length) {
   return *this;
 }
 
-PayloadType Packet::getPayloadType() const {
-  if (payload_type_ == PayloadType::UNSPECIFIED) {
-    hicn_payload_type_t ret;
-    if (hicn_packet_get_payload_type(packet_start_, &ret) < 0) {
-      throw errors::RuntimeException("Impossible to retrieve payload type.");
-    }
-
-    payload_type_ = (PayloadType)ret;
-  }
-
-  return payload_type_;
-}
-
-Packet &Packet::setPayloadType(PayloadType payload_type) {
-  if (hicn_packet_set_payload_type(packet_start_,
-                                   hicn_payload_type_t(payload_type)) < 0) {
-    throw errors::RuntimeException("Error setting payload type of the packet.");
-  }
-
-  payload_type_ = payload_type;
-
-  return *this;
-}
-
-Packet::Format Packet::getFormat() const {
-  /**
-   * We check packet start because after a movement it will result in a nullptr
-   */
-  if (format_ == HF_UNSPEC && length()) {
-    if (hicn_packet_get_format(packet_start_, &format_) < 0) {
-      LOG(ERROR) << "Unexpected packet format HF_UNSPEC.";
-    }
-  }
-
-  return format_;
-}
-
-std::shared_ptr<utils::MemBuf> Packet::acquireMemBufReference() {
-  return std::static_pointer_cast<utils::MemBuf>(shared_from_this());
-}
-
 void Packet::dump() const {
   LOG(INFO) << "HEADER -- Length: " << headerSize();
   LOG(INFO) << "PAYLOAD -- Length: " << payloadSize();
@@ -274,180 +263,42 @@ void Packet::dump() const {
   } while (current != this);
 }
 
-void Packet::dump(uint8_t *buffer, std::size_t length) {
-  hicn_packet_dump(buffer, length);
-}
-
-void Packet::setSignatureSize(std::size_t size_bytes) {
-  if (!authenticationHeader()) {
-    throw errors::RuntimeException("Packet without Authentication Header.");
-  }
-
-  int ret = hicn_packet_set_signature_size(format_, packet_start_, size_bytes);
-
-  if (ret < 0) {
-    throw errors::RuntimeException("Error setting signature size.");
-  }
-}
-
-void Packet::setSignatureSizeGap(std::size_t size_bytes) {
-  if (!authenticationHeader()) {
-    throw errors::RuntimeException("Packet without Authentication Header.");
-  }
-
-  int ret = hicn_packet_set_signature_gap(format_, packet_start_,
-                                          (uint8_t)size_bytes);
-
-  if (ret < 0) {
-    throw errors::RuntimeException("Error setting signature size.");
-  }
-}
-
-uint8_t *Packet::getSignature() const {
-  if (!authenticationHeader()) {
-    throw errors::RuntimeException("Packet without Authentication Header.");
-  }
-
-  uint8_t *signature;
-  int ret = hicn_packet_get_signature(format_, packet_start_, &signature);
-
-  if (ret < 0) {
-    throw errors::RuntimeException("Error getting signature.");
-  }
-
-  return signature;
-}
-
-void Packet::setSignatureTimestamp(const uint64_t &timestamp) {
-  if (!authenticationHeader()) {
-    throw errors::RuntimeException("Packet without Authentication Header.");
-  }
-
-  int ret =
-      hicn_packet_set_signature_timestamp(format_, packet_start_, timestamp);
-
-  if (ret < 0) {
-    throw errors::RuntimeException("Error setting the signature timestamp.");
-  }
-}
-
-uint64_t Packet::getSignatureTimestamp() const {
-  if (!authenticationHeader()) {
-    throw errors::RuntimeException("Packet without Authentication Header.");
-  }
-
-  uint64_t return_value;
-  int ret = hicn_packet_get_signature_timestamp(format_, packet_start_,
-                                                &return_value);
-
-  if (ret < 0) {
-    throw errors::RuntimeException("Error getting the signature timestamp.");
-  }
-
-  return return_value;
-}
-
-void Packet::setValidationAlgorithm(
-    const auth::CryptoSuite &validation_algorithm) {
-  if (!authenticationHeader()) {
-    throw errors::RuntimeException("Packet without Authentication Header.");
-  }
-
-  int ret = hicn_packet_set_validation_algorithm(format_, packet_start_,
-                                                 uint8_t(validation_algorithm));
-
-  if (ret < 0) {
-    throw errors::RuntimeException("Error setting the validation algorithm.");
-  }
-}
-
-auth::CryptoSuite Packet::getValidationAlgorithm() const {
-  if (!authenticationHeader()) {
-    throw errors::RuntimeException("Packet without Authentication Header.");
-  }
-
-  uint8_t return_value;
-  int ret = hicn_packet_get_validation_algorithm(format_, packet_start_,
-                                                 &return_value);
-
-  if (ret < 0) {
-    throw errors::RuntimeException("Error getting the validation algorithm.");
-  }
-
-  return auth::CryptoSuite(return_value);
-}
-
-void Packet::setKeyId(const auth::KeyId &key_id) {
-  if (!authenticationHeader()) {
-    throw errors::RuntimeException("Packet without Authentication Header.");
-  }
-
-  int ret = hicn_packet_set_key_id(format_, packet_start_, key_id.first);
-
-  if (ret < 0) {
-    throw errors::RuntimeException("Error setting the key id.");
-  }
-}
-
-auth::KeyId Packet::getKeyId() const {
-  if (!authenticationHeader()) {
-    throw errors::RuntimeException("Packet without Authentication Header.");
-  }
+void Packet::setChecksum() {
+  if (_is_tcp(format_)) {
+    uint16_t partial_csum =
+        csum(data() + HICN_V6_TCP_HDRLEN, length() - HICN_V6_TCP_HDRLEN, 0);
 
-  auth::KeyId return_value;
-  int ret = hicn_packet_get_key_id(format_, packet_start_, &return_value.first,
-                                   &return_value.second);
+    for (utils::MemBuf *current = next(); current != this;
+         current = current->next()) {
+      partial_csum = csum(current->data(), current->length(), ~partial_csum);
+    }
 
-  if (ret < 0) {
-    throw errors::RuntimeException("Error getting the validation algorithm.");
+    if (hicn_packet_compute_header_checksum(format_, packet_start_,
+                                            partial_csum) < 0) {
+      throw errors::MalformedPacketException();
+    }
   }
-
-  return return_value;
-}
-
-auth::CryptoHash Packet::computeDigest(auth::CryptoHashType algorithm) const {
-  auth::CryptoHash hash;
-  hash.setType(algorithm);
-
-  // Copy IP+TCP/ICMP header before zeroing them
-  hicn_header_t header_copy;
-
-  hicn_packet_copy_header(format_, packet_start_, &header_copy, false);
-
-  const_cast<Packet *>(this)->resetForHash();
-
-  hash.computeDigest(this);
-  hicn_packet_copy_header(format_, &header_copy, packet_start_, false);
-
-  return hash;
 }
 
 bool Packet::checkIntegrity() const {
-  uint16_t partial_csum =
-      csum(data() + HICN_V6_TCP_HDRLEN, length() - HICN_V6_TCP_HDRLEN, 0);
+  if (_is_tcp(format_)) {
+    uint16_t partial_csum =
+        csum(data() + HICN_V6_TCP_HDRLEN, length() - HICN_V6_TCP_HDRLEN, 0);
 
-  for (const utils::MemBuf *current = next(); current != this;
-       current = current->next()) {
-    partial_csum = csum(current->data(), current->length(), ~partial_csum);
-  }
+    for (const utils::MemBuf *current = next(); current != this;
+         current = current->next()) {
+      partial_csum = csum(current->data(), current->length(), ~partial_csum);
+    }
 
-  if (hicn_packet_check_integrity_no_payload(format_, packet_start_,
-                                             partial_csum) < 0) {
-    return false;
+    if (hicn_packet_check_integrity_no_payload(format_, packet_start_,
+                                               partial_csum) < 0) {
+      return false;
+    }
   }
 
   return true;
 }
 
-void Packet::prependPayload(const uint8_t **buffer, std::size_t *size) {
-  auto last = prev();
-  auto to_copy = std::min(*size, last->tailroom());
-  std::memcpy(last->writableTail(), *buffer, to_copy);
-  last->append(to_copy);
-  *size -= to_copy;
-  *buffer += to_copy;
-}
-
 Packet &Packet::setSyn() {
   if (hicn_packet_set_syn(format_, packet_start_) < 0) {
     throw errors::RuntimeException("Error setting syn bit in the packet.");
@@ -553,29 +404,23 @@ Packet &Packet::resetFlags() {
   resetAck();
   resetRst();
   resetFin();
-
   return *this;
 }
 
 std::string Packet::printFlags() const {
   std::string flags;
-
   if (testSyn()) {
     flags += "S";
   }
-
   if (testAck()) {
     flags += "A";
   }
-
   if (testRst()) {
     flags += "R";
   }
-
   if (testFin()) {
     flags += "F";
   }
-
   return flags;
 }
 
@@ -634,6 +479,245 @@ uint8_t Packet::getTTL() const {
   return hops;
 }
 
+bool Packet::hasAH() const { return _is_ah(format_); }
+
+std::vector<uint8_t> Packet::getSignature() const {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
+  }
+
+  uint8_t *signature;
+  int ret = hicn_packet_get_signature(format_, packet_start_, &signature);
+
+  if (ret < 0) {
+    throw errors::RuntimeException("Error getting signature.");
+  }
+
+  return std::vector<uint8_t>(signature, signature + getSignatureFieldSize());
+}
+
+std::size_t Packet::getSignatureFieldSize() const {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
+  }
+
+  size_t field_size;
+  int ret = hicn_packet_get_signature_size(format_, packet_start_, &field_size);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error reading signature field size");
+  }
+  return field_size;
+}
+
+std::size_t Packet::getSignatureSize() const {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
+  }
+
+  size_t padding;
+  int ret = hicn_packet_get_signature_padding(format_, packet_start_, &padding);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error reading signature padding");
+  }
+
+  size_t size = getSignatureFieldSize() - padding;
+  if (size < 0) {
+    throw errors::RuntimeException("Error reading signature size");
+  }
+
+  return size;
+}
+
+uint64_t Packet::getSignatureTimestamp() const {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
+  }
+
+  uint64_t timestamp;
+  int ret =
+      hicn_packet_get_signature_timestamp(format_, packet_start_, &timestamp);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error getting the signature timestamp.");
+  }
+  return timestamp;
+}
+
+auth::KeyId Packet::getKeyId() const {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
+  }
+
+  auth::KeyId key_id;
+  int ret = hicn_packet_get_key_id(format_, packet_start_, &key_id.first,
+                                   &key_id.second);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error getting the validation algorithm.");
+  }
+  return key_id;
+}
+
+auth::CryptoSuite Packet::getValidationAlgorithm() const {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
+  }
+
+  uint8_t return_value;
+  int ret = hicn_packet_get_validation_algorithm(format_, packet_start_,
+                                                 &return_value);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error getting the validation algorithm.");
+  }
+  return auth::CryptoSuite(return_value);
+}
+
+void Packet::setSignature(const std::vector<uint8_t> &signature) {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
+  }
+
+  uint8_t *signature_field;
+  int ret = hicn_packet_get_signature(format_, packet_start_, &signature_field);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error getting signature.");
+  }
+  memcpy(signature_field, signature.data(), signature.size());
+}
+
+void Packet::setSignatureFieldSize(std::size_t size) {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
+  }
+
+  int ret = hicn_packet_set_signature_size(format_, packet_start_, size);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error setting signature size.");
+  }
+}
+
+void Packet::setSignatureSize(std::size_t size) {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
+  }
+
+  size_t padding = getSignatureFieldSize() - size;
+  if (padding < 0) {
+    throw errors::RuntimeException("Error setting signature padding.");
+  }
+
+  int ret = hicn_packet_set_signature_padding(format_, packet_start_, padding);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error setting signature padding.");
+  }
+}
+
+void Packet::setSignatureTimestamp(const uint64_t &timestamp) {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
+  }
+
+  int ret =
+      hicn_packet_set_signature_timestamp(format_, packet_start_, timestamp);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error setting the signature timestamp.");
+  }
+}
+
+void Packet::setKeyId(const auth::KeyId &key_id) {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
+  }
+
+  int ret = hicn_packet_set_key_id(format_, packet_start_, key_id.first);
+  if (ret < 0) {
+    throw errors::RuntimeException("Error setting the key id.");
+  }
+}
+
+void Packet::setValidationAlgorithm(
+    const auth::CryptoSuite &validation_algorithm) {
+  if (!hasAH()) {
+    throw errors::RuntimeException("Packet without Authentication Header.");
+  }
+
+  int ret = hicn_packet_set_validation_algorithm(format_, packet_start_,
+                                                 uint8_t(validation_algorithm));
+  if (ret < 0) {
+    throw errors::RuntimeException("Error setting the validation algorithm.");
+  }
+}
+
+Packet::Format Packet::toAHFormat(const Format &format) {
+  return hicn_get_ah_format(format);
+}
+
+Packet::Format Packet::getFormatFromBuffer(const uint8_t *buffer,
+                                           std::size_t /* length */) {
+  Packet::Format format = HF_UNSPEC;
+  hicn_packet_get_format((const hicn_header_t *)buffer, &format);
+  return format;
+}
+
+std::size_t Packet::getHeaderSizeFromFormat(Format format,
+                                            std::size_t signature_size) {
+  std::size_t header_length;
+  hicn_packet_get_header_length_from_format(format, &header_length);
+  int is_ah = _is_ah(format);
+  return is_ah * (header_length + signature_size) + (!is_ah) * header_length;
+}
+
+std::size_t Packet::getHeaderSizeFromBuffer(Format format,
+                                            const uint8_t *buffer) {
+  size_t header_length;
+
+  if (hicn_packet_get_header_length(format, (hicn_header_t *)buffer,
+                                    &header_length) < 0) {
+    throw errors::MalformedPacketException();
+  }
+
+  return header_length;
+}
+
+std::size_t Packet::getPayloadSizeFromBuffer(Format format,
+                                             const uint8_t *buffer) {
+  std::size_t payload_length;
+  if (TRANSPORT_EXPECT_FALSE(
+          hicn_packet_get_payload_length(format, (hicn_header_t *)buffer,
+                                         &payload_length) < 0)) {
+    throw errors::MalformedPacketException();
+  }
+
+  return payload_length;
+}
+
+bool Packet::isInterest(const uint8_t *buffer, Format format) {
+  int is_interest = 0;
+
+  if (TRANSPORT_EXPECT_FALSE(format == Format::HF_UNSPEC)) {
+    format = getFormatFromBuffer(buffer, /* Unused length */ 128);
+  }
+
+  if (TRANSPORT_EXPECT_FALSE(
+          hicn_packet_is_interest(format, (const hicn_header_t *)buffer,
+                                  &is_interest) < 0)) {
+    throw errors::RuntimeException("Error reading ece flag from packet");
+  }
+
+  return is_interest;
+}
+
+void Packet::dump(uint8_t *buffer, std::size_t length) {
+  hicn_packet_dump(buffer, length);
+}
+
+void Packet::prependPayload(const uint8_t **buffer, std::size_t *size) {
+  auto last = prev();
+  auto to_copy = std::min(*size, last->tailroom());
+  std::memcpy(last->writableTail(), *buffer, to_copy);
+  last->append(to_copy);
+  *size -= to_copy;
+  *buffer += to_copy;
+}
+
 }  // end namespace core
 
 }  // end namespace transport
diff --git a/libtransport/src/core/pending_interest.cc b/libtransport/src/core/pending_interest.cc
deleted file mode 100644
index fbe98cab5..000000000
--- a/libtransport/src/core/pending_interest.cc
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * 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 <core/pending_interest.h>
-
-namespace transport {
-
-namespace core {
-
-PendingInterest::PendingInterest()
-    : interest_(nullptr, nullptr),
-      timer_(),
-      on_content_object_callback_(),
-      on_interest_timeout_callback_() {}
-
-PendingInterest::PendingInterest(Interest::Ptr &&interest,
-                                 std::unique_ptr<asio::steady_timer> &&timer)
-    : interest_(std::move(interest)),
-      timer_(std::move(timer)),
-      on_content_object_callback_(),
-      on_interest_timeout_callback_() {}
-
-PendingInterest::PendingInterest(
-    Interest::Ptr &&interest, OnContentObjectCallback &&on_content_object,
-    OnInterestTimeoutCallback &&on_interest_timeout,
-    std::unique_ptr<asio::steady_timer> &&timer)
-    : interest_(std::move(interest)),
-      timer_(std::move(timer)),
-      on_content_object_callback_(std::move(on_content_object)),
-      on_interest_timeout_callback_(std::move(on_interest_timeout)) {}
-
-PendingInterest::~PendingInterest() {}
-
-void PendingInterest::cancelTimer() { timer_->cancel(); }
-
-void PendingInterest::setInterest(Interest::Ptr &&interest) {
-  interest_ = std::move(interest);
-}
-
-Interest::Ptr &&PendingInterest::getInterest() { return std::move(interest_); }
-
-const OnContentObjectCallback &PendingInterest::getOnDataCallback() const {
-  return on_content_object_callback_;
-}
-
-void PendingInterest::setOnContentObjectCallback(
-    OnContentObjectCallback &&on_content_object) {
-  PendingInterest::on_content_object_callback_ = on_content_object;
-}
-
-const OnInterestTimeoutCallback &PendingInterest::getOnTimeoutCallback() const {
-  return on_interest_timeout_callback_;
-}
-
-void PendingInterest::setOnTimeoutCallback(
-    OnInterestTimeoutCallback &&on_interest_timeout) {
-  PendingInterest::on_interest_timeout_callback_ = on_interest_timeout;
-}
-
-}  // end namespace core
-
-}  // end namespace transport
diff --git a/libtransport/src/core/pending_interest.h b/libtransport/src/core/pending_interest.h
index 99a8bd327..f8a4ba10e 100644
--- a/libtransport/src/core/pending_interest.h
+++ b/libtransport/src/core/pending_interest.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -48,19 +48,17 @@ class PendingInterest {
   //       on_content_object_callback_(),
   //       on_interest_timeout_callback_() {}
 
-  PendingInterest(Interest::Ptr &&interest,
-                  std::unique_ptr<asio::steady_timer> &&timer)
-      : interest_(std::move(interest)),
-        timer_(std::move(timer)),
+  PendingInterest(asio::io_service &io_service, const Interest::Ptr &interest)
+      : interest_(interest),
+        timer_(io_service),
         on_content_object_callback_(),
         on_interest_timeout_callback_() {}
 
-  PendingInterest(Interest::Ptr &&interest,
+  PendingInterest(asio::io_service &io_service, const Interest::Ptr &interest,
                   OnContentObjectCallback &&on_content_object,
-                  OnInterestTimeoutCallback &&on_interest_timeout,
-                  std::unique_ptr<asio::steady_timer> &&timer)
-      : interest_(std::move(interest)),
-        timer_(std::move(timer)),
+                  OnInterestTimeoutCallback &&on_interest_timeout)
+      : interest_(interest),
+        timer_(io_service),
         on_content_object_callback_(std::move(on_content_object)),
         on_interest_timeout_callback_(std::move(on_interest_timeout)) {}
 
@@ -68,12 +66,12 @@ class PendingInterest {
 
   template <typename Handler>
   TRANSPORT_ALWAYS_INLINE void startCountdown(Handler &&cb) {
-    timer_->expires_from_now(
+    timer_.expires_from_now(
         std::chrono::milliseconds(interest_->getLifetime()));
-    timer_->async_wait(std::forward<Handler &&>(cb));
+    timer_.async_wait(std::forward<Handler &&>(cb));
   }
 
-  TRANSPORT_ALWAYS_INLINE void cancelTimer() { timer_->cancel(); }
+  TRANSPORT_ALWAYS_INLINE void cancelTimer() { timer_.cancel(); }
 
   TRANSPORT_ALWAYS_INLINE Interest::Ptr &&getInterest() {
     return std::move(interest_);
@@ -105,7 +103,7 @@ class PendingInterest {
 
  private:
   Interest::Ptr interest_;
-  std::unique_ptr<asio::steady_timer> timer_;
+  asio::steady_timer timer_;
   OnContentObjectCallback on_content_object_callback_;
   OnInterestTimeoutCallback on_interest_timeout_callback_;
 };
diff --git a/libtransport/src/core/portal.cc b/libtransport/src/core/portal.cc
index c4c0cf8ba..d8e8d78ea 100644
--- a/libtransport/src/core/portal.cc
+++ b/libtransport/src/core/portal.cc
@@ -30,11 +30,11 @@ namespace core {
 #ifdef ANDROID
 static const constexpr char default_module[] = "";
 #elif defined(MACINTOSH)
-static const constexpr char default_module[] = "hicnlight_module.dylib";
+static const constexpr char default_module[] = "hicnlightng_module.dylib";
 #elif defined(LINUX)
-static const constexpr char default_module[] = "hicnlight_module.so";
+static const constexpr char default_module[] = "hicnlightng_module.so";
 #elif defined(WINDOWS)
-static const constexpr char default_module[] = "hicnlight_module.lib";
+static const constexpr char default_module[] = "hicnlightng_module.lib";
 #endif
 
 IoModuleConfiguration Portal::conf_;
@@ -57,7 +57,7 @@ std::string Portal::defaultIoModule() {
 
 void Portal::getModuleConfiguration(ConfigurationObject& object,
                                     std::error_code& ec) {
-  assert(object.getKey() == io_module_section);
+  DCHECK(object.getKey() == io_module_section);
 
   auto conf = dynamic_cast<const IoModuleConfiguration&>(object);
   conf = conf_;
@@ -103,7 +103,7 @@ std::string getIoModulePath(const std::string& name,
 
 void Portal::setModuleConfiguration(const ConfigurationObject& object,
                                     std::error_code& ec) {
-  assert(object.getKey() == io_module_section);
+  DCHECK(object.getKey() == io_module_section);
 
   const IoModuleConfiguration& conf =
       dynamic_cast<const IoModuleConfiguration&>(object);
diff --git a/libtransport/src/core/portal.h b/libtransport/src/core/portal.h
index f6a9ce85b..aae4c573e 100644
--- a/libtransport/src/core/portal.h
+++ b/libtransport/src/core/portal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -15,6 +15,7 @@
 
 #pragma once
 
+#include <core/global_workers.h>
 #include <core/pending_interest.h>
 #include <glog/logging.h>
 #include <hicn/transport/config.h>
@@ -28,6 +29,7 @@
 #include <hicn/transport/interfaces/global_conf_interface.h>
 #include <hicn/transport/interfaces/portal.h>
 #include <hicn/transport/portability/portability.h>
+#include <hicn/transport/utils/event_thread.h>
 #include <hicn/transport/utils/fixed_block_allocator.h>
 
 #include <future>
@@ -54,11 +56,11 @@ class HandlerMemory {
   HandlerMemory(const HandlerMemory &) = delete;
   HandlerMemory &operator=(const HandlerMemory &) = delete;
 
-  TRANSPORT_ALWAYS_INLINE void *allocate(std::size_t size) {
+  void *allocate(std::size_t size) {
     return utils::FixedBlockAllocator<128, 8192>::getInstance().allocateBlock();
   }
 
-  TRANSPORT_ALWAYS_INLINE void deallocate(void *pointer) {
+  void deallocate(void *pointer) {
     utils::FixedBlockAllocator<128, 8192>::getInstance().deallocateBlock(
         pointer);
   }
@@ -69,13 +71,9 @@ class HandlerMemory {
   HandlerMemory(const HandlerMemory &) = delete;
   HandlerMemory &operator=(const HandlerMemory &) = delete;
 
-  TRANSPORT_ALWAYS_INLINE void *allocate(std::size_t size) {
-    return ::operator new(size);
-  }
+  void *allocate(std::size_t size) { return ::operator new(size); }
 
-  TRANSPORT_ALWAYS_INLINE void deallocate(void *pointer) {
-    ::operator delete(pointer);
-  }
+  void deallocate(void *pointer) { ::operator delete(pointer); }
 #endif
 };
 
@@ -92,21 +90,19 @@ class HandlerAllocator {
   HandlerAllocator(const HandlerAllocator<U> &other) noexcept
       : memory_(other.memory_) {}
 
-  TRANSPORT_ALWAYS_INLINE bool operator==(
-      const HandlerAllocator &other) const noexcept {
+  bool operator==(const HandlerAllocator &other) const noexcept {
     return &memory_ == &other.memory_;
   }
 
-  TRANSPORT_ALWAYS_INLINE bool operator!=(
-      const HandlerAllocator &other) const noexcept {
+  bool operator!=(const HandlerAllocator &other) const noexcept {
     return &memory_ != &other.memory_;
   }
 
-  TRANSPORT_ALWAYS_INLINE T *allocate(std::size_t n) const {
+  T *allocate(std::size_t n) const {
     return static_cast<T *>(memory_.allocate(sizeof(T) * n));
   }
 
-  TRANSPORT_ALWAYS_INLINE void deallocate(T *p, std::size_t /*n*/) const {
+  void deallocate(T *p, std::size_t /*n*/) const {
     return memory_.deallocate(p);
   }
 
@@ -135,7 +131,7 @@ class CustomAllocatorHandler {
   }
 
   template <typename... Args>
-  void operator()(Args &&... args) {
+  void operator()(Args &&...args) {
     handler_(std::forward<Args>(args)...);
   }
 
@@ -151,49 +147,16 @@ inline CustomAllocatorHandler<Handler> makeCustomAllocatorHandler(
   return CustomAllocatorHandler<Handler>(m, h);
 }
 
-class Pool {
- public:
-  Pool(asio::io_service &io_service) : io_service_(io_service) {
-    increasePendingInterestPool();
-  }
-
-  TRANSPORT_ALWAYS_INLINE void increasePendingInterestPool() {
-    // Create pool of pending interests to reuse
-    for (uint32_t i = 0; i < pit_size; i++) {
-      pending_interests_pool_.add(new PendingInterest(
-          Interest::Ptr(nullptr),
-          std::make_unique<asio::steady_timer>(io_service_)));
-    }
-  }
-  PendingInterest::Ptr getPendingInterest() {
-    auto res = pending_interests_pool_.get();
-    while (TRANSPORT_EXPECT_FALSE(!res.first)) {
-      increasePendingInterestPool();
-      res = pending_interests_pool_.get();
-    }
-
-    return std::move(res.second);
-  }
-
- private:
-  utils::ObjectPool<PendingInterest> pending_interests_pool_;
-  asio::io_service &io_service_;
-};
-
 }  // namespace portal_details
 
 class PortalConfiguration;
 
-using PendingInterestHashTable =
-    std::unordered_map<uint32_t, PendingInterest::Ptr>;
-
-using interface::BindConfig;
+using PendingInterestHashTable = std::unordered_map<uint32_t, PendingInterest>;
 
 /**
  * Portal is a opaque class which is used for sending/receiving interest/data
- * packets over multiple kind of connector. The connector itself is defined by
- * the template ForwarderInt, which is resolved at compile time. It is then not
- * possible to decide at runtime what the connector will be.
+ * packets over multiple kind of io_modules. The io_module itself is an external
+ * module loaded at runtime.
  *
  * The tasks performed by portal are the following:
  * - Sending/Receiving Interest packets
@@ -210,22 +173,16 @@ using interface::BindConfig;
  * users of this class.
  */
 
-class Portal {
- public:
-  using ConsumerCallback = interface::Portal::ConsumerCallback;
-  using ProducerCallback = interface::Portal::ProducerCallback;
-
-  friend class PortalConfiguration;
-
-  Portal() : Portal(internal_io_service_) {}
+class Portal : public ::utils::NonCopyable,
+               public std::enable_shared_from_this<Portal> {
+ private:
+  Portal() : Portal(GlobalWorkers::getInstance().getWorker()) {}
 
-  Portal(asio::io_service &io_service)
+  Portal(::utils::EventThread &worker)
       : io_module_(nullptr, [](IoModule *module) { IoModule::unload(module); }),
-        io_service_(io_service),
-        packet_pool_(io_service),
+        worker_(worker),
         app_name_("libtransport_application"),
-        consumer_callback_(nullptr),
-        producer_callback_(nullptr),
+        transport_callback_(nullptr),
         is_consumer_(false) {
     /**
      * This workaroung allows to initialize memory for packet buffers *before*
@@ -235,58 +192,105 @@ class Portal {
      */
     PacketManager<>::getInstance();
   }
+
+ public:
+  using TransportCallback = interface::Portal::TransportCallback;
+  friend class PortalConfiguration;
+
+  static std::shared_ptr<Portal> createShared() {
+    return std::shared_ptr<Portal>(new Portal());
+  }
+
+  static std::shared_ptr<Portal> createShared(::utils::EventThread &worker) {
+    return std::shared_ptr<Portal>(new Portal(worker));
+  }
+
+  bool isConnected() const { return io_module_.get() != nullptr; }
+
   /**
-   * Set the consumer callback.
+   * Set the transport callback. Must be called from the same worker thread.
    *
-   * @param consumer_callback - The pointer to the ConsumerCallback object.
+   * @param consumer_callback - The pointer to the TransportCallback object.
    */
-  void setConsumerCallback(ConsumerCallback *consumer_callback) {
-    consumer_callback_ = consumer_callback;
+  void registerTransportCallback(TransportCallback *transport_callback) {
+    DCHECK(std::this_thread::get_id() == worker_.getThreadId());
+    transport_callback_ = transport_callback;
   }
 
   /**
-   * Set the producer callback.
-   *
-   * @param producer_callback - The pointer to the ProducerCallback object.
+   * Unset the consumer callback. Must be called from the same worker thread.
    */
-  void setProducerCallback(ProducerCallback *producer_callback) {
-    producer_callback_ = producer_callback;
+  void unregisterTransportCallback() {
+    DCHECK(std::this_thread::get_id() == worker_.getThreadId());
+    transport_callback_ = nullptr;
   }
 
   /**
-   * Specify the output interface to use. This method will be useful in a future
-   * scenario where the library will be able to forward packets without
+   * Specify the output interface to use. This method will be useful in a
+   * future scenario where the library will be able to forward packets without
    * connecting to a local forwarder. Now it is not used.
    *
    * @param output_interface - The output interface to use for
    * forwarding/receiving packets.
    */
-  TRANSPORT_ALWAYS_INLINE void setOutputInterface(
-      const std::string &output_interface) {
-    io_module_->setOutputInterface(output_interface);
+  void setOutputInterface(const std::string &output_interface) {
+    if (io_module_) {
+      io_module_->setOutputInterface(output_interface);
+    }
   }
 
   /**
    * Connect the transport to the local hicn forwarder.
    *
-   * @param is_consumer - Boolean specifying if the application on top of portal
-   * is a consumer or a producer.
+   * @param is_consumer - Boolean specifying if the application on top of
+   * portal is a consumer or a producer.
    */
-  TRANSPORT_ALWAYS_INLINE void connect(bool is_consumer = true) {
-    if (!io_module_) {
-      pending_interest_hash_table_.reserve(portal_details::pit_size);
-      io_module_.reset(IoModule::load(io_module_path_.c_str()));
-
-      CHECK(io_module_);
-
-      io_module_->init(std::bind(&Portal::processIncomingMessages, this,
-                                 std::placeholders::_1, std::placeholders::_2,
-                                 std::placeholders::_3),
-                       std::bind(&Portal::setLocalRoutes, this), io_service_,
-                       app_name_);
-      io_module_->connect(is_consumer);
-      is_consumer_ = is_consumer;
+  void connect(bool is_consumer = true) {
+    if (isConnected()) {
+      return;
     }
+
+    worker_.addAndWaitForExecution([this, is_consumer]() {
+      if (!io_module_) {
+        pending_interest_hash_table_.reserve(portal_details::pit_size);
+        io_module_.reset(IoModule::load(io_module_path_.c_str()));
+
+        CHECK(io_module_);
+
+        std::weak_ptr<Portal> self(shared_from_this());
+
+        io_module_->init(
+            [self](Connector *c, const std::vector<utils::MemBuf::Ptr> &buffers,
+                   const std::error_code &ec) {
+              if (auto ptr = self.lock()) {
+                ptr->processIncomingMessages(c, buffers, ec);
+              }
+            },
+            [self](Connector *c, const std::error_code &ec) {
+              if (!ec) {
+                return;
+              }
+              auto ptr = self.lock();
+              if (ptr && ptr->transport_callback_) {
+                ptr->transport_callback_->onError(ec);
+              }
+            },
+            [self](Connector *c, const std::error_code &ec) {
+              auto ptr = self.lock();
+              if (ptr) {
+                if (ec && ptr->transport_callback_) {
+                  ptr->transport_callback_->onError(ec);
+                  return;
+                }
+                ptr->setLocalRoutes();
+              }
+            },
+            worker_.getIoService(), app_name_);
+
+        io_module_->connect(is_consumer);
+        is_consumer_ = is_consumer;
+      }
+    });
   }
 
   /**
@@ -295,18 +299,13 @@ class Portal {
   ~Portal() { killConnection(); }
 
   /**
-   * Compute name hash
-   */
-  TRANSPORT_ALWAYS_INLINE uint32_t getHash(const Name &name) {
-    return name.getHash32(false) + name.getSuffix();
-  }
-
-  /**
    * Check if there is already a pending interest for a given name.
    *
    * @param name - The interest name.
    */
-  TRANSPORT_ALWAYS_INLINE bool interestIsPending(const Name &name) {
+  bool interestIsPending(const Name &name) {
+    DCHECK(std::this_thread::get_id() == worker_.getThreadId());
+
     auto it = pending_interest_hash_table_.find(getHash(name));
     if (it != pending_interest_hash_table_.end()) {
       return true;
@@ -321,19 +320,21 @@ class Portal {
    * @param interest - The pointer to the interest. The ownership of the
    * interest is transferred by the caller to portal.
    *
-   * @param on_content_object_callback - If the caller wishes to use a different
-   * callback to be called for this interest, it can set this parameter.
-   * Otherwise ConsumerCallback::onContentObject will be used.
+   * @param on_content_object_callback - If the caller wishes to use a
+   * different callback to be called for this interest, it can set this
+   * parameter. Otherwise ConsumerCallback::onContentObject will be used.
    *
    * @param on_interest_timeout_callback - If the caller wishes to use a
    * different callback to be called for this interest, it can set this
    * parameter. Otherwise ConsumerCallback::onTimeout will be used.
    */
-  TRANSPORT_ALWAYS_INLINE void sendInterest(
+  void sendInterest(
       Interest::Ptr &&interest,
       OnContentObjectCallback &&on_content_object_callback = UNSET_CALLBACK,
       OnInterestTimeoutCallback &&on_interest_timeout_callback =
           UNSET_CALLBACK) {
+    DCHECK(std::this_thread::get_id() == worker_.getThreadId());
+
     // Send it
     interest->encodeSuffixes();
     io_module_->send(*interest);
@@ -346,35 +347,42 @@ class Portal {
     uint32_t counter = 0;
     // Set timers
     do {
-      auto pending_interest = packet_pool_.getPendingInterest();
-      pending_interest->setInterest(interest);
+      if (suffix) {
+        hash = initial_hash + *suffix;
+        seq = *suffix;
+        suffix++;
+      }
+
+      auto it = pending_interest_hash_table_.find(hash);
+      PendingInterest *pending_interest = nullptr;
+      if (it != pending_interest_hash_table_.end()) {
+        it->second.cancelTimer();
+        pending_interest = &it->second;
+        pending_interest->setInterest(interest);
+      } else {
+        auto pend_int = pending_interest_hash_table_.try_emplace(
+            hash, worker_.getIoService(), interest);
+        pending_interest = &pend_int.first->second;
+      }
+
       pending_interest->setOnContentObjectCallback(
           std::move(on_content_object_callback));
       pending_interest->setOnTimeoutCallback(
           std::move(on_interest_timeout_callback));
 
+      auto self = weak_from_this();
       pending_interest->startCountdown(
           portal_details::makeCustomAllocatorHandler(
               async_callback_memory_,
-              std::bind(&Portal::timerHandler, this, std::placeholders::_1,
-                        hash, seq)));
+              [self, hash, seq](const std::error_code &ec) {
+                if (TRANSPORT_EXPECT_FALSE(ec.operator bool())) {
+                  return;
+                }
 
-      auto it = pending_interest_hash_table_.find(hash);
-      if (it != pending_interest_hash_table_.end()) {
-        it->second->cancelTimer();
-
-        // Get reference to interest packet in order to have it destroyed.
-        auto _int = it->second->getInterest();
-        it->second = std::move(pending_interest);
-      } else {
-        pending_interest_hash_table_[hash] = std::move(pending_interest);
-      }
-
-      if (suffix) {
-        hash = initial_hash + *suffix;
-        seq = *suffix;
-        suffix++;
-      }
+                if (auto ptr = self.lock()) {
+                  ptr->timerHandler(hash, seq);
+                }
+              }));
 
     } while (counter++ < n_suffixes);
   }
@@ -385,214 +393,174 @@ class Portal {
    * @param ec - Error code which says whether the timer expired or has been
    * canceled upon data packet reception.
    *
-   * @param hash - The index of the interest in the pending interest hash table.
+   * @param hash - The index of the interest in the pending interest hash
+   * table.
    */
-  TRANSPORT_ALWAYS_INLINE void timerHandler(const std::error_code &ec,
-                                            uint32_t hash, uint32_t seq) {
-    bool is_stopped = io_service_.stopped();
-    if (TRANSPORT_EXPECT_FALSE(is_stopped)) {
-      return;
-    }
+  void timerHandler(uint32_t hash, uint32_t seq) {
+    PendingInterestHashTable::iterator it =
+        pending_interest_hash_table_.find(hash);
+    if (it != pending_interest_hash_table_.end()) {
+      PendingInterest &pend_interest = it->second;
+      auto _int = pend_interest.getInterest();
+      auto callback = pend_interest.getOnTimeoutCallback();
+      pending_interest_hash_table_.erase(it);
+      Name &name = const_cast<Name &>(_int->getName());
+      name.setSuffix(seq);
 
-    if (TRANSPORT_EXPECT_TRUE(!ec)) {
-      PendingInterestHashTable::iterator it =
-          pending_interest_hash_table_.find(hash);
-      if (it != pending_interest_hash_table_.end()) {
-        PendingInterest::Ptr ptr = std::move(it->second);
-        pending_interest_hash_table_.erase(it);
-        auto _int = ptr->getInterest();
-        Name &name = const_cast<Name &>(_int->getName());
-        name.setSuffix(seq);
-
-        if (ptr->getOnTimeoutCallback() != UNSET_CALLBACK) {
-          ptr->on_interest_timeout_callback_(_int, name);
-        } else if (consumer_callback_) {
-          consumer_callback_->onTimeout(_int, name);
-        }
+      if (callback != UNSET_CALLBACK) {
+        callback(_int, name);
+      } else if (transport_callback_) {
+        transport_callback_->onTimeout(_int, name);
       }
     }
   }
 
   /**
-   * Register a producer name to the local forwarder and optionally set the
-   * content store size in a per-face manner.
-   *
-   * @param config - The configuration for the local forwarder binding.
-   */
-  TRANSPORT_ALWAYS_INLINE void bind(const BindConfig &config) {
-    assert(io_module_);
-    io_module_->setContentStoreSize(config.csReserved());
-    served_namespaces_.push_back(config.prefix());
-    setLocalRoutes();
-  }
-
-  /**
-   * Start the event loop. This function blocks here and calls the callback set
-   * by the application upon interest/data received or timeout.
-   */
-  TRANSPORT_ALWAYS_INLINE void runEventsLoop() {
-    if (io_service_.stopped()) {
-      io_service_.reset();  // ensure that run()/poll() will do some work
-    }
-
-    io_service_.run();
-  }
-
-  /**
-   * Run one event and return.
-   */
-  TRANSPORT_ALWAYS_INLINE void runOneEvent() {
-    if (io_service_.stopped()) {
-      io_service_.reset();  // ensure that run()/poll() will do some work
-    }
-
-    io_service_.run_one();
-  }
-
-  /**
-   * Send a data packet to the local forwarder. As opposite to sendInterest, the
-   * ownership of the content object is not transferred to the portal.
+   * Send a data packet to the local forwarder.
    *
    * @param content_object - The data packet.
    */
-  TRANSPORT_ALWAYS_INLINE void sendContentObject(
-      ContentObject &content_object) {
+  void sendContentObject(ContentObject &content_object) {
+    DCHECK(io_module_);
+    DCHECK(std::this_thread::get_id() == worker_.getThreadId());
+
     io_module_->send(content_object);
   }
 
   /**
-   * Stop the event loop, canceling all the pending events in the event queue.
-   *
-   * Beware that stopping the event loop DOES NOT disconnect the transport from
-   * the local forwarder, the connector underneath will stay connected.
+   * Disconnect the transport from the local forwarder.
    */
-  TRANSPORT_ALWAYS_INLINE void stopEventsLoop() {
-    if (!io_service_.stopped()) {
-      io_service_.dispatch([this]() {
-        clear();
-        io_service_.stop();
-      });
+  void killConnection() {
+    if (TRANSPORT_EXPECT_TRUE(io_module_ != nullptr)) {
+      io_module_->closeConnection();
     }
   }
 
   /**
-   * Disconnect the transport from the local forwarder.
+   * Clear the pending interest hash table.
    */
-  TRANSPORT_ALWAYS_INLINE void killConnection() {
-    io_module_->closeConnection();
+  void clear() {
+    worker_.tryRunHandlerNow([self{shared_from_this()}]() { self->doClear(); });
   }
 
   /**
-   * Clear the pending interest hash table.
+   * Get a reference to the io_service object.
    */
-  TRANSPORT_ALWAYS_INLINE void clear() {
-    if (!io_service_.stopped()) {
-      io_service_.dispatch(std::bind(&Portal::doClear, this));
-    } else {
-      doClear();
-    }
-  }
+  utils::EventThread &getThread() { return worker_; }
 
   /**
-   * Remove one pending interest.
+   * Register a route to the local forwarder.
    */
-  TRANSPORT_ALWAYS_INLINE void clearOne(const Name &name) {
-    if (!io_service_.stopped()) {
-      io_service_.dispatch(std::bind(&Portal::doClearOne, this, name));
-    } else {
-      doClearOne(name);
-    }
+  void registerRoute(const Prefix &prefix) {
+    std::weak_ptr<Portal> self = shared_from_this();
+    worker_.tryRunHandlerNow([self, prefix]() {
+      if (auto ptr = self.lock()) {
+        auto ret = ptr->served_namespaces_.insert(prefix);
+        if (ret.second && ptr->io_module_ && ptr->io_module_->isConnected()) {
+          ptr->io_module_->registerRoute(prefix);
+        }
+      }
+    });
   }
 
   /**
-   * Get a reference to the io_service object.
+   * Send a MAP-Me update to traverse NATs.
    */
-  TRANSPORT_ALWAYS_INLINE asio::io_service &getIoService() {
-    return io_service_;
+  TRANSPORT_ALWAYS_INLINE void sendMapme() {
+    if (io_module_->isConnected()) {
+      io_module_->sendMapme();
+    }
   }
 
   /**
-   * Register a route to the local forwarder.
+   * set forwarding strategy
    */
-  TRANSPORT_ALWAYS_INLINE void registerRoute(Prefix &prefix) {
-    served_namespaces_.push_back(prefix);
+  TRANSPORT_ALWAYS_INLINE void setForwardingStrategy(Prefix &prefix,
+                                                     std::string &strategy) {
     if (io_module_->isConnected()) {
-      io_module_->registerRoute(prefix);
+      io_module_->setForwardingStrategy(prefix, strategy);
     }
   }
 
   /**
    * Check if the transport is connected to a forwarder or not
    */
-  TRANSPORT_ALWAYS_INLINE bool isConnectedToFwd() {
+  bool isConnectedToFwd() {
     std::string mod = io_module_path_.substr(0, io_module_path_.find("."));
     if (mod == "forwarder_module") return false;
     return true;
   }
 
+  auto &getServedNamespaces() { return served_namespaces_; }
+
  private:
   /**
-   * Clear the pending interest hash table.
+   * Compute name hash
    */
-  TRANSPORT_ALWAYS_INLINE void doClear() {
-    for (auto &pend_interest : pending_interest_hash_table_) {
-      pend_interest.second->cancelTimer();
-
-      // Get interest packet from pending interest and do nothing with it. It
-      // will get destroyed as it goes out of scope.
-      auto _int = pend_interest.second->getInterest();
-    }
-
-    pending_interest_hash_table_.clear();
+  uint32_t getHash(const Name &name) {
+    return name.getHash32(false) + name.getSuffix();
   }
 
   /**
-   * Remove one pending interest.
+   * Clear the pending interest hash table.
    */
-  TRANSPORT_ALWAYS_INLINE void doClearOne(const Name &name) {
-    auto it = pending_interest_hash_table_.find(getHash(name));
-
-    if (it != pending_interest_hash_table_.end()) {
-      it->second->cancelTimer();
-
-      // Get interest packet from pending interest and do nothing with it. It
-      // will get destroyed as it goes out of scope.
-      auto _int = it->second->getInterest();
-
-      pending_interest_hash_table_.erase(it);
+  void doClear() {
+    for (auto &pend_interest : pending_interest_hash_table_) {
+      pend_interest.second.cancelTimer();
     }
+
+    pending_interest_hash_table_.clear();
   }
 
   /**
-   * Callback called by the underlying connector upon reception of a packet from
-   * the local forwarder.
+   * Callback called by the underlying connector upon reception of a packet
+   * from the local forwarder.
    *
    * @param packet_buffer - The bytes of the packet.
    */
-  TRANSPORT_ALWAYS_INLINE void processIncomingMessages(
-      Connector *c, utils::MemBuf &buffer, const std::error_code &ec) {
-    bool is_stopped = io_service_.stopped();
-    if (TRANSPORT_EXPECT_FALSE(is_stopped)) {
+  void processIncomingMessages(Connector *c,
+                               const std::vector<utils::MemBuf::Ptr> &buffers,
+                               const std::error_code &ec) {
+    if (!transport_callback_) {
       return;
     }
 
-    if (TRANSPORT_EXPECT_FALSE(io_module_->isControlMessage(buffer.data()))) {
-      processControlMessage(buffer);
+    if (TRANSPORT_EXPECT_FALSE(ec.operator bool())) {
+      // Error receiving from underlying infra.
+      if (transport_callback_) {
+        transport_callback_->onError(ec);
+      }
+
       return;
     }
 
-    // The buffer is a base class for an interest or a content object
-    Packet &packet_buffer = static_cast<Packet &>(buffer);
+    for (auto &buffer_ptr : buffers) {
+      auto &buffer = *buffer_ptr;
+
+      if (TRANSPORT_EXPECT_FALSE(io_module_->isControlMessage(buffer))) {
+        processControlMessage(buffer);
+        return;
+      }
 
-    auto format = packet_buffer.getFormat();
-    if (TRANSPORT_EXPECT_TRUE(_is_tcp(format))) {
-      if (is_consumer_) {
-        processContentObject(static_cast<ContentObject &>(packet_buffer));
+      auto format = Packet::getFormatFromBuffer(buffer.data(), buffer.length());
+      if (TRANSPORT_EXPECT_TRUE(_is_cmpr(format) || _is_tcp(format))) {
+        // The buffer is a base class for an interest or a content object
+        Packet &packet_buffer = static_cast<Packet &>(buffer);
+        if (is_consumer_ && !packet_buffer.isInterest()) {
+          processContentObject(static_cast<ContentObject &>(packet_buffer));
+        } else if (!is_consumer_ && packet_buffer.isInterest()) {
+          processInterest(static_cast<Interest &>(packet_buffer));
+        } else {
+          auto packet_type =
+              packet_buffer.isInterest() ? "Interest" : "ContentObject";
+          auto socket_type = is_consumer_ ? "consumer " : "producer ";
+          LOG(ERROR) << "Received a " << packet_type << " packet with name "
+                     << packet_buffer.getName() << " in a " << socket_type
+                     << " transport. Ignoring it.";
+        }
       } else {
-        processInterest(static_cast<Interest &>(packet_buffer));
+        LOG(ERROR) << "Received not supported packet. Ignoring it.";
       }
-    } else {
-      LOG(ERROR) << "Received not supported packet. Ignoring it.";
     }
   }
 
@@ -601,19 +569,21 @@ class Portal {
    * It register the prefixes in the served_namespaces_ list to the local
    * forwarder.
    */
-  TRANSPORT_ALWAYS_INLINE void setLocalRoutes() {
+  void setLocalRoutes() {
+    DCHECK(io_module_);
+    DCHECK(io_module_->isConnected());
+    DCHECK(std::this_thread::get_id() == worker_.getThreadId());
+
     for (auto &prefix : served_namespaces_) {
-      if (io_module_->isConnected()) {
-        io_module_->registerRoute(prefix);
-      }
+      io_module_->registerRoute(prefix);
     }
   }
 
-  TRANSPORT_ALWAYS_INLINE void processInterest(Interest &interest) {
+  void processInterest(Interest &interest) {
     // Interest for a producer
     DLOG_IF(INFO, VLOG_IS_ON(3)) << "processInterest " << interest.getName();
-    if (TRANSPORT_EXPECT_TRUE(producer_callback_ != nullptr)) {
-      producer_callback_->onInterest(interest);
+    if (TRANSPORT_EXPECT_TRUE(transport_callback_ != nullptr)) {
+      transport_callback_->onInterest(interest);
     }
   }
 
@@ -625,8 +595,7 @@ class Portal {
    *
    * @param content_object - The data packet
    */
-  TRANSPORT_ALWAYS_INLINE void processContentObject(
-      ContentObject &content_object) {
+  void processContentObject(ContentObject &content_object) {
     DLOG_IF(INFO, VLOG_IS_ON(3))
         << "processContentObject " << content_object.getName();
     uint32_t hash = getHash(content_object.getName());
@@ -635,15 +604,16 @@ class Portal {
     if (it != pending_interest_hash_table_.end()) {
       DLOG_IF(INFO, VLOG_IS_ON(3)) << "Found pending interest.";
 
-      PendingInterest::Ptr interest_ptr = std::move(it->second);
+      PendingInterest &pend_interest = it->second;
+      pend_interest.cancelTimer();
+      auto _int = pend_interest.getInterest();
+      auto callback = pend_interest.getOnDataCallback();
       pending_interest_hash_table_.erase(it);
-      interest_ptr->cancelTimer();
-      auto _int = interest_ptr->getInterest();
 
-      if (interest_ptr->getOnDataCallback() != UNSET_CALLBACK) {
-        interest_ptr->on_content_object_callback_(*_int, content_object);
-      } else if (consumer_callback_) {
-        consumer_callback_->onContentObject(*_int, content_object);
+      if (callback != UNSET_CALLBACK) {
+        callback(*_int, content_object);
+      } else if (transport_callback_) {
+        transport_callback_->onContentObject(*_int, content_object);
       }
     } else {
       DLOG_IF(INFO, VLOG_IS_ON(3))
@@ -652,12 +622,11 @@ class Portal {
   }
 
   /**
-   * Process a control message. Control messages are different depending on the
-   * connector, then the forwarder_interface will do the job of understanding
-   * them.
+   * Process a control message. Control messages are different depending on
+   * the connector, then the forwarder_interface will do the job of
+   * understanding them.
    */
-  TRANSPORT_ALWAYS_INLINE void processControlMessage(
-      utils::MemBuf &packet_buffer) {
+  void processControlMessage(utils::MemBuf &packet_buffer) {
     io_module_->processControlMessageReply(packet_buffer);
   }
 
@@ -665,17 +634,14 @@ class Portal {
   portal_details::HandlerMemory async_callback_memory_;
   std::unique_ptr<IoModule, void (*)(IoModule *)> io_module_;
 
-  asio::io_service &io_service_;
-  asio::io_service internal_io_service_;
-  portal_details::Pool packet_pool_;
+  ::utils::EventThread &worker_;
 
   std::string app_name_;
 
   PendingInterestHashTable pending_interest_hash_table_;
-  std::list<Prefix> served_namespaces_;
+  std::set<Prefix> served_namespaces_;
 
-  ConsumerCallback *consumer_callback_;
-  ProducerCallback *producer_callback_;
+  TransportCallback *transport_callback_;
 
   bool is_consumer_;
 
diff --git a/libtransport/src/core/prefix.cc b/libtransport/src/core/prefix.cc
index d598cff75..4c1e191e9 100644
--- a/libtransport/src/core/prefix.cc
+++ b/libtransport/src/core/prefix.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -99,6 +99,14 @@ void Prefix::buildPrefix(std::string &prefix, uint16_t prefix_length,
   ip_prefix_.family = family;
 }
 
+bool Prefix::operator<(const Prefix &other) const {
+  return ip_prefix_cmp(&ip_prefix_, &other.ip_prefix_) < 0;
+}
+
+bool Prefix::operator==(const Prefix &other) const {
+  return ip_prefix_cmp(&ip_prefix_, &other.ip_prefix_) == 0;
+}
+
 std::unique_ptr<Sockaddr> Prefix::toSockaddr() const {
   Sockaddr *ret = nullptr;
 
@@ -211,8 +219,6 @@ Name Prefix::getName(const core::Name &mask, const core::Name &components,
     }
   }
 
-  // if (this->contains(name_ip))
-  //   throw errors::RuntimeException("Mask overrides the prefix");
   return Name(ip_prefix_.family, (uint8_t *)&name_ip);
 }
 
@@ -279,8 +285,6 @@ Prefix &Prefix::setNetwork(std::string &network) {
 }
 
 Name Prefix::makeRandomName() const {
-  srand((unsigned int)time(nullptr));
-
   if (ip_prefix_.family == AF_INET6) {
     std::default_random_engine eng((std::random_device())());
     std::uniform_int_distribution<uint32_t> idis(
diff --git a/libtransport/src/core/tcp_socket_connector.cc b/libtransport/src/core/tcp_socket_connector.cc
index a30264271..7758e2cf2 100644
--- a/libtransport/src/core/tcp_socket_connector.cc
+++ b/libtransport/src/core/tcp_socket_connector.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -85,8 +85,10 @@ void TcpSocketConnector::send(const uint8_t *packet, std::size_t len,
                               const PacketSentCallback &packet_sent) {
   if (packet_sent != 0) {
     asio::async_write(socket_, asio::buffer(packet, len),
-                      [packet_sent](std::error_code ec,
-                                    std::size_t /*length*/) { packet_sent(); });
+                      [packet_sent](const std::error_code &ec)
+                          std::size_t /*length*/) {
+      packet_sent();
+    });
   } else {
     if (state_ == ConnectorState::CONNECTED) {
       asio::write(socket_, asio::buffer(packet, len));
@@ -151,7 +153,7 @@ void TcpSocketConnector::doWrite() {
 
   asio::async_write(
       socket_, std::move(array),
-      [this, packet_store = std::move(packet_store)](std::error_code ec,
+      [this, packet_store = std::move(packet_store)](const std::error_code &ec,
                                                      std::size_t length) {
         if (TRANSPORT_EXPECT_TRUE(!ec)) {
           if (!output_buffer_.empty()) {
@@ -172,7 +174,7 @@ void TcpSocketConnector::doReadBody(std::size_t body_length) {
   asio::async_read(
       socket_, asio::buffer(read_msg_->writableTail(), body_length),
       asio::transfer_exactly(body_length),
-      [this](std::error_code ec, std::size_t length) {
+      [this](const std::error_code &ec, std::size_t length) {
         read_msg_->append(length);
         if (TRANSPORT_EXPECT_TRUE(!ec)) {
           receive_callback_(std::move(read_msg_));
@@ -195,7 +197,7 @@ void TcpSocketConnector::doReadHeader() {
       asio::buffer(read_msg_->writableData(),
                    NetworkMessage::fixed_header_length),
       asio::transfer_exactly(NetworkMessage::fixed_header_length),
-      [this](std::error_code ec, std::size_t length) {
+      [this](const std::error_code &ec, std::size_t length) {
         if (TRANSPORT_EXPECT_TRUE(!ec)) {
           read_msg_->append(NetworkMessage::fixed_header_length);
           std::size_t body_length = 0;
@@ -235,7 +237,7 @@ void TcpSocketConnector::tryReconnect() {
 void TcpSocketConnector::doConnect() {
   asio::async_connect(
       socket_, endpoint_iterator_,
-      [this](std::error_code ec, tcp::resolver::iterator) {
+      [this](const std::error_code &ec, tcp::resolver::iterator) {
         if (!ec) {
           timer_.cancel();
           state_ = ConnectorState::CONNECTED;
diff --git a/libtransport/src/core/tcp_socket_connector.h b/libtransport/src/core/tcp_socket_connector.h
index 21db8301e..2901a5c9d 100644
--- a/libtransport/src/core/tcp_socket_connector.h
+++ b/libtransport/src/core/tcp_socket_connector.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/core/udp_connector.cc b/libtransport/src/core/udp_connector.cc
new file mode 100644
index 000000000..ee0c7ea9c
--- /dev/null
+++ b/libtransport/src/core/udp_connector.cc
@@ -0,0 +1,371 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ */
+
+#include <core/errors.h>
+#include <core/udp_connector.h>
+#include <glog/logging.h>
+#include <hicn/transport/utils/branch_prediction.h>
+
+#include <iostream>
+#include <thread>
+#include <vector>
+
+namespace transport {
+namespace core {
+
+UdpTunnelConnector::~UdpTunnelConnector() {}
+
+void UdpTunnelConnector::connect(const std::string &hostname, uint16_t port,
+                                 const std::string &bind_address,
+                                 uint16_t bind_port) {
+  if (state_ == State::CLOSED) {
+    state_ = State::CONNECTING;
+
+    asio::ip::udp::resolver::query query(asio::ip::udp::v4(), hostname,
+                                         std::to_string(port));
+
+    endpoint_iterator_ = resolver_.resolve(query);
+    remote_endpoint_send_ = *endpoint_iterator_;
+    socket_->open(remote_endpoint_send_.protocol());
+
+    if (!bind_address.empty() && bind_port != 0) {
+      using namespace asio::ip;
+
+      auto address = address::from_string(bind_address);
+      if (address.is_v6()) {
+        std::error_code ec;
+        socket_->set_option(asio::ip::v6_only(false), ec);
+        // Call succeeds only on dual stack systems.
+      }
+
+      socket_->bind(udp::endpoint(address, bind_port));
+    }
+
+    remote_endpoint_ = Endpoint(remote_endpoint_send_);
+    local_endpoint_ = Endpoint(socket_->local_endpoint());
+
+    auto self = shared_from_this();
+    doConnect(self);
+  }
+}
+
+void UdpTunnelConnector::send(Packet &packet) {
+  send(packet.shared_from_this());
+}
+
+void UdpTunnelConnector::send(const utils::MemBuf::Ptr &buffer) {
+  auto self = shared_from_this();
+  io_service_.post([self, pkt{buffer}]() {
+    bool write_in_progress = !self->output_buffer_.empty();
+    self->output_buffer_.push_back(std::move(pkt));
+    if (TRANSPORT_EXPECT_TRUE(self->state_ == State::CONNECTED)) {
+      if (!write_in_progress) {
+        self->doSendPacket(self);
+      }
+    } else {
+      self->data_available_ = true;
+    }
+  });
+}
+
+void UdpTunnelConnector::close() {
+  DLOG_IF(INFO, VLOG_IS_ON(2)) << "UDPTunnelConnector::close";
+  state_ = State::CLOSED;
+  bool is_socket_owned = socket_.use_count() == 1;
+  if (is_socket_owned) {
+    // Here we use a shared ptr to keep the object alive until we call the close
+    // function
+    auto self = shared_from_this();
+    io_service_.dispatch([this, self]() {
+      socket_->close();
+      // on_close_callback_(shared_from_this());
+    });
+  }
+}
+
+void UdpTunnelConnector::doSendPacket(
+    const std::shared_ptr<UdpTunnelConnector> &self) {
+#ifdef LINUX
+  send_timer_.expires_from_now(std::chrono::microseconds(50));
+  send_timer_.async_wait([self](const std::error_code &ec) {
+    if (ec) {
+      return;
+    }
+
+    self->writeHandler();
+  });
+#else
+  auto packet = output_buffer_.front().get();
+  auto array = std::vector<asio::const_buffer>();
+
+  const ::utils::MemBuf *current = packet;
+  do {
+    array.push_back(asio::const_buffer(current->data(), current->length()));
+    current = current->next();
+  } while (current != packet);
+
+  socket_->async_send_to(
+      std::move(array), remote_endpoint_send_,
+      [this, self](const std::error_code &ec, std::size_t length) {
+        if (TRANSPORT_EXPECT_TRUE(!ec)) {
+          sent_callback_(this, make_error_code(core_error::success));
+        } else if (ec.value() ==
+                   static_cast<int>(std::errc::operation_canceled)) {
+          // The connection has been closed by the application.
+          return;
+        } else {
+          sendFailed();
+          sent_callback_(this, ec);
+        }
+
+        output_buffer_.pop_front();
+        if (!output_buffer_.empty()) {
+          doSendPacket(self);
+        }
+      });
+#endif
+}
+
+void UdpTunnelConnector::retryConnection() {
+  // The connection was refused. In this case let's retry to reconnect.
+  connection_reattempts_++;
+  LOG(ERROR) << "Error in UDP: Connection refused. Retrying...";
+  state_ = State::CONNECTING;
+  timer_.expires_from_now(std::chrono::milliseconds(500));
+  std::weak_ptr<UdpTunnelConnector> self = shared_from_this();
+  timer_.async_wait([self, this](const std::error_code &ec) {
+    if (ec) {
+    }
+    if (auto ptr = self.lock()) {
+      doConnect(ptr);
+    }
+  });
+  return;
+}
+
+#ifdef LINUX
+void UdpTunnelConnector::writeHandler() {
+  if (TRANSPORT_EXPECT_FALSE(state_ != State::CONNECTED)) {
+    return;
+  }
+
+  auto len = std::min(output_buffer_.size(), std::size_t(Connector::max_burst));
+
+  if (len) {
+    int m = 0;
+    for (auto &p : output_buffer_) {
+      auto packet = p.get();
+      ::utils::MemBuf *current = packet;
+      int b = 0;
+      do {
+        // array.push_back(asio::const_buffer(current->data(),
+        // current->length()));
+        tx_iovecs_[m][b].iov_base = current->writableData();
+        tx_iovecs_[m][b].iov_len = current->length();
+        current = current->next();
+        b++;
+      } while (current != packet);
+
+      tx_msgs_[m].msg_hdr.msg_iov = tx_iovecs_[m];
+      tx_msgs_[m].msg_hdr.msg_iovlen = b;
+      tx_msgs_[m].msg_hdr.msg_name = remote_endpoint_send_.data();
+      tx_msgs_[m].msg_hdr.msg_namelen = remote_endpoint_send_.size();
+      m++;
+
+      if (--len == 0) {
+        break;
+      }
+    }
+
+    int retval = sendmmsg(socket_->native_handle(), tx_msgs_, m, MSG_DONTWAIT);
+    if (retval > 0) {
+      while (retval--) {
+        output_buffer_.pop_front();
+      }
+    } else if (errno != EWOULDBLOCK && errno != EAGAIN) {
+      LOG(ERROR) << "Error sending messages: " << strerror(errno);
+      sent_callback_(this, make_error_code(core_error::send_failed));
+      return;
+    }
+  }
+
+  if (!output_buffer_.empty()) {
+    send_timer_.expires_from_now(std::chrono::microseconds(50));
+    std::weak_ptr<UdpTunnelConnector> self = shared_from_this();
+    send_timer_.async_wait([self](const std::error_code &ec) {
+      if (ec) {
+        return;
+      }
+      if (auto ptr = self.lock()) {
+        ptr->writeHandler();
+      }
+    });
+  }
+}
+
+void UdpTunnelConnector::readHandler(const std::error_code &ec) {
+  DLOG_IF(INFO, VLOG_IS_ON(3)) << "UdpTunnelConnector receive packet";
+
+  if (TRANSPORT_EXPECT_TRUE(!ec)) {
+    if (TRANSPORT_EXPECT_TRUE(state_ == State::CONNECTED)) {
+      if (current_position_ == 0) {
+        for (int i = 0; i < max_burst; i++) {
+          auto read_buffer = getRawBuffer();
+          rx_iovecs_[i][0].iov_base = read_buffer.first;
+          rx_iovecs_[i][0].iov_len = read_buffer.second;
+          rx_msgs_[i].msg_hdr.msg_iov = rx_iovecs_[i];
+          rx_msgs_[i].msg_hdr.msg_iovlen = 1;
+        }
+      }
+
+      int res = recvmmsg(socket_->native_handle(), rx_msgs_ + current_position_,
+                         max_burst - current_position_, MSG_DONTWAIT, nullptr);
+      if (res < 0) {
+        if (errno == EWOULDBLOCK || errno == EAGAIN) {
+          // Try again later
+          return;
+        }
+
+        if (errno == ECONNREFUSED &&
+            connection_reattempts_ < max_reconnection_reattempts) {
+          retryConnection();
+          return;
+        }
+
+        LOG(ERROR) << "Error receiving messages! " << strerror(errno) << " "
+                   << res;
+        std::vector<utils::MemBuf::Ptr> v;
+        auto ec = make_error_code(core_error::receive_failed);
+
+        receive_callback_(this, v, ec);
+        return;
+      }
+
+      std::vector<utils::MemBuf::Ptr> v;
+      v.reserve(res);
+      for (int i = 0; i < res; i++) {
+        auto packet = getPacketFromBuffer(
+            reinterpret_cast<uint8_t *>(
+                rx_msgs_[current_position_].msg_hdr.msg_iov[0].iov_base),
+            rx_msgs_[current_position_].msg_len);
+        receiveSuccess(*packet);
+        v.push_back(std::move(packet));
+        ++current_position_;
+      }
+
+      receive_callback_(this, v, make_error_code(core_error::success));
+
+      doRecvPacket();
+    } else {
+      LOG(ERROR) << "Error in UDP: Receiving packets from a not "
+                    "connected socket.";
+    }
+  } else if (ec.value() == static_cast<int>(std::errc::operation_canceled)) {
+    LOG(ERROR) << "The connection has been closed by the application.";
+    return;
+  } else {
+    if (TRANSPORT_EXPECT_TRUE(state_ == State::CONNECTED)) {
+      // receive_callback_(this, *read_msg_, ec);
+      LOG(ERROR) << "Error in UDP connector: " << ec.value() << " "
+                 << ec.message();
+    } else {
+      LOG(ERROR) << "Error in connector while not connected. " << ec.value()
+                 << " " << ec.message();
+    }
+  }
+}
+#endif
+
+void UdpTunnelConnector::doRecvPacket() {
+  std::weak_ptr<UdpTunnelConnector> self = shared_from_this();
+#ifdef LINUX
+  if (state_ == State::CONNECTED) {
+#if ((ASIO_VERSION / 100 % 1000) < 11)
+    socket_->async_receive(asio::null_buffers(),
+#else
+    socket_->async_wait(asio::ip::tcp::socket::wait_read,
+#endif
+                           [self](const std::error_code &ec) {
+                             if (ec) {
+                               LOG(ERROR)
+                                   << "Error in UDP connector: " << ec.value()
+                                   << " " << ec.message();
+                               return;
+                             }
+                             if (auto ptr = self.lock()) {
+                               ptr->readHandler(ec);
+                             }
+                           });
+  }
+#else
+  DLOG_IF(INFO, VLOG_IS_ON(3)) << "UdpTunnelConnector receive packet";
+  read_msg_ = getRawBuffer();
+  socket_->async_receive_from(
+      asio::buffer(read_msg_.first, read_msg_.second), remote_endpoint_recv_,
+      [this, self](const std::error_code &ec, std::size_t length) {
+        if (auto ptr = self.lock()) {
+          DLOG_IF(INFO, VLOG_IS_ON(3))
+              << "UdpTunnelConnector received packet length=" << length;
+          if (TRANSPORT_EXPECT_TRUE(!ec)) {
+            if (TRANSPORT_EXPECT_TRUE(state_ == State::CONNECTED)) {
+              auto packet = getPacketFromBuffer(read_msg_.first, length);
+              receiveSuccess(*packet);
+              std::vector<utils::MemBuf::Ptr> v{std::move(packet)};
+              receive_callback_(this, v, make_error_code(core_error::success));
+              doRecvPacket();
+            } else {
+              LOG(ERROR) << "Error in UDP: Receiving packets from a not "
+                            "connected socket.";
+            }
+          } else if (ec.value() ==
+                     static_cast<int>(std::errc::operation_canceled)) {
+            LOG(ERROR) << "The connection has been closed by the application.";
+            return;
+          } else if (ec.value() ==
+                     static_cast<int>(std::errc::connection_refused)) {
+            if (connection_reattempts_ < max_reconnection_reattempts) {
+              retryConnection();
+            }
+          } else {
+            if (TRANSPORT_EXPECT_TRUE(state_ == State::CONNECTED)) {
+              LOG(ERROR) << "Error in UDP connector: " << ec.value()
+                         << ec.message();
+            } else {
+              LOG(ERROR) << "Error while not connected";
+            }
+          }
+        }
+      });
+#endif
+}
+
+void UdpTunnelConnector::doConnect(
+    std::shared_ptr<UdpTunnelConnector> &self_shared) {
+  std::weak_ptr<UdpTunnelConnector> self = self_shared;
+  asio::async_connect(*socket_, endpoint_iterator_,
+                      [this, self](const std::error_code &ec,
+                                   asio::ip::udp::resolver::iterator) {
+                        if (auto ptr = self.lock()) {
+                          if (!ec) {
+                            state_ = State::CONNECTED;
+                            doRecvPacket();
+
+                            if (data_available_) {
+                              data_available_ = false;
+                              doSendPacket(ptr);
+                            }
+
+                            on_reconnect_callback_(
+                                this, make_error_code(core_error::success));
+                          } else {
+                            LOG(ERROR) << "UDP Connection failed!!!";
+                            retryConnection();
+                          }
+                        }
+                      });
+}
+
+}  // namespace core
+
+}  // namespace transport
diff --git a/libtransport/src/io_modules/forwarder/udp_tunnel.h b/libtransport/src/core/udp_connector.h
index 4f044f93f..65821852d 100644
--- a/libtransport/src/io_modules/forwarder/udp_tunnel.h
+++ b/libtransport/src/core/udp_connector.h
@@ -1,13 +1,13 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  */
 
 #pragma once
 
+#include <core/errors.h>
 #include <hicn/transport/core/asio_wrapper.h>
 #include <hicn/transport/core/connector.h>
 #include <hicn/transport/portability/platform.h>
-#include <io_modules/forwarder/errors.h>
 
 #include <iostream>
 #include <memory>
@@ -30,16 +30,15 @@ class UdpTunnelConnector : public Connector {
       : Connector(receive_callback, packet_sent, on_close_callback,
                   on_reconnect),
         io_service_(io_service),
-        strand_(std::make_shared<asio::io_service::strand>(io_service_)),
         socket_(std::make_shared<asio::ip::udp::socket>(io_service_)),
         resolver_(io_service_),
         timer_(io_service_),
 #ifdef LINUX
         send_timer_(io_service_),
-        tx_iovecs_{0},
-        tx_msgs_{0},
-        rx_iovecs_{0},
-        rx_msgs_{0},
+        tx_iovecs_{},
+        tx_msgs_{},
+        rx_iovecs_{},
+        rx_msgs_{},
         current_position_(0),
 #else
         read_msg_(nullptr, 0),
@@ -61,17 +60,16 @@ class UdpTunnelConnector : public Connector {
 #else
         io_service_((asio::io_context &)(socket->get_executor().context())),
 #endif
-        strand_(strand),
         socket_(socket),
         resolver_(io_service_),
         remote_endpoint_send_(std::forward<EndpointType &&>(remote_endpoint)),
         timer_(io_service_),
 #ifdef LINUX
         send_timer_(io_service_),
-        tx_iovecs_{0},
-        tx_msgs_{0},
-        rx_iovecs_{0},
-        rx_msgs_{0},
+        tx_iovecs_{},
+        tx_msgs_{},
+        rx_iovecs_{},
+        rx_msgs_{},
         current_position_(0),
 #else
         read_msg_(nullptr, 0),
@@ -88,7 +86,7 @@ class UdpTunnelConnector : public Connector {
 
   void send(Packet &packet) override;
 
-  void send(const uint8_t *packet, std::size_t len) override;
+  void send(const utils::MemBuf::Ptr &buffer) override;
 
   void close() override;
 
@@ -99,26 +97,27 @@ class UdpTunnelConnector : public Connector {
   auto shared_from_this() { return utils::shared_from(this); }
 
  private:
-  void doConnect();
+  void retryConnection();
+  void doConnect(std::shared_ptr<UdpTunnelConnector> &self);
   void doRecvPacket();
 
-  void doRecvPacket(utils::MemBuf &buffer) {
-    receive_callback_(this, buffer, make_error_code(forwarder_error::success));
+  void doRecvPacket(utils::MemBuf::Ptr &buffer) {
+    std::vector<utils::MemBuf::Ptr> v{std::move(buffer)};
+    receive_callback_(this, v, make_error_code(core_error::success));
   }
 
 #ifdef LINUX
-  void readHandler(std::error_code ec);
-  void writeHandler(std::error_code ec);
+  void readHandler(const std::error_code &ec);
+  void writeHandler();
 #endif
 
   void setConnected() { state_ = State::CONNECTED; }
 
-  void doSendPacket();
+  void doSendPacket(const std::shared_ptr<UdpTunnelConnector> &self);
   void doClose();
 
  private:
   asio::io_service &io_service_;
-  std::shared_ptr<asio::io_service::strand> strand_;
   std::shared_ptr<asio::ip::udp::socket> socket_;
   asio::ip::udp::resolver resolver_;
   asio::ip::udp::resolver::iterator endpoint_iterator_;
diff --git a/libtransport/src/io_modules/forwarder/udp_tunnel_listener.cc b/libtransport/src/core/udp_listener.cc
index d047cc568..c67673392 100644
--- a/libtransport/src/io_modules/forwarder/udp_tunnel_listener.cc
+++ b/libtransport/src/core/udp_listener.cc
@@ -1,11 +1,11 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  */
 
+#include <core/udp_connector.h>
+#include <core/udp_listener.h>
 #include <glog/logging.h>
 #include <hicn/transport/utils/hash.h>
-#include <io_modules/forwarder/udp_tunnel.h>
-#include <io_modules/forwarder/udp_tunnel_listener.h>
 
 #ifndef LINUX
 namespace std {
@@ -35,7 +35,7 @@ void UdpTunnelListener::close() {
 }
 
 #ifdef LINUX
-void UdpTunnelListener::readHandler(std::error_code ec) {
+void UdpTunnelListener::readHandler(const std::error_code &ec) {
   DLOG_IF(INFO, VLOG_IS_ON(3)) << "UdpTunnelConnector receive packet";
 
   if (TRANSPORT_EXPECT_TRUE(!ec)) {
@@ -102,7 +102,8 @@ void UdpTunnelListener::readHandler(std::error_code ec) {
             std::make_shared<UdpTunnelConnector>(
                 socket_, strand_, receive_callback_,
                 [](Connector *, const std::error_code &) {}, [](Connector *) {},
-                [](Connector *) {}, std::move(remote_endpoint_)));
+                [](Connector *, const std::error_code &) {},
+                std::move(remote_endpoint_)));
         connector = ret.first;
         connector->second->setConnectorId(connector_id);
       }
@@ -112,7 +113,7 @@ void UdpTunnelListener::readHandler(std::error_code ec) {
        */
       UdpTunnelConnector *c =
           dynamic_cast<UdpTunnelConnector *>(connector->second.get());
-      c->doRecvPacket(*packet);
+      c->doRecvPacket(packet);
 
       ++current_position_;
     }
@@ -141,7 +142,7 @@ void UdpTunnelListener::doRecvPacket() {
   read_msg_ = Connector::getRawBuffer();
   socket_->async_receive_from(
       asio::buffer(read_msg_.first, read_msg_.second), remote_endpoint_,
-      [this](std::error_code ec, std::size_t length) {
+      [this](const std::error_code &ec, std::size_t length) {
         if (TRANSPORT_EXPECT_TRUE(!ec)) {
           auto packet = Connector::getPacketFromBuffer(read_msg_.first, length);
           auto connector_id =
@@ -153,7 +154,8 @@ void UdpTunnelListener::doRecvPacket() {
                 connector_id, std::make_shared<UdpTunnelConnector>(
                                   socket_, strand_, receive_callback_,
                                   [](Connector *, const std::error_code &) {},
-                                  [](Connector *) {}, [](Connector *) {},
+                                  [](Connector *) {},
+                                  [](Connector *, const std::error_code &) {},
                                   std::move(remote_endpoint_)));
             connector = ret.first;
             connector->second->setConnectorId(connector_id);
@@ -161,7 +163,7 @@ void UdpTunnelListener::doRecvPacket() {
 
           UdpTunnelConnector *c =
               dynamic_cast<UdpTunnelConnector *>(connector->second.get());
-          c->doRecvPacket(*packet);
+          c->doRecvPacket(packet);
           doRecvPacket();
         } else if (ec.value() ==
                    static_cast<int>(std::errc::operation_canceled)) {
diff --git a/libtransport/src/io_modules/forwarder/udp_tunnel_listener.h b/libtransport/src/core/udp_listener.h
index 5d197dcb0..813520309 100644
--- a/libtransport/src/io_modules/forwarder/udp_tunnel_listener.h
+++ b/libtransport/src/core/udp_listener.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  */
 
 #pragma once
@@ -44,8 +44,8 @@ class UdpTunnelListener
 #ifndef LINUX
         read_msg_(nullptr, 0)
 #else
-        iovecs_{0},
-        msgs_{0},
+        iovecs_{},
+        msgs_{},
         current_position_(0)
 #endif
   {
@@ -83,7 +83,7 @@ class UdpTunnelListener
  private:
   void doRecvPacket();
 
-  void readHandler(std::error_code ec);
+  void readHandler(const std::error_code &ec);
 
   asio::io_service &io_service_;
   std::shared_ptr<asio::io_service::strand> strand_;
diff --git a/libtransport/src/http/CMakeLists.txt b/libtransport/src/http/CMakeLists.txt
index 2407faea3..0060f8714 100644
--- a/libtransport/src/http/CMakeLists.txt
+++ b/libtransport/src/http/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/libtransport/src/http/client_connection.cc b/libtransport/src/http/client_connection.cc
index b4ab7cbc3..05fa3e335 100644
--- a/libtransport/src/http/client_connection.cc
+++ b/libtransport/src/http/client_connection.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -77,9 +77,7 @@ class HTTPClientConnection::Implementation
       auto end = std::chrono::steady_clock::now();
       LOG(INFO) << method_map[method].c_str() << " " << url.c_str() << " ["
                 << name_.str() << "] duration: "
-                << std::chrono::duration_cast<std::chrono::microseconds>(end -
-                                                                         start)
-                       .count()
+                << utils::SteadyTime::getDurationUs(start, end).count()
                 << " [usec] " << size << " [bytes]";
     };
 
@@ -106,7 +104,7 @@ class HTTPClientConnection::Implementation
   HTTPClientConnection &setTimeout(const std::chrono::seconds &timeout) {
     timer_->cancel();
     timer_->expires_from_now(timeout);
-    timer_->async_wait([this](std::error_code ec) {
+    timer_->async_wait([this](const std::error_code &ec) {
       if (!ec) {
         consumer_.stop();
       }
@@ -147,18 +145,14 @@ class HTTPClientConnection::Implementation
 
     name_ << ipv6_first_word << ":";
 
-    for (uint16_t *word = (uint16_t *)&locator_hash;
-         std::size_t(word) <
-         (std::size_t(&locator_hash) + sizeof(locator_hash));
-         word++) {
-      name_ << ":" << std::hex << *word;
+    uint16_t *word = (uint16_t *)(&locator_hash);
+    for (std::size_t i = 0; i < sizeof(locator_hash) / 2; i++) {
+      name_ << ":" << std::hex << word[i];
     }
 
-    for (uint16_t *word = (uint16_t *)&request_hash;
-         std::size_t(word) <
-         (std::size_t(&request_hash) + sizeof(request_hash));
-         word++) {
-      name_ << ":" << std::hex << *word;
+    word = (uint16_t *)(&request_hash);
+    for (std::size_t i = 0; i < sizeof(request_hash) / 2; i++) {
+      name_ << ":" << std::hex << word[i];
     }
 
     name_ << "|0";
@@ -199,7 +193,7 @@ class HTTPClientConnection::Implementation
     }
   }
 
-  void readError(const std::error_code ec) noexcept override {
+  void readError(const std::error_code &ec) noexcept override {
     LOG(ERROR) << "Error " << ec.message() << " during download of "
                << current_url_.c_str();
     if (read_bytes_callback_) {
diff --git a/libtransport/src/http/request.cc b/libtransport/src/http/request.cc
index 29118fd88..ad726741a 100644
--- a/libtransport/src/http/request.cc
+++ b/libtransport/src/http/request.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/http/response.cc b/libtransport/src/http/response.cc
index c665fbc5f..727e2c755 100644
--- a/libtransport/src/http/response.cc
+++ b/libtransport/src/http/response.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/implementation/CMakeLists.txt b/libtransport/src/implementation/CMakeLists.txt
index daf899d06..1f2a33a4c 100644
--- a/libtransport/src/implementation/CMakeLists.txt
+++ b/libtransport/src/implementation/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/libtransport/src/implementation/p2psecure_socket_consumer.cc b/libtransport/src/implementation/p2psecure_socket_consumer.cc
index 4b14da5d2..6b67a5487 100644
--- a/libtransport/src/implementation/p2psecure_socket_consumer.cc
+++ b/libtransport/src/implementation/p2psecure_socket_consumer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -44,7 +44,7 @@ int readOld(BIO *b, char *buf, int size) {
   if (!socket->something_to_read_) {
     if (!socket->transport_protocol_->isRunning()) {
       socket->network_name_.setSuffix(socket->random_suffix_);
-      socket->ConsumerSocket::asyncConsume(socket->network_name_);
+      socket->ConsumerSocket::consume(socket->network_name_);
     }
 
     if (!socket->something_to_read_) socket->cv_.wait(lck);
@@ -312,36 +312,6 @@ int P2PSecureConsumerSocket::consume(const Name &name) {
     return tls_consumer_->consume((prefix->mapName(name)));
 }
 
-int P2PSecureConsumerSocket::asyncConsume(const Name &name) {
-  if (transport_protocol_->isRunning()) {
-    return CONSUMER_BUSY;
-  }
-
-  if (handshake() != 1) {
-    throw errors::RuntimeException("Unable to perform client handshake");
-  } else {
-    DLOG_IF(INFO, VLOG_IS_ON(2)) << "Handshake performed!";
-  }
-
-  initSessionSocket();
-
-  if (tls_consumer_ == nullptr) {
-    throw errors::RuntimeException("TLS socket does not exist");
-  }
-
-  std::shared_ptr<Name> prefix_name = std::make_shared<Name>(
-      secure_prefix_.family,
-      ip_address_get_buffer(&(secure_prefix_.address), secure_prefix_.family));
-  std::shared_ptr<Prefix> prefix =
-      std::make_shared<Prefix>(*prefix_name, secure_prefix_.len);
-
-  if (payload_ != NULL)
-    return tls_consumer_->asyncConsume((prefix->mapName(name)),
-                                       std::move(payload_));
-  else
-    return tls_consumer_->asyncConsume((prefix->mapName(name)));
-}
-
 void P2PSecureConsumerSocket::registerPrefix(const Prefix &producer_namespace) {
   producer_namespace_ = producer_namespace;
 }
@@ -385,7 +355,7 @@ void P2PSecureConsumerSocket::readBufferAvailable(
   cv_.notify_one();
 }
 
-void P2PSecureConsumerSocket::readError(const std::error_code ec) noexcept {};
+void P2PSecureConsumerSocket::readError(const std::error_code &ec) noexcept {};
 
 void P2PSecureConsumerSocket::readSuccess(std::size_t total_size) noexcept {
   std::unique_lock<std::mutex> lck(this->mtx_);
diff --git a/libtransport/src/implementation/p2psecure_socket_consumer.h b/libtransport/src/implementation/p2psecure_socket_consumer.h
index a35a50352..a5e69f611 100644
--- a/libtransport/src/implementation/p2psecure_socket_consumer.h
+++ b/libtransport/src/implementation/p2psecure_socket_consumer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -48,8 +48,6 @@ class P2PSecureConsumerSocket : public ConsumerSocket,
 
   int consume(const Name &name) override;
 
-  int asyncConsume(const Name &name) override;
-
   void registerPrefix(const Prefix &producer_namespace);
 
   int setSocketOption(
@@ -120,7 +118,7 @@ class P2PSecureConsumerSocket : public ConsumerSocket,
   virtual void readBufferAvailable(
       std::unique_ptr<utils::MemBuf> &&buffer) noexcept override;
 
-  virtual void readError(const std::error_code ec) noexcept override;
+  virtual void readError(const std::error_code &ec) noexcept override;
 
   virtual void readSuccess(std::size_t total_size) noexcept override;
 
diff --git a/libtransport/src/implementation/p2psecure_socket_producer.cc b/libtransport/src/implementation/p2psecure_socket_producer.cc
index 3748001fc..ee78ea53b 100644
--- a/libtransport/src/implementation/p2psecure_socket_producer.cc
+++ b/libtransport/src/implementation/p2psecure_socket_producer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -20,6 +20,7 @@
 #include <interfaces/tls_rtc_socket_producer.h>
 #include <interfaces/tls_socket_producer.h>
 #include <openssl/bio.h>
+#include <openssl/pkcs12.h>
 #include <openssl/rand.h>
 #include <openssl/ssl.h>
 
@@ -41,7 +42,7 @@ P2PSecureProducerSocket::P2PSecureProducerSocket(
 
 P2PSecureProducerSocket::P2PSecureProducerSocket(
     interface::ProducerSocket *producer_socket, bool rtc,
-    const std::shared_ptr<auth::Identity> &identity)
+    std::string &keystore_path, std::string &keystore_pwd)
     : ProducerSocket(producer_socket,
                      ProductionProtocolAlgorithms::BYTE_STREAM),
       rtc_(rtc),
@@ -50,8 +51,16 @@ P2PSecureProducerSocket::P2PSecureProducerSocket(
       map_producers(),
       list_producers() {
   /* Setup SSL context (identity and parameter to use TLS 1.3) */
-  cert_509_ = identity->getCertificate().get();
-  pkey_rsa_ = identity->getPrivateKey().get();
+  FILE *p12file = fopen(keystore_path.c_str(), "r");
+  if (p12file == NULL)
+    throw errors::RuntimeException("impossible open keystore");
+  std::unique_ptr<PKCS12, decltype(&::PKCS12_free)> p12(
+      d2i_PKCS12_fp(p12file, NULL), ::PKCS12_free);
+  // now we parse the file to get the first key and certificate
+  if (1 != PKCS12_parse(p12.get(), keystore_pwd.c_str(), &pkey_rsa_, &cert_509_,
+                        NULL))
+    throw errors::RuntimeException("impossible to get the private key");
+  fclose(p12file);
 
   /* Set the callback so that when an interest is received we catch it and we
    * decrypt the payload before passing it to the application.  */
@@ -133,15 +142,15 @@ uint32_t P2PSecureProducerSocket::produceDatagram(
   // TODO
   throw errors::NotImplementedException();
 
-  if (!rtc_) {
-    throw errors::RuntimeException(
-        "RTC must be the transport protocol to start the production of current "
-        "data. Aborting.");
-  }
+  // if (!rtc_) {
+  //   throw errors::RuntimeException(
+  //       "RTC must be the transport protocol to start the production of
+  //       current " "data. Aborting.");
+  // }
 
-  std::unique_lock<std::mutex> lck(mtx_);
+  // std::unique_lock<std::mutex> lck(mtx_);
 
-  if (list_producers.empty()) cv_.wait(lck);
+  // if (list_producers.empty()) cv_.wait(lck);
 
   // TODO
   // for (auto it = list_producers.cbegin(); it != list_producers.cend(); it++)
@@ -151,7 +160,7 @@ uint32_t P2PSecureProducerSocket::produceDatagram(
   //   rtc_producer->produce(utils::MemBuf::copyBuffer(buffer, buffer_size));
   // }
 
-  return 0;
+  // return 0;
 }
 
 uint32_t P2PSecureProducerSocket::produceStream(
@@ -197,44 +206,6 @@ uint32_t P2PSecureProducerSocket::produceStream(const Name &content_name,
   return segments;
 }
 
-// void P2PSecureProducerSocket::asyncProduce(const Name &content_name,
-//                                            const uint8_t *buf,
-//                                            size_t buffer_size, bool is_last,
-//                                            uint32_t *start_offset) {
-//   if (rtc_) {
-//     throw errors::RuntimeException(
-//         "RTC transport protocol is not compatible with the production of "
-//         "current data. Aborting.");
-//   }
-
-//   std::unique_lock<std::mutex> lck(mtx_);
-//   if (list_producers.empty()) cv_.wait(lck);
-
-//   for (auto it = list_producers.cbegin(); it != list_producers.cend(); it++)
-//   {
-//     (*it)->asyncProduce(content_name, buf, buffer_size, is_last,
-//     start_offset);
-//   }
-// }
-
-void P2PSecureProducerSocket::asyncProduce(
-    Name content_name, std::unique_ptr<utils::MemBuf> &&buffer, bool is_last,
-    uint32_t offset, uint32_t **last_segment) {
-  if (rtc_) {
-    throw errors::RuntimeException(
-        "RTC transport protocol is not compatible with the production of "
-        "current data. Aborting.");
-  }
-
-  std::unique_lock<std::mutex> lck(mtx_);
-  if (list_producers.empty()) cv_.wait(lck);
-
-  for (auto it = list_producers.cbegin(); it != list_producers.cend(); it++) {
-    (*it)->asyncProduce(content_name, buffer->clone(), is_last, offset,
-                        last_segment);
-  }
-}
-
 /* Redefinition of socket options to avoid name hiding */
 int P2PSecureProducerSocket::setSocketOption(
     int socket_option_key, ProducerInterestCallback socket_option_value) {
diff --git a/libtransport/src/implementation/p2psecure_socket_producer.h b/libtransport/src/implementation/p2psecure_socket_producer.h
index f94347258..00f407a75 100644
--- a/libtransport/src/implementation/p2psecure_socket_producer.h
+++ b/libtransport/src/implementation/p2psecure_socket_producer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -15,7 +15,6 @@
 
 #pragma once
 
-#include <hicn/transport/auth/identity.h>
 #include <hicn/transport/auth/signer.h>
 #include <implementation/socket_producer.h>
 // #include <implementation/tls_rtc_socket_producer.h>
@@ -38,9 +37,9 @@ class P2PSecureProducerSocket : public ProducerSocket {
  public:
   explicit P2PSecureProducerSocket(interface::ProducerSocket *producer_socket);
 
-  explicit P2PSecureProducerSocket(
-      interface::ProducerSocket *producer_socket, bool rtc,
-      const std::shared_ptr<auth::Identity> &identity);
+  explicit P2PSecureProducerSocket(interface::ProducerSocket *producer_socket,
+                                   bool rtc, std::string &keystore_path,
+                                   std::string &keystore_pwd);
 
   ~P2PSecureProducerSocket();
 
@@ -56,10 +55,6 @@ class P2PSecureProducerSocket : public ProducerSocket {
                          bool is_last = true,
                          uint32_t start_offset = 0) override;
 
-  void asyncProduce(Name content_name, std::unique_ptr<utils::MemBuf> &&buffer,
-                    bool is_last, uint32_t offset,
-                    uint32_t **last_segment = nullptr) override;
-
   int setSocketOption(int socket_option_key,
                       ProducerInterestCallback socket_option_value) override;
 
diff --git a/libtransport/src/implementation/socket.cc b/libtransport/src/implementation/socket.cc
index 2e21f2bc3..95941da07 100644
--- a/libtransport/src/implementation/socket.cc
+++ b/libtransport/src/implementation/socket.cc
@@ -14,13 +14,42 @@
  */
 
 #include <core/global_configuration.h>
+#include <hicn/transport/interfaces/socket_options_default_values.h>
 #include <implementation/socket.h>
 
 namespace transport {
 namespace implementation {
 
 Socket::Socket(std::shared_ptr<core::Portal> &&portal)
-    : portal_(std::move(portal)), is_async_(false) {}
+    : portal_(std::move(portal)),
+      is_async_(false),
+      packet_format_(interface::default_values::packet_format) {}
+
+int Socket::setSocketOption(int socket_option_key,
+                            hicn_format_t packet_format) {
+  switch (socket_option_key) {
+    case interface::GeneralTransportOptions::PACKET_FORMAT:
+      packet_format_ = packet_format;
+      break;
+    default:
+      return SOCKET_OPTION_NOT_SET;
+  }
+
+  return SOCKET_OPTION_SET;
+}
+
+int Socket::getSocketOption(int socket_option_key,
+                            hicn_format_t &packet_format) {
+  switch (socket_option_key) {
+    case interface::GeneralTransportOptions::PACKET_FORMAT:
+      packet_format = packet_format_;
+      break;
+    default:
+      return SOCKET_OPTION_NOT_GET;
+  }
+
+  return SOCKET_OPTION_GET;
+}
 
 }  // namespace implementation
 }  // namespace transport
\ No newline at end of file
diff --git a/libtransport/src/implementation/socket.h b/libtransport/src/implementation/socket.h
index cf22c03e1..11c9a704d 100644
--- a/libtransport/src/implementation/socket.h
+++ b/libtransport/src/implementation/socket.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -38,7 +38,26 @@ class Socket {
   virtual void connect() = 0;
   virtual bool isRunning() = 0;
 
-  virtual asio::io_service &getIoService() { return portal_->getIoService(); }
+  virtual asio::io_service &getIoService() {
+    return portal_->getThread().getIoService();
+  }
+
+  int setSocketOption(int socket_option_key, hicn_format_t packet_format);
+  int getSocketOption(int socket_option_key, hicn_format_t &packet_format);
+
+  int getSocketOption(int socket_option_key,
+                      std::shared_ptr<core::Portal> &socket_option_value) {
+    switch (socket_option_key) {
+      case interface::GeneralTransportOptions::PORTAL:
+        socket_option_value = portal_;
+        break;
+      default:
+        return SOCKET_OPTION_NOT_GET;
+        ;
+    }
+
+    return SOCKET_OPTION_GET;
+  }
 
  protected:
   Socket(std::shared_ptr<core::Portal> &&portal);
@@ -48,6 +67,7 @@ class Socket {
  protected:
   std::shared_ptr<core::Portal> portal_;
   bool is_async_;
+  hicn_format_t packet_format_;
 };
 
 }  // namespace implementation
diff --git a/libtransport/src/implementation/socket_consumer.h b/libtransport/src/implementation/socket_consumer.h
index e0981af7f..ebdac7f93 100644
--- a/libtransport/src/implementation/socket_consumer.h
+++ b/libtransport/src/implementation/socket_consumer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -20,6 +20,7 @@
 #include <hicn/transport/interfaces/socket_options_default_values.h>
 #include <hicn/transport/interfaces/statistics.h>
 #include <hicn/transport/utils/event_thread.h>
+#include <implementation/socket.h>
 #include <protocols/cbr.h>
 #include <protocols/raaqm.h>
 #include <protocols/rtc/rtc.h>
@@ -38,7 +39,6 @@ class ConsumerSocket : public Socket {
                  std::shared_ptr<core::Portal> &&portal)
       : Socket(std::move(portal)),
         consumer_interface_(consumer),
-        async_downloader_(),
         interest_lifetime_(default_values::interest_lifetime),
         min_window_size_(default_values::min_window_size),
         max_window_size_(default_values::max_window_size),
@@ -56,6 +56,7 @@ class ConsumerSocket : public Socket {
         rate_estimation_observer_(nullptr),
         rate_estimation_batching_parameter_(default_values::batch),
         rate_estimation_choice_(0),
+        max_unverified_delay_(default_values::max_unverified_delay),
         verifier_(std::make_shared<auth::VoidVerifier>()),
         verify_signature_(false),
         reset_window_(false),
@@ -64,41 +65,42 @@ class ConsumerSocket : public Socket {
         on_interest_satisfied_(VOID_HANDLER),
         on_content_object_input_(VOID_HANDLER),
         stats_summary_(VOID_HANDLER),
+        on_fwd_strategy_(VOID_HANDLER),
+        on_rec_strategy_(VOID_HANDLER),
         read_callback_(nullptr),
         timer_interval_milliseconds_(0),
+        recovery_strategy_(RtcTransportRecoveryStrategies::RTX_ONLY),
+        aggregated_data_(false),
+        fec_setting_(""),
         guard_raaqm_params_() {
     switch (protocol) {
       case TransportProtocolAlgorithms::CBR:
         transport_protocol_ =
-            std::make_unique<protocol::CbrTransportProtocol>(this);
+            std::make_shared<protocol::CbrTransportProtocol>(this);
         break;
       case TransportProtocolAlgorithms::RTC:
         transport_protocol_ =
-            std::make_unique<protocol::rtc::RTCTransportProtocol>(this);
+            std::make_shared<protocol::rtc::RTCTransportProtocol>(this);
         break;
       case TransportProtocolAlgorithms::RAAQM:
       default:
         transport_protocol_ =
-            std::make_unique<protocol::RaaqmTransportProtocol>(this);
+            std::make_shared<protocol::RaaqmTransportProtocol>(this);
         break;
     }
   }
 
  public:
   ConsumerSocket(interface::ConsumerSocket *consumer, int protocol)
-      : ConsumerSocket(consumer, protocol, std::make_shared<core::Portal>()) {}
+      : ConsumerSocket(consumer, protocol, core::Portal::createShared()) {}
 
   ConsumerSocket(interface::ConsumerSocket *consumer, int protocol,
-                 asio::io_service &io_service)
-      : ConsumerSocket(consumer, protocol,
-                       std::make_shared<core::Portal>(io_service)) {
+                 ::utils::EventThread &worker)
+      : ConsumerSocket(consumer, protocol, core::Portal::createShared(worker)) {
     is_async_ = true;
   }
 
-  ~ConsumerSocket() {
-    stop();
-    async_downloader_.stop();
-  }
+  ~ConsumerSocket() { stop(); }
 
   interface::ConsumerSocket *getInterface() {
     return consumer_interface_;
@@ -122,18 +124,6 @@ class ConsumerSocket : public Socket {
 
     transport_protocol_->start();
 
-    return is_async_ ? CONSUMER_RUNNING : CONSUMER_FINISHED;
-  }
-
-  virtual int asyncConsume(const Name &name) {
-    if (!async_downloader_.stopped()) {
-      async_downloader_.add([this, name]() {
-        network_name_ = std::move(name);
-        network_name_.setSuffix(0);
-        transport_protocol_->start();
-      });
-    }
-
     return CONSUMER_RUNNING;
   }
 
@@ -149,6 +139,9 @@ class ConsumerSocket : public Socket {
     }
   }
 
+  using Socket::getSocketOption;
+  using Socket::setSocketOption;
+
   virtual int setSocketOption(int socket_option_key,
                               ReadCallback *socket_option_value) {
     // Reschedule the function on the io_service to avoid race condition in
@@ -245,6 +238,10 @@ class ConsumerSocket : public Socket {
         interest_lifetime_ = socket_option_value;
         break;
 
+      case GeneralTransportOptions::MAX_UNVERIFIED_TIME:
+        max_unverified_delay_ = socket_option_value;
+        break;
+
       case RateEstimationOptions::RATE_ESTIMATION_BATCH_PARAMETER:
         if (socket_option_value > 0) {
           rate_estimation_batching_parameter_ = socket_option_value;
@@ -265,6 +262,11 @@ class ConsumerSocket : public Socket {
         timer_interval_milliseconds_ = socket_option_value;
         break;
 
+      case RtcTransportOptions::RECOVERY_STRATEGY:
+        recovery_strategy_ =
+            (RtcTransportRecoveryStrategies)socket_option_value;
+        break;
+
       default:
         return SOCKET_OPTION_NOT_SET;
     }
@@ -328,6 +330,11 @@ class ConsumerSocket : public Socket {
           result = SOCKET_OPTION_SET;
           break;
 
+        case RtcTransportOptions::AGGREGATED_DATA:
+          aggregated_data_ = socket_option_value;
+          result = SOCKET_OPTION_SET;
+          break;
+
         default:
           return result;
       }
@@ -406,36 +413,37 @@ class ConsumerSocket : public Socket {
   int setSocketOption(
       int socket_option_key,
       const std::shared_ptr<auth::Verifier> &socket_option_value) {
-    int result = SOCKET_OPTION_NOT_SET;
     if (!transport_protocol_->isRunning()) {
       switch (socket_option_key) {
         case GeneralTransportOptions::VERIFIER:
           verifier_.reset();
           verifier_ = socket_option_value;
-          result = SOCKET_OPTION_SET;
           break;
         default:
-          return result;
+          return SOCKET_OPTION_NOT_SET;
       }
     }
-
-    return result;
+    return SOCKET_OPTION_SET;
   }
 
   int setSocketOption(int socket_option_key,
                       const std::string &socket_option_value) {
     int result = SOCKET_OPTION_NOT_SET;
-    if (!transport_protocol_->isRunning()) {
-      switch (socket_option_key) {
-        case DataLinkOptions::OUTPUT_INTERFACE:
+    switch (socket_option_key) {
+      case DataLinkOptions::OUTPUT_INTERFACE:
+        if (!transport_protocol_->isRunning()) {
           output_interface_ = socket_option_value;
           portal_->setOutputInterface(output_interface_);
           result = SOCKET_OPTION_SET;
-          break;
+        }
+        break;
+      case GeneralTransportOptions::FEC_TYPE:
+        fec_setting_ = socket_option_value;
+        result = SOCKET_OPTION_SET;
+        break;
 
-        default:
-          return result;
-      }
+      default:
+        return result;
     }
     return result;
   }
@@ -461,6 +469,29 @@ class ConsumerSocket : public Socket {
         });
   }
 
+  int setSocketOption(int socket_option_key,
+                      StrategyCallback socket_option_value) {
+    // Reschedule the function on the io_service to avoid race condition in
+    // case setSocketOption is called while the io_service is running.
+    return rescheduleOnIOService(
+        socket_option_key, socket_option_value,
+        [this](int socket_option_key,
+               StrategyCallback socket_option_value) -> int {
+          switch (socket_option_key) {
+            case ConsumerCallbacksOptions::FWD_STRATEGY_CHANGE:
+              on_fwd_strategy_ = socket_option_value;
+              break;
+            case ConsumerCallbacksOptions::REC_STRATEGY_CHANGE:
+              on_rec_strategy_ = socket_option_value;
+              break;
+            default:
+              return SOCKET_OPTION_NOT_SET;
+          }
+
+          return SOCKET_OPTION_SET;
+        });
+  }
+
   int getSocketOption(int socket_option_key, double &socket_option_value) {
     utils::SpinLock::Acquire locked(guard_raaqm_params_);
     switch (socket_option_key) {
@@ -516,6 +547,10 @@ class ConsumerSocket : public Socket {
         socket_option_value = interest_lifetime_;
         break;
 
+      case GeneralTransportOptions::MAX_UNVERIFIED_TIME:
+        socket_option_value = max_unverified_delay_;
+        break;
+
       case RaaqmTransportOptions::SAMPLE_NUMBER:
         socket_option_value = sample_number_;
         break;
@@ -532,6 +567,10 @@ class ConsumerSocket : public Socket {
         socket_option_value = timer_interval_milliseconds_;
         break;
 
+      case RtcTransportOptions::RECOVERY_STRATEGY:
+        socket_option_value = recovery_strategy_;
+        break;
+
       default:
         return SOCKET_OPTION_NOT_GET;
     }
@@ -553,6 +592,10 @@ class ConsumerSocket : public Socket {
         socket_option_value = reset_window_;
         break;
 
+      case RtcTransportOptions::AGGREGATED_DATA:
+        socket_option_value = aggregated_data_;
+        break;
+
       default:
         return SOCKET_OPTION_NOT_GET;
     }
@@ -628,20 +671,6 @@ class ConsumerSocket : public Socket {
   }
 
   int getSocketOption(int socket_option_key,
-                      std::shared_ptr<core::Portal> &socket_option_value) {
-    switch (socket_option_key) {
-      case PORTAL:
-        socket_option_value = portal_;
-        break;
-
-      default:
-        return SOCKET_OPTION_NOT_GET;
-    }
-
-    return SOCKET_OPTION_GET;
-  }
-
-  int getSocketOption(int socket_option_key,
                       IcnObserver **socket_option_value) {
     utils::SpinLock::Acquire locked(guard_raaqm_params_);
     switch (socket_option_key) {
@@ -665,7 +694,6 @@ class ConsumerSocket : public Socket {
       default:
         return SOCKET_OPTION_NOT_GET;
     }
-
     return SOCKET_OPTION_GET;
   }
 
@@ -674,6 +702,9 @@ class ConsumerSocket : public Socket {
       case DataLinkOptions::OUTPUT_INTERFACE:
         socket_option_value = output_interface_;
         break;
+      case GeneralTransportOptions::FEC_TYPE:
+        socket_option_value = fec_setting_;
+        break;
       default:
         return SOCKET_OPTION_NOT_GET;
     }
@@ -714,6 +745,29 @@ class ConsumerSocket : public Socket {
         });
   }
 
+  int getSocketOption(int socket_option_key,
+                      StrategyCallback **socket_option_value) {
+    // Reschedule the function on the io_service to avoid race condition in
+    // case setSocketOption is called while the io_service is running.
+    return rescheduleOnIOService(
+        socket_option_key, socket_option_value,
+        [this](int socket_option_key,
+               StrategyCallback **socket_option_value) -> int {
+          switch (socket_option_key) {
+            case ConsumerCallbacksOptions::FWD_STRATEGY_CHANGE:
+              *socket_option_value = &on_fwd_strategy_;
+              break;
+            case ConsumerCallbacksOptions::REC_STRATEGY_CHANGE:
+              *socket_option_value = &on_rec_strategy_;
+              break;
+            default:
+              return SOCKET_OPTION_NOT_GET;
+          }
+
+          return SOCKET_OPTION_GET;
+        });
+  }
+
  protected:
   template <typename Lambda, typename arg2>
   int rescheduleOnIOService(int socket_option_key, arg2 socket_option_value,
@@ -726,9 +780,9 @@ class ConsumerSocket : public Socket {
       /* Condition variable for the wait */
       std::condition_variable cv;
       bool done = false;
-      portal_->getIoService().dispatch([&socket_option_key,
-                                        &socket_option_value, &mtx, &cv,
-                                        &result, &done, &func]() {
+      portal_->getThread().tryRunHandlerNow([&socket_option_key,
+                                             &socket_option_value, &mtx, &cv,
+                                             &result, &done, &func]() {
         std::unique_lock<std::mutex> lck(mtx);
         done = true;
         result = func(socket_option_key, socket_option_value);
@@ -748,8 +802,6 @@ class ConsumerSocket : public Socket {
  protected:
   interface::ConsumerSocket *consumer_interface_;
 
-  utils::EventThread async_downloader_;
-
   // No need to protect from multiple accesses in the async consumer
   // The parameter is accessible only with a getSocketOption and
   // set from the consume
@@ -776,6 +828,7 @@ class ConsumerSocket : public Socket {
   int rate_estimation_choice_;
 
   // Verification parameters
+  int max_unverified_delay_;
   std::shared_ptr<auth::Verifier> verifier_;
   transport::auth::KeyId *key_id_;
   std::atomic_bool verify_signature_;
@@ -787,17 +840,26 @@ class ConsumerSocket : public Socket {
   ConsumerInterestCallback on_interest_satisfied_;
   ConsumerContentObjectCallback on_content_object_input_;
   ConsumerTimerCallback stats_summary_;
+  StrategyCallback on_fwd_strategy_;
+  StrategyCallback on_rec_strategy_;
 
   ReadCallback *read_callback_;
 
   uint32_t timer_interval_milliseconds_;
 
   // Transport protocol
-  std::unique_ptr<protocol::TransportProtocol> transport_protocol_;
+  std::shared_ptr<protocol::TransportProtocol> transport_protocol_;
 
   // Statistic
   TransportStatistics stats_;
 
+  // RTC protocol
+  RtcTransportRecoveryStrategies recovery_strategy_;
+  bool aggregated_data_;
+
+  // FEC setting
+  std::string fec_setting_;
+
   utils::SpinLock guard_raaqm_params_;
   std::string output_interface_;
 };
diff --git a/libtransport/src/implementation/socket_producer.h b/libtransport/src/implementation/socket_producer.h
index 9daf79b9d..37151d497 100644
--- a/libtransport/src/implementation/socket_producer.h
+++ b/libtransport/src/implementation/socket_producer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -40,6 +40,7 @@ namespace implementation {
 
 using namespace core;
 using namespace interface;
+using ProducerCallback = interface::ProducerSocket::Callback;
 
 class ProducerSocket : public Socket {
  private:
@@ -48,11 +49,14 @@ class ProducerSocket : public Socket {
       : Socket(std::move(portal)),
         producer_interface_(producer_socket),
         data_packet_size_(default_values::content_object_packet_size),
+        max_segment_size_(default_values::content_object_packet_size),
         content_object_expiry_time_(default_values::content_object_expiry_time),
-        async_thread_(),
-        making_manifest_(false),
+        making_manifest_(default_values::manifest_capacity),
         hash_algorithm_(auth::CryptoHashType::SHA256),
-        suffix_strategy_(core::NextSegmentCalculationStrategy::INCREMENTAL),
+        signer_(std::make_shared<auth::VoidSigner>()),
+        suffix_strategy_(std::make_shared<utils::IncrementalSuffixStrategy>(0)),
+        aggregated_data_(false),
+        fec_setting_(""),
         on_interest_input_(VOID_HANDLER),
         on_interest_dropped_input_buffer_(VOID_HANDLER),
         on_interest_inserted_input_buffer_(VOID_HANDLER),
@@ -63,29 +67,30 @@ class ProducerSocket : public Socket {
         on_content_object_in_output_buffer_(VOID_HANDLER),
         on_content_object_output_(VOID_HANDLER),
         on_content_object_evicted_from_output_buffer_(VOID_HANDLER),
-        on_content_produced_(VOID_HANDLER) {
+        on_content_produced_(VOID_HANDLER),
+        application_callback_(nullptr) {
     switch (protocol) {
       case ProductionProtocolAlgorithms::RTC_PROD:
         production_protocol_ =
-            std::make_unique<protocol::RTCProductionProtocol>(this);
+            std::make_shared<protocol::RTCProductionProtocol>(this);
         break;
       case ProductionProtocolAlgorithms::BYTE_STREAM:
       default:
         production_protocol_ =
-            std::make_unique<protocol::ByteStreamProductionProtocol>(this);
+            std::make_shared<protocol::ByteStreamProductionProtocol>(this);
         break;
     }
   }
 
  public:
   ProducerSocket(interface::ProducerSocket *producer, int protocol)
-      : ProducerSocket(producer, protocol, std::make_shared<core::Portal>()) {}
+      : ProducerSocket(producer, protocol, core::Portal::createShared()) {
+    is_async_ = true;
+  }
 
   ProducerSocket(interface::ProducerSocket *producer, int protocol,
-                 asio::io_service &io_service)
-      : ProducerSocket(producer, protocol,
-                       std::make_shared<core::Portal>(io_service)) {
-    is_async_ = true;
+                 ::utils::EventThread &worker)
+      : ProducerSocket(producer, protocol, core::Portal::createShared(worker)) {
   }
 
   virtual ~ProducerSocket() {}
@@ -98,31 +103,9 @@ class ProducerSocket : public Socket {
     producer_interface_ = producer_socket;
   }
 
-  void connect() override {
-    portal_->connect(false);
-    production_protocol_->start();
-  }
-
-  bool isRunning() override { return !production_protocol_->isRunning(); };
+  void connect() override { portal_->connect(false); }
 
-  virtual void asyncProduce(Name content_name,
-                            std::unique_ptr<utils::MemBuf> &&buffer,
-                            bool is_last, uint32_t offset,
-                            uint32_t **last_segment = nullptr) {
-    if (!async_thread_.stopped()) {
-      auto a = buffer.release();
-      async_thread_.add([this, content_name, a, is_last, offset,
-                         last_segment]() {
-        auto buf = std::unique_ptr<utils::MemBuf>(a);
-        if (last_segment != NULL) {
-          **last_segment = offset + produceStream(content_name, std::move(buf),
-                                                  is_last, offset);
-        } else {
-          produceStream(content_name, std::move(buf), is_last, offset);
-        }
-      });
-    }
-  }
+  bool isRunning() override { return production_protocol_->isRunning(); };
 
   virtual uint32_t produceStream(const Name &content_name,
                                  std::unique_ptr<utils::MemBuf> &&buffer,
@@ -156,12 +139,38 @@ class ProducerSocket : public Socket {
     production_protocol_->produce(content_object);
   }
 
+  void sendMapme() { production_protocol_->sendMapme(); }
+
   void registerPrefix(const Prefix &producer_namespace) {
-    production_protocol_->registerNamespaceWithNetwork(producer_namespace);
+    portal_->registerRoute(producer_namespace);
   }
 
+  void start() { production_protocol_->start(); }
   void stop() { production_protocol_->stop(); }
 
+  using Socket::getSocketOption;
+  using Socket::setSocketOption;
+
+  virtual int setSocketOption(int socket_option_key,
+                              ProducerCallback *socket_option_value) {
+    // Reschedule the function on the io_service to avoid race condition in
+    // case setSocketOption is called while the io_service is running.
+    return rescheduleOnIOService(
+        socket_option_key, socket_option_value,
+        [this](int socket_option_key,
+               ProducerCallback *socket_option_value) -> int {
+          switch (socket_option_key) {
+            case ProducerCallbacksOptions::PRODUCER_CALLBACK:
+              application_callback_ = socket_option_value;
+              break;
+            default:
+              return SOCKET_OPTION_NOT_SET;
+          }
+
+          return SOCKET_OPTION_SET;
+        });
+  }
+
   virtual int setSocketOption(int socket_option_key,
                               uint32_t socket_option_value) {
     switch (socket_option_key) {
@@ -172,6 +181,17 @@ class ProducerSocket : public Socket {
         }
         break;
 
+      case GeneralTransportOptions::MAKE_MANIFEST:
+        making_manifest_ = socket_option_value;
+        break;
+
+      case GeneralTransportOptions::MAX_SEGMENT_SIZE:
+        if (socket_option_value <= default_values::max_content_object_size &&
+            socket_option_value > 0) {
+          max_segment_size_ = socket_option_value;
+        }
+        break;
+
       case GeneralTransportOptions::OUTPUT_BUFFER_SIZE:
         production_protocol_->setOutputBufferSize(socket_option_value);
         break;
@@ -260,8 +280,8 @@ class ProducerSocket : public Socket {
 
   virtual int setSocketOption(int socket_option_key, bool socket_option_value) {
     switch (socket_option_key) {
-      case GeneralTransportOptions::MAKE_MANIFEST:
-        making_manifest_ = socket_option_value;
+      case RtcTransportOptions::AGGREGATED_DATA:
+        aggregated_data_ = socket_option_value;
         break;
 
       default:
@@ -385,7 +405,7 @@ class ProducerSocket : public Socket {
 
   virtual int setSocketOption(
       int socket_option_key,
-      core::NextSegmentCalculationStrategy socket_option_value) {
+      const std::shared_ptr<utils::SuffixStrategy> &socket_option_value) {
     switch (socket_option_key) {
       case GeneralTransportOptions::SUFFIX_STRATEGY:
         suffix_strategy_ = socket_option_value;
@@ -413,9 +433,33 @@ class ProducerSocket : public Socket {
     return SOCKET_OPTION_SET;
   }
 
+  int getSocketOption(int socket_option_key,
+                      ProducerCallback **socket_option_value) {
+    // Reschedule the function on the io_service to avoid race condition in
+    // case setSocketOption is called while the io_service is running.
+    return rescheduleOnIOService(
+        socket_option_key, socket_option_value,
+        [this](int socket_option_key,
+               ProducerCallback **socket_option_value) -> int {
+          switch (socket_option_key) {
+            case ProducerCallbacksOptions::PRODUCER_CALLBACK:
+              *socket_option_value = application_callback_;
+              break;
+            default:
+              return SOCKET_OPTION_NOT_GET;
+          }
+
+          return SOCKET_OPTION_GET;
+        });
+  }
+
   virtual int getSocketOption(int socket_option_key,
                               uint32_t &socket_option_value) {
     switch (socket_option_key) {
+      case GeneralTransportOptions::MAKE_MANIFEST:
+        socket_option_value = making_manifest_;
+        break;
+
       case GeneralTransportOptions::OUTPUT_BUFFER_SIZE:
         socket_option_value = production_protocol_->getOutputBufferSize();
         break;
@@ -424,6 +468,10 @@ class ProducerSocket : public Socket {
         socket_option_value = (uint32_t)data_packet_size_;
         break;
 
+      case GeneralTransportOptions::MAX_SEGMENT_SIZE:
+        socket_option_value = (uint32_t)max_segment_size_;
+        break;
+
       case GeneralTransportOptions::CONTENT_OBJECT_EXPIRY_TIME:
         socket_option_value = content_object_expiry_time_;
         break;
@@ -438,14 +486,14 @@ class ProducerSocket : public Socket {
   virtual int getSocketOption(int socket_option_key,
                               bool &socket_option_value) {
     switch (socket_option_key) {
-      case GeneralTransportOptions::MAKE_MANIFEST:
-        socket_option_value = making_manifest_;
-        break;
-
       case GeneralTransportOptions::ASYNC_MODE:
         socket_option_value = is_async_;
         break;
 
+      case RtcTransportOptions::AGGREGATED_DATA:
+        socket_option_value = aggregated_data_;
+        break;
+
       default:
         return SOCKET_OPTION_NOT_GET;
     }
@@ -547,21 +595,6 @@ class ProducerSocket : public Socket {
         });
   }
 
-  virtual int getSocketOption(
-      int socket_option_key,
-      std::shared_ptr<core::Portal> &socket_option_value) {
-    switch (socket_option_key) {
-      case PORTAL:
-        socket_option_value = portal_;
-        break;
-      default:
-        return SOCKET_OPTION_NOT_GET;
-        ;
-    }
-
-    return SOCKET_OPTION_GET;
-  }
-
   virtual int getSocketOption(int socket_option_key,
                               auth::CryptoHashType &socket_option_value) {
     switch (socket_option_key) {
@@ -577,7 +610,7 @@ class ProducerSocket : public Socket {
 
   virtual int getSocketOption(
       int socket_option_key,
-      core::NextSegmentCalculationStrategy &socket_option_value) {
+      std::shared_ptr<utils::SuffixStrategy> &socket_option_value) {
     switch (socket_option_key) {
       case GeneralTransportOptions::SUFFIX_STRATEGY:
         socket_option_value = suffix_strategy_;
@@ -603,9 +636,31 @@ class ProducerSocket : public Socket {
     return SOCKET_OPTION_GET;
   }
 
+  int getSocketOption(int socket_option_key, std::string &socket_option_value) {
+    switch (socket_option_key) {
+      case GeneralTransportOptions::FEC_TYPE:
+        socket_option_value = fec_setting_;
+        break;
+      default:
+        return SOCKET_OPTION_NOT_GET;
+    }
+
+    return SOCKET_OPTION_GET;
+  }
+
   virtual int setSocketOption(int socket_option_key,
                               const std::string &socket_option_value) {
-    return SOCKET_OPTION_NOT_SET;
+    int result = SOCKET_OPTION_NOT_SET;
+    switch (socket_option_key) {
+      case GeneralTransportOptions::FEC_TYPE:
+        fec_setting_ = socket_option_value;
+        result = SOCKET_OPTION_SET;
+        break;
+
+      default:
+        return result;
+    }
+    return result;
   }
 
   // If the thread calling lambda_func is not the same of io_service, this
@@ -623,9 +678,9 @@ class ProducerSocket : public Socket {
       std::condition_variable cv;
 
       bool done = false;
-      portal_->getIoService().dispatch([&socket_option_key,
-                                        &socket_option_value, &mtx, &cv,
-                                        &result, &done, &func]() {
+      portal_->getThread().tryRunHandlerNow([&socket_option_key,
+                                             &socket_option_value, &mtx, &cv,
+                                             &result, &done, &func]() {
         std::unique_lock<std::mutex> lck(mtx);
         done = true;
         result = func(socket_option_key, socket_option_value);
@@ -655,9 +710,9 @@ class ProducerSocket : public Socket {
       /* Condition variable for the wait */
       std::condition_variable cv;
       bool done = false;
-      portal_->getIoService().dispatch([&socket_option_key,
-                                        &socket_option_value, &mtx, &cv,
-                                        &result, &done, &func]() {
+      portal_->getThread().tryRunHandlerNow([&socket_option_key,
+                                             &socket_option_value, &mtx, &cv,
+                                             &result, &done, &func]() {
         std::unique_lock<std::mutex> lck(mtx);
         done = true;
         result = func(socket_option_key, socket_option_value);
@@ -677,20 +732,24 @@ class ProducerSocket : public Socket {
   // Threads
  protected:
   interface::ProducerSocket *producer_interface_;
-  asio::io_service io_service_;
   std::atomic<size_t> data_packet_size_;
+  std::atomic<size_t> max_segment_size_;
   std::atomic<uint32_t> content_object_expiry_time_;
 
-  utils::EventThread async_thread_;
-
-  std::atomic<bool> making_manifest_;
+  std::atomic<uint32_t> making_manifest_;
   std::atomic<auth::CryptoHashType> hash_algorithm_;
   std::atomic<auth::CryptoSuite> crypto_suite_;
   utils::SpinLock signer_lock_;
   std::shared_ptr<auth::Signer> signer_;
-  core::NextSegmentCalculationStrategy suffix_strategy_;
+  std::shared_ptr<utils::SuffixStrategy> suffix_strategy_;
+
+  std::shared_ptr<protocol::ProductionProtocol> production_protocol_;
 
-  std::unique_ptr<protocol::ProductionProtocol> production_protocol_;
+  // RTC transport
+  bool aggregated_data_;
+
+  // FEC setting
+  std::string fec_setting_;
 
   // callbacks
   ProducerInterestCallback on_interest_input_;
@@ -706,6 +765,8 @@ class ProducerSocket : public Socket {
   ProducerContentObjectCallback on_content_object_evicted_from_output_buffer_;
 
   ProducerContentCallback on_content_produced_;
+
+  ProducerCallback *application_callback_;
 };
 
 }  // namespace implementation
diff --git a/libtransport/src/implementation/tls_rtc_socket_producer.cc b/libtransport/src/implementation/tls_rtc_socket_producer.cc
index db62b10c1..06d613ef0 100644
--- a/libtransport/src/implementation/tls_rtc_socket_producer.cc
+++ b/libtransport/src/implementation/tls_rtc_socket_producer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -90,11 +90,11 @@ int TLSRTCProducerSocket::writeOld(BIO *b, const char *buf, int num) {
   socket = (TLSRTCProducerSocket *)BIO_get_data(b);
 
   if (socket->getHandshakeState() != SERVER_FINISHED && socket->first_) {
-    bool making_manifest = socket->parent_->making_manifest_;
+    uint32_t making_manifest = socket->parent_->making_manifest_;
 
     socket->tls_chunks_--;
     socket->parent_->setSocketOption(GeneralTransportOptions::MAKE_MANIFEST,
-                                     false);
+                                     0U);
     socket->parent_->ProducerSocket::produce(
         socket->name_, (const uint8_t *)buf, num, socket->tls_chunks_ == 0, 0);
     socket->parent_->setSocketOption(GeneralTransportOptions::MAKE_MANIFEST,
diff --git a/libtransport/src/implementation/tls_rtc_socket_producer.h b/libtransport/src/implementation/tls_rtc_socket_producer.h
index 92c657afc..f6dc425e4 100644
--- a/libtransport/src/implementation/tls_rtc_socket_producer.h
+++ b/libtransport/src/implementation/tls_rtc_socket_producer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/implementation/tls_socket_consumer.cc b/libtransport/src/implementation/tls_socket_consumer.cc
index 65472b41d..b368c4b88 100644
--- a/libtransport/src/implementation/tls_socket_consumer.cc
+++ b/libtransport/src/implementation/tls_socket_consumer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -43,7 +43,7 @@ int readOldTLS(BIO *b, char *buf, int size) {
   if (!socket->something_to_read_) {
     if (!socket->transport_protocol_->isRunning()) {
       socket->network_name_.setSuffix(socket->random_suffix_);
-      socket->ConsumerSocket::asyncConsume(socket->network_name_);
+      socket->ConsumerSocket::consume(socket->network_name_);
     }
 
     if (!socket->something_to_read_) socket->cv_.wait(lck);
@@ -284,31 +284,6 @@ int TLSConsumerSocket::download_content(const Name &name) {
   return CONSUMER_FINISHED;
 }
 
-int TLSConsumerSocket::asyncConsume(const Name &name,
-                                    std::unique_ptr<utils::MemBuf> &&buffer) {
-  this->payload_ = std::move(buffer);
-
-  this->ConsumerSocket::setSocketOption(
-      ConsumerCallbacksOptions::INTEREST_OUTPUT,
-      (ConsumerInterestCallback)std::bind(
-          &TLSConsumerSocket::setInterestPayload, this, std::placeholders::_1,
-          std::placeholders::_2));
-
-  return asyncConsume(name);
-}
-
-int TLSConsumerSocket::asyncConsume(const Name &name) {
-  if ((SSL_in_before(this->ssl_) || SSL_in_init(this->ssl_))) {
-    throw errors::RuntimeException("Handshake not performed");
-  }
-
-  if (!async_downloader_tls_.stopped()) {
-    async_downloader_tls_.add([this, name]() { download_content(name); });
-  }
-
-  return CONSUMER_RUNNING;
-}
-
 void TLSConsumerSocket::registerPrefix(const Prefix &producer_namespace) {
   producer_namespace_ = producer_namespace;
 }
@@ -353,7 +328,7 @@ void TLSConsumerSocket::readBufferAvailable(
   cv_.notify_one();
 }
 
-void TLSConsumerSocket::readError(const std::error_code ec) noexcept {}
+void TLSConsumerSocket::readError(const std::error_code &ec) noexcept {}
 
 void TLSConsumerSocket::readSuccess(std::size_t total_size) noexcept {
   std::unique_lock<std::mutex> lck(this->mtx_);
diff --git a/libtransport/src/implementation/tls_socket_consumer.h b/libtransport/src/implementation/tls_socket_consumer.h
index be08ec47d..a74f1ee10 100644
--- a/libtransport/src/implementation/tls_socket_consumer.h
+++ b/libtransport/src/implementation/tls_socket_consumer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -47,9 +47,6 @@ class TLSConsumerSocket : public ConsumerSocket,
   int consume(const Name &name, std::unique_ptr<utils::MemBuf> &&buffer);
   int consume(const Name &name) override;
 
-  int asyncConsume(const Name &name, std::unique_ptr<utils::MemBuf> &&buffer);
-  int asyncConsume(const Name &name) override;
-
   void registerPrefix(const Prefix &producer_namespace);
 
   int setSocketOption(
@@ -100,7 +97,7 @@ class TLSConsumerSocket : public ConsumerSocket,
   virtual void readBufferAvailable(
       std::unique_ptr<utils::MemBuf> &&buffer) noexcept override;
 
-  virtual void readError(const std::error_code ec) noexcept override;
+  virtual void readError(const std::error_code &ec) noexcept override;
 
   virtual void readSuccess(std::size_t total_size) noexcept override;
 
diff --git a/libtransport/src/implementation/tls_socket_producer.cc b/libtransport/src/implementation/tls_socket_producer.cc
index 3992ca45c..47f3b43a6 100644
--- a/libtransport/src/implementation/tls_socket_producer.cc
+++ b/libtransport/src/implementation/tls_socket_producer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -99,12 +99,12 @@ int TLSProducerSocket::writeOld(BIO *b, const char *buf, int num) {
   socket = (TLSProducerSocket *)BIO_get_data(b);
 
   if (socket->getHandshakeState() != SERVER_FINISHED && socket->first_) {
-    bool making_manifest = socket->parent_->making_manifest_;
+    uint32_t making_manifest = socket->parent_->making_manifest_;
 
     //! socket->tls_chunks_ corresponds to is_last
     socket->tls_chunks_--;
     socket->parent_->setSocketOption(GeneralTransportOptions::MAKE_MANIFEST,
-                                     false);
+                                     0U);
     socket->parent_->ProducerSocket::produceStream(
         socket->name_, (const uint8_t *)buf, num, socket->tls_chunks_ == 0,
         socket->last_segment_);
@@ -358,7 +358,7 @@ uint32_t TLSProducerSocket::produceStream(
   }
 
   size_t buf_size = buffer->length();
-  name_ = production_protocol_->getNamespaces().front().mapName(content_name);
+  name_ = portal_->getServedNamespaces().begin()->mapName(content_name);
   tls_chunks_ = to_call_oncontentproduced_ =
       (int)ceil((float)buf_size / (float)SSL3_RT_MAX_PLAIN_LENGTH);
 
@@ -394,8 +394,7 @@ int TLSProducerSocket::addHicnKeyIdCb(SSL *s, unsigned int ext_type,
       << "On addHicnKeyIdCb, for the prefix registration.";
 
   if (ext_type == 100) {
-    auto &prefix =
-        socket->parent_->production_protocol_->getNamespaces().front();
+    auto &prefix = *socket->parent_->portal_->getServedNamespaces().begin();
     const ip_prefix_t &ip_prefix = prefix.toIpPrefixStruct();
     int inet_family = prefix.getAddressFamily();
     uint16_t prefix_len_bits = prefix.getPrefixLength();
diff --git a/libtransport/src/implementation/tls_socket_producer.h b/libtransport/src/implementation/tls_socket_producer.h
index a542a4d9f..0e958b321 100644
--- a/libtransport/src/implementation/tls_socket_producer.h
+++ b/libtransport/src/implementation/tls_socket_producer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/interfaces/CMakeLists.txt b/libtransport/src/interfaces/CMakeLists.txt
index 7ec024fec..0a0603ac8 100644
--- a/libtransport/src/interfaces/CMakeLists.txt
+++ b/libtransport/src/interfaces/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/libtransport/src/interfaces/callbacks.cc b/libtransport/src/interfaces/callbacks.cc
index 6869ac3f7..776b4cbe7 100644
--- a/libtransport/src/interfaces/callbacks.cc
+++ b/libtransport/src/interfaces/callbacks.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/interfaces/p2psecure_socket_consumer.cc b/libtransport/src/interfaces/p2psecure_socket_consumer.cc
index e473a1e2e..e329a50f1 100644
--- a/libtransport/src/interfaces/p2psecure_socket_consumer.cc
+++ b/libtransport/src/interfaces/p2psecure_socket_consumer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/interfaces/p2psecure_socket_producer.cc b/libtransport/src/interfaces/p2psecure_socket_producer.cc
index 10d8a1367..5f98302d0 100644
--- a/libtransport/src/interfaces/p2psecure_socket_producer.cc
+++ b/libtransport/src/interfaces/p2psecure_socket_producer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -23,10 +23,11 @@ P2PSecureProducerSocket::P2PSecureProducerSocket() {
   socket_ = std::make_unique<implementation::P2PSecureProducerSocket>(this);
 }
 
-P2PSecureProducerSocket::P2PSecureProducerSocket(
-    bool rtc, const std::shared_ptr<auth::Identity> &identity) {
-  socket_ = std::make_unique<implementation::P2PSecureProducerSocket>(this, rtc,
-                                                                      identity);
+P2PSecureProducerSocket::P2PSecureProducerSocket(bool rtc,
+                                                 std::string &keystore_path,
+                                                 std::string &keystore_pwd) {
+  socket_ = std::make_unique<implementation::P2PSecureProducerSocket>(
+      this, rtc, keystore_path, keystore_pwd);
 }
 
 }  // namespace interface
diff --git a/libtransport/src/interfaces/portal.cc b/libtransport/src/interfaces/portal.cc
index 9db0621f6..84634a282 100644
--- a/libtransport/src/interfaces/portal.cc
+++ b/libtransport/src/interfaces/portal.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,83 +13,106 @@
  * limitations under the License.
  */
 
+#include <core/portal.h>
 #include <hicn/transport/interfaces/portal.h>
-#include <implementation/socket.h>
 
 namespace transport {
 namespace interface {
 
-Portal::Portal() { implementation_ = new core::Portal(); }
+class Portal::Impl {
+ public:
+  Impl() : portal_(core::Portal::createShared()) {}
+  Impl(::utils::EventThread &worker)
+      : portal_(core::Portal::createShared(worker)) {}
 
-Portal::Portal(asio::io_service &io_service) {
-  implementation_ = new core::Portal(io_service);
-}
+  void registerTransportCallback(TransportCallback *transport_callback) {
+    portal_->registerTransportCallback(transport_callback);
+  }
+
+  void connect(bool is_consumer) { portal_->connect(is_consumer); }
+
+  bool interestIsPending(const core::Name &name) {
+    return portal_->interestIsPending(name);
+  }
+
+  void sendInterest(core::Interest::Ptr &&interest,
+                    OnContentObjectCallback &&on_content_object_callback,
+                    OnInterestTimeoutCallback &&on_interest_timeout_callback) {
+    portal_->sendInterest(std::move(interest),
+                          std::move(on_content_object_callback),
+                          std::move(on_interest_timeout_callback));
+  }
+
+  void sendContentObject(core::ContentObject &content_object) {
+    portal_->sendContentObject(content_object);
+  }
+
+  void killConnection() { portal_->killConnection(); }
+
+  void clear() { portal_->clear(); }
 
-Portal::~Portal() { delete reinterpret_cast<core::Portal *>(implementation_); }
+  utils::EventThread &getThread() { return portal_->getThread(); }
 
-void Portal::setConsumerCallback(ConsumerCallback *consumer_callback) {
-  reinterpret_cast<core::Portal *>(implementation_)
-      ->setConsumerCallback(consumer_callback);
+  void registerRoute(core::Prefix &prefix) { portal_->registerRoute(prefix); }
+
+  void sendMapme() { portal_->sendMapme(); }
+
+  void setForwardingStrategy(core::Prefix &prefix, std::string &strategy) {
+    portal_->setForwardingStrategy(prefix, strategy);
+  }
+
+ private:
+  std::shared_ptr<core::Portal> portal_;
+};
+
+Portal::Portal() { implementation_ = new Impl(); }
+
+Portal::Portal(::utils::EventThread &worker) {
+  implementation_ = new Impl(worker);
 }
 
-void Portal::setProducerCallback(ProducerCallback *producer_callback) {
-  reinterpret_cast<core::Portal *>(implementation_)
-      ->setProducerCallback(producer_callback);
+Portal::~Portal() { delete implementation_; }
+
+void Portal::registerTransportCallback(TransportCallback *transport_callback) {
+  implementation_->registerTransportCallback(transport_callback);
 }
 
 void Portal::connect(bool is_consumer) {
-  reinterpret_cast<core::Portal *>(implementation_)->connect(is_consumer);
+  implementation_->connect(is_consumer);
 }
 
 bool Portal::interestIsPending(const core::Name &name) {
-  return reinterpret_cast<core::Portal *>(implementation_)
-      ->interestIsPending(name);
+  return implementation_->interestIsPending(name);
 }
 
 void Portal::sendInterest(
     core::Interest::Ptr &&interest,
     OnContentObjectCallback &&on_content_object_callback,
     OnInterestTimeoutCallback &&on_interest_timeout_callback) {
-  reinterpret_cast<core::Portal *>(implementation_)
-      ->sendInterest(std::move(interest), std::move(on_content_object_callback),
-                     std::move(on_interest_timeout_callback));
-}
-
-void Portal::bind(const BindConfig &config) {
-  reinterpret_cast<core::Portal *>(implementation_)->bind(config);
-}
-
-void Portal::runEventsLoop() {
-  reinterpret_cast<core::Portal *>(implementation_)->runEventsLoop();
-}
-
-void Portal::runOneEvent() {
-  reinterpret_cast<core::Portal *>(implementation_)->runOneEvent();
+  implementation_->sendInterest(std::move(interest),
+                                std::move(on_content_object_callback),
+                                std::move(on_interest_timeout_callback));
 }
 
 void Portal::sendContentObject(core::ContentObject &content_object) {
-  reinterpret_cast<core::Portal *>(implementation_)
-      ->sendContentObject(content_object);
+  implementation_->sendContentObject(content_object);
 }
 
-void Portal::stopEventsLoop() {
-  reinterpret_cast<core::Portal *>(implementation_)->stopEventsLoop();
-}
+void Portal::killConnection() { implementation_->killConnection(); }
 
-void Portal::killConnection() {
-  reinterpret_cast<core::Portal *>(implementation_)->killConnection();
-}
+void Portal::clear() { implementation_->clear(); }
 
-void Portal::clear() {
-  reinterpret_cast<core::Portal *>(implementation_)->clear();
-}
+utils::EventThread &Portal::getThread() { return implementation_->getThread(); }
 
-asio::io_service &Portal::getIoService() {
-  return reinterpret_cast<core::Portal *>(implementation_)->getIoService();
+void Portal::registerRoute(core::Prefix &prefix) {
+  implementation_->registerRoute(prefix);
 }
 
-void Portal::registerRoute(core::Prefix &prefix) {
-  reinterpret_cast<core::Portal *>(implementation_)->registerRoute(prefix);
+void Portal::sendMapme() { implementation_->sendMapme(); }
+
+void Portal::setForwardingStrategy(core::Prefix &prefix,
+                                   std::string &strategy) {
+  implementation_->setForwardingStrategy(prefix, strategy);
 }
 
 }  // namespace interface
diff --git a/libtransport/src/interfaces/socket_consumer.cc b/libtransport/src/interfaces/socket_consumer.cc
index 4eee73cab..747dc0974 100644
--- a/libtransport/src/interfaces/socket_consumer.cc
+++ b/libtransport/src/interfaces/socket_consumer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -23,23 +23,28 @@ ConsumerSocket::ConsumerSocket(int protocol) {
   socket_ = std::make_unique<implementation::ConsumerSocket>(this, protocol);
 }
 
-ConsumerSocket::ConsumerSocket(int protocol, asio::io_service &io_service) {
-  socket_ = std::make_unique<implementation::ConsumerSocket>(this, protocol,
-                                                             io_service);
+ConsumerSocket::ConsumerSocket(int protocol, ::utils::EventThread &worker) {
+  socket_ =
+      std::make_unique<implementation::ConsumerSocket>(this, protocol, worker);
 }
 
 ConsumerSocket::ConsumerSocket() {}
 
-ConsumerSocket::~ConsumerSocket() { socket_->stop(); }
+ConsumerSocket::ConsumerSocket(ConsumerSocket &&other) noexcept
+    : socket_(std::move(other.socket_)) {}
+
+ConsumerSocket::~ConsumerSocket() {
+  if (socket_) {
+    socket_->stop();
+  }
+}
 
 void ConsumerSocket::connect() { socket_->connect(); }
 
 bool ConsumerSocket::isRunning() { return socket_->isRunning(); }
 
-int ConsumerSocket::consume(const Name &name) { return socket_->consume(name); }
-
-int ConsumerSocket::asyncConsume(const Name &name) {
-  return socket_->asyncConsume(name);
+int ConsumerSocket::consume(const Name &name, bool blocking) {
+  return socket_->consume(name);
 }
 
 void ConsumerSocket::stop() { socket_->stop(); }
@@ -111,6 +116,16 @@ int ConsumerSocket::setSocketOption(int socket_option_key,
   return socket_->setSocketOption(socket_option_key, socket_option_value);
 }
 
+int ConsumerSocket::setSocketOption(int socket_option_key,
+                                    StrategyCallback socket_option_value) {
+  return socket_->setSocketOption(socket_option_key, socket_option_value);
+}
+
+int ConsumerSocket::setSocketOption(int socket_option_key,
+                                    Packet::Format socket_option_value) {
+  return socket_->setSocketOption(socket_option_key, socket_option_value);
+}
+
 int ConsumerSocket::getSocketOption(int socket_option_key,
                                     double &socket_option_value) {
   return socket_->getSocketOption(socket_option_key, socket_option_value);
@@ -169,6 +184,16 @@ int ConsumerSocket::getSocketOption(
   return socket_->getSocketOption(socket_option_key, socket_option_value);
 }
 
+int ConsumerSocket::getSocketOption(int socket_option_key,
+                                    StrategyCallback **socket_option_value) {
+  return socket_->getSocketOption(socket_option_key, socket_option_value);
+}
+
+int ConsumerSocket::getSocketOption(int socket_option_key,
+                                    Packet::Format &socket_option_value) {
+  return socket_->getSocketOption(socket_option_key, socket_option_value);
+}
+
 }  // namespace interface
 
 }  // namespace transport
diff --git a/libtransport/src/interfaces/socket_producer.cc b/libtransport/src/interfaces/socket_producer.cc
index b04947dfd..10613c0e1 100644
--- a/libtransport/src/interfaces/socket_producer.cc
+++ b/libtransport/src/interfaces/socket_producer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -33,14 +33,21 @@ ProducerSocket::ProducerSocket(int protocol) {
   socket_ = std::make_unique<implementation::ProducerSocket>(this, protocol);
 }
 
-ProducerSocket::ProducerSocket(int protocol, asio::io_service &io_service) {
-  socket_ = std::make_unique<implementation::ProducerSocket>(this, protocol,
-                                                             io_service);
+ProducerSocket::ProducerSocket(int protocol, ::utils::EventThread &worker) {
+  socket_ =
+      std::make_unique<implementation::ProducerSocket>(this, protocol, worker);
 }
 
+ProducerSocket::ProducerSocket(ProducerSocket &&other) noexcept
+    : socket_(std::move(other.socket_)) {}
+
 ProducerSocket::ProducerSocket(bool) {}
 
-ProducerSocket::~ProducerSocket() { socket_->stop(); }
+ProducerSocket::~ProducerSocket() {
+  if (socket_) {
+    socket_->stop();
+  }
+}
 
 void ProducerSocket::connect() { socket_->connect(); }
 
@@ -76,18 +83,14 @@ void ProducerSocket::produce(ContentObject &content_object) {
   return socket_->produce(content_object);
 }
 
-void ProducerSocket::asyncProduce(Name content_name,
-                                  std::unique_ptr<utils::MemBuf> &&buffer,
-                                  bool is_last, uint32_t offset,
-                                  uint32_t **last_segment) {
-  return socket_->asyncProduce(content_name, std::move(buffer), is_last, offset,
-                               last_segment);
-}
+void ProducerSocket::sendMapme() { return socket_->sendMapme(); }
 
 void ProducerSocket::registerPrefix(const Prefix &producer_namespace) {
   return socket_->registerPrefix(producer_namespace);
 }
 
+void ProducerSocket::start() { return socket_->start(); }
+
 void ProducerSocket::stop() { return socket_->stop(); }
 
 asio::io_service &ProducerSocket::getIoService() {
@@ -95,6 +98,11 @@ asio::io_service &ProducerSocket::getIoService() {
 };
 
 int ProducerSocket::setSocketOption(int socket_option_key,
+                                    Callback *socket_option_value) {
+  return socket_->setSocketOption(socket_option_key, socket_option_value);
+}
+
+int ProducerSocket::setSocketOption(int socket_option_key,
                                     uint32_t socket_option_value) {
   return socket_->setSocketOption(socket_option_key, socket_option_value);
 }
@@ -140,9 +148,14 @@ int ProducerSocket::setSocketOption(
   return socket_->setSocketOption(socket_option_key, socket_option_value);
 }
 
+int ProducerSocket::setSocketOption(int socket_option_key,
+                                    Packet::Format socket_option_value) {
+  return socket_->setSocketOption(socket_option_key, socket_option_value);
+}
+
 int ProducerSocket::getSocketOption(int socket_option_key,
                                     uint32_t &socket_option_value) {
-  return socket_->setSocketOption(socket_option_key, socket_option_value);
+  return socket_->getSocketOption(socket_option_key, socket_option_value);
 }
 
 int ProducerSocket::setSocketOption(int socket_option_key,
@@ -181,6 +194,11 @@ int ProducerSocket::getSocketOption(
   return socket_->getSocketOption(socket_option_key, socket_option_value);
 }
 
+int ProducerSocket::getSocketOption(int socket_option_key,
+                                    Packet::Format &socket_option_value) {
+  return socket_->getSocketOption(socket_option_key, socket_option_value);
+}
+
 }  // namespace interface
 
 }  // namespace transport
diff --git a/libtransport/src/interfaces/tls_rtc_socket_producer.cc b/libtransport/src/interfaces/tls_rtc_socket_producer.cc
index 7326fcbcb..6bf1b011c 100644
--- a/libtransport/src/interfaces/tls_rtc_socket_producer.cc
+++ b/libtransport/src/interfaces/tls_rtc_socket_producer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/interfaces/tls_rtc_socket_producer.h b/libtransport/src/interfaces/tls_rtc_socket_producer.h
index 3ea84095b..b8b6ec298 100644
--- a/libtransport/src/interfaces/tls_rtc_socket_producer.h
+++ b/libtransport/src/interfaces/tls_rtc_socket_producer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/interfaces/tls_socket_consumer.cc b/libtransport/src/interfaces/tls_socket_consumer.cc
index 6c1c535b5..24060d1d8 100644
--- a/libtransport/src/interfaces/tls_socket_consumer.cc
+++ b/libtransport/src/interfaces/tls_socket_consumer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/interfaces/tls_socket_consumer.h b/libtransport/src/interfaces/tls_socket_consumer.h
index 845a9181f..242dc91a5 100644
--- a/libtransport/src/interfaces/tls_socket_consumer.h
+++ b/libtransport/src/interfaces/tls_socket_consumer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/interfaces/tls_socket_producer.cc b/libtransport/src/interfaces/tls_socket_producer.cc
index 037702f72..b2b9e723a 100644
--- a/libtransport/src/interfaces/tls_socket_producer.cc
+++ b/libtransport/src/interfaces/tls_socket_producer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/interfaces/tls_socket_producer.h b/libtransport/src/interfaces/tls_socket_producer.h
index 3c662176a..9b31cb483 100644
--- a/libtransport/src/interfaces/tls_socket_producer.h
+++ b/libtransport/src/interfaces/tls_socket_producer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/io_modules/CMakeLists.txt b/libtransport/src/io_modules/CMakeLists.txt
index 29aec236a..f4143de04 100644
--- a/libtransport/src/io_modules/CMakeLists.txt
+++ b/libtransport/src/io_modules/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,25 +11,69 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
+##############################################################
+# Android case: no submodules
+##############################################################
 if (${CMAKE_SYSTEM_NAME} MATCHES Android)
   list(APPEND SOURCE_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/udp/hicn_forwarder_module.cc
-    ${CMAKE_CURRENT_SOURCE_DIR}/udp/udp_socket_connector.cc
+    ${CMAKE_CURRENT_SOURCE_DIR}/hicn-light-ng/hicn_forwarder_module.cc
   )
 
   list(APPEND HEADER_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/udp/hicn_forwarder_module.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/udp/udp_socket_connector.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/hicn-light-ng/hicn_forwarder_module.h
+  )
+
+  if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+    find_package(Libhicnctrl ${CURRENT_VERSION} REQUIRED NO_MODULE)
+
+    if (DISABLE_SHARED_LIBRARIES)
+      set(LIBTYPE static)
+    else()
+      set(LIBTYPE shared)
+    endif()
+
+    list(APPEND LIBHICNCTRL_LIBRARIES hicn::hicnctrl.${LIBTYPE})
+  else()
+    if (DISABLE_SHARED_LIBRARIES)
+      if (WIN32)
+        set(LIBHICNCTRL_LIBRARIES ${LIBHICNCTRL_STATIC})
+      else ()
+        set(LIBHICNCTRL_LIBRARIES ${LIBHICNCTRL_STATIC} log)
+      endif ()
+      list(APPEND DEPENDENCIES
+        ${LIBHICNCTRL_STATIC}
+      )
+    else()
+      set(LIBHICNCTRL_LIBRARIES ${LIBHICNCTRL_SHARED})
+      list(APPEND DEPENDENCIES
+        ${LIBHICNCTRL_SHARED}
+      )
+    endif()
+  endif()
+
+  list(APPEND LIBRARIES
+    PRIVATE ${LIBHICNCTRL_LIBRARIES}
+  )
+
+  list(APPEND LIBTRANSPORT_INTERNAL_INCLUDE_DIRS
+    PUBLIC
+      $<BUILD_INTERFACE:${LIBHICNCTRL_INCLUDE_DIRS}>
   )
 
   set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
   set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
+  set(LIBRARIES ${LIBRARIES} PARENT_SCOPE)
+  set(LIBTRANSPORT_INTERNAL_INCLUDE_DIRS ${LIBTRANSPORT_INTERNAL_INCLUDE_DIRS} PARENT_SCOPE)
 else()
-  add_subdirectory(udp)
+##############################################################
+# Compile submodules
+##############################################################
+  add_subdirectory(hicn-light-ng)
   add_subdirectory(loopback)
   add_subdirectory(forwarder)
 
   if (__vpp__)
     add_subdirectory(memif)
   endif()
-endif()
\ No newline at end of file
+endif()
diff --git a/libtransport/src/io_modules/forwarder/CMakeLists.txt b/libtransport/src/io_modules/forwarder/CMakeLists.txt
index a1d0c5db5..3922316d3 100644
--- a/libtransport/src/io_modules/forwarder/CMakeLists.txt
+++ b/libtransport/src/io_modules/forwarder/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -17,8 +17,6 @@ list(APPEND MODULE_HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/errors.h
   ${CMAKE_CURRENT_SOURCE_DIR}/forwarder_module.h
   ${CMAKE_CURRENT_SOURCE_DIR}/forwarder.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/udp_tunnel_listener.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/udp_tunnel.h
   ${CMAKE_CURRENT_SOURCE_DIR}/global_counter.h
 )
 
@@ -26,16 +24,13 @@ list(APPEND MODULE_SOURCE_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/errors.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/forwarder_module.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/forwarder.cc
-  ${CMAKE_CURRENT_SOURCE_DIR}/udp_tunnel_listener.cc
-  ${CMAKE_CURRENT_SOURCE_DIR}/udp_tunnel.cc
 )
 
 build_module(forwarder_module
-    SHARED
     SOURCES ${MODULE_SOURCE_FILES}
     DEPENDS ${DEPENDENCIES}
     COMPONENT ${LIBTRANSPORT_COMPONENT}-io-modules
-    INCLUDE_DIRS ${LIBTRANSPORT_INCLUDE_DIRS} ${LIBTRANSPORT_INTERNAL_INCLUDE_DIRS}
+    INCLUDE_DIRS ${LIBTRANSPORT_INTERNAL_INCLUDE_DIRS} ${Libhicn_INCLUDE_DIRS}
     DEFINITIONS ${COMPILER_DEFINITIONS}
-    COMPILE_OPTIONS ${COMPILE_FLAGS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS}
 )
diff --git a/libtransport/src/io_modules/forwarder/errors.cc b/libtransport/src/io_modules/forwarder/errors.cc
index b5f131499..6e93d0453 100644
--- a/libtransport/src/io_modules/forwarder/errors.cc
+++ b/libtransport/src/io_modules/forwarder/errors.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  */
 
 #include <io_modules/forwarder/errors.h>
diff --git a/libtransport/src/io_modules/forwarder/forwarder.cc b/libtransport/src/io_modules/forwarder/forwarder.cc
index 0546cb8b3..3ae5bf397 100644
--- a/libtransport/src/io_modules/forwarder/forwarder.cc
+++ b/libtransport/src/io_modules/forwarder/forwarder.cc
@@ -15,11 +15,11 @@
 
 #include <core/global_configuration.h>
 #include <core/local_connector.h>
+#include <core/udp_connector.h>
+#include <core/udp_listener.h>
 #include <glog/logging.h>
 #include <io_modules/forwarder/forwarder.h>
 #include <io_modules/forwarder/global_id_counter.h>
-#include <io_modules/forwarder/udp_tunnel.h>
-#include <io_modules/forwarder/udp_tunnel_listener.h>
 
 namespace transport {
 
@@ -89,11 +89,12 @@ void Forwarder::initConnectors() {
 Connector::Id Forwarder::registerLocalConnector(
     asio::io_service &io_service,
     Connector::PacketReceivedCallback &&receive_callback,
+    Connector::PacketSentCallback &&sent_callback,
     Connector::OnReconnectCallback &&reconnect_callback) {
   utils::SpinLock::Acquire locked(connector_lock_);
   auto id = GlobalCounter<Connector::Id>::getInstance().getNext();
   auto connector = std::make_shared<LocalConnector>(
-      io_service, receive_callback, nullptr, nullptr, reconnect_callback);
+      io_service, receive_callback, sent_callback, nullptr, reconnect_callback);
   connector->setConnectorId(id);
   local_connectors_.emplace(id, std::move(connector));
   return id;
@@ -105,6 +106,7 @@ Forwarder &Forwarder::deleteConnector(Connector::Id id) {
   if (it != local_connectors_.end()) {
     it->second->close();
     local_connectors_.erase(it);
+  } else {
   }
 
   return *this;
@@ -120,9 +122,9 @@ Connector::Ptr Forwarder::getConnector(Connector::Id id) {
   return nullptr;
 }
 
-void Forwarder::onPacketFromListener(Connector *connector,
-                                     utils::MemBuf &packet_buffer,
-                                     const std::error_code &ec) {
+void Forwarder::onPacketFromListener(
+    Connector *connector, const std::vector<utils::MemBuf::Ptr> &packets,
+    const std::error_code &ec) {
   // Create connector
   connector->setReceiveCallback(
       std::bind(&Forwarder::onPacketReceived, this, std::placeholders::_1,
@@ -135,37 +137,47 @@ void Forwarder::onPacketFromListener(Connector *connector,
     remote_connectors_.emplace(connector->getConnectorId(),
                                connector->shared_from_this());
   }
+
   // TODO Check if control packet or not. For the moment it is not.
-  onPacketReceived(connector, packet_buffer, ec);
+  onPacketReceived(connector, packets, ec);
 }
 
 void Forwarder::onPacketReceived(Connector *connector,
-                                 utils::MemBuf &packet_buffer,
+                                 const std::vector<utils::MemBuf::Ptr> &packets,
                                  const std::error_code &ec) {
-  // Figure out the type of packet we received
-  bool is_interest = Packet::isInterest(packet_buffer.data());
-
-  Packet *packet = nullptr;
-  if (is_interest) {
-    packet = static_cast<Interest *>(&packet_buffer);
-  } else {
-    packet = static_cast<ContentObject *>(&packet_buffer);
+  if (ec) {
+    LOG(ERROR) << "Error receiving packet: " << ec.message();
+    return;
   }
 
-  for (auto &c : local_connectors_) {
-    auto role = c.second->getRole();
-    auto is_producer = role == Connector::Role::PRODUCER;
-    if ((is_producer && is_interest) || (!is_producer && !is_interest)) {
-      c.second->send(*packet);
+  for (auto &packet_buffer_ptr : packets) {
+    auto &packet_buffer = *packet_buffer_ptr;
+
+    // Figure out the type of packet we received
+    bool is_interest = Packet::isInterest(packet_buffer.data());
+
+    Packet *packet = nullptr;
+    if (is_interest) {
+      packet = static_cast<Interest *>(&packet_buffer);
     } else {
-      LOG(ERROR) << "Error sending packet to local connector. is_interest = "
-                 << is_interest << " - is_producer = " << is_producer;
+      packet = static_cast<ContentObject *>(&packet_buffer);
+    }
+
+    for (auto &c : local_connectors_) {
+      auto role = c.second->getRole();
+      auto is_producer = role == Connector::Role::PRODUCER;
+      if ((is_producer && is_interest) || (!is_producer && !is_interest)) {
+        c.second->send(*packet);
+      } else {
+        LOG(ERROR) << "Error sending packet to local connector. is_interest = "
+                   << is_interest << " - is_producer = " << is_producer;
+      }
     }
-  }
 
-  // PCS Lookup + FIB lookup. Skip for now
+    // PCS Lookup + FIB lookup. Skip for now
 
-  // Forward packet to local connectors
+    // Forward packet to local connectors
+  }
 }
 
 void Forwarder::send(Packet &packet) {
diff --git a/libtransport/src/io_modules/forwarder/forwarder.h b/libtransport/src/io_modules/forwarder/forwarder.h
index 5b564bb5e..38b4260b3 100644
--- a/libtransport/src/io_modules/forwarder/forwarder.h
+++ b/libtransport/src/io_modules/forwarder/forwarder.h
@@ -15,13 +15,13 @@
 
 #pragma once
 
+#include <core/udp_listener.h>
 #include <hicn/transport/core/io_module.h>
 #include <hicn/transport/core/prefix.h>
 #include <hicn/transport/utils/event_thread.h>
 #include <hicn/transport/utils/singleton.h>
 #include <hicn/transport/utils/spinlock.h>
 #include <io_modules/forwarder/configuration.h>
-#include <io_modules/forwarder/udp_tunnel_listener.h>
 
 #include <atomic>
 #include <libconfig.h++>
@@ -31,9 +31,8 @@ namespace transport {
 
 namespace core {
 
-class Forwarder : public utils::Singleton<Forwarder> {
+class Forwarder {
   static constexpr char forwarder_config_section[] = "forwarder";
-  friend class utils::Singleton<Forwarder>;
 
  public:
   Forwarder();
@@ -47,6 +46,7 @@ class Forwarder : public utils::Singleton<Forwarder> {
   Connector::Id registerLocalConnector(
       asio::io_service &io_service,
       Connector::PacketReceivedCallback &&receive_callback,
+      Connector::PacketSentCallback &&sent_callback,
       Connector::OnReconnectCallback &&reconnect_callback);
 
   Forwarder &deleteConnector(Connector::Id id);
@@ -58,9 +58,11 @@ class Forwarder : public utils::Singleton<Forwarder> {
   void stop();
 
  private:
-  void onPacketFromListener(Connector *connector, utils::MemBuf &packet_buffer,
+  void onPacketFromListener(Connector *connector,
+                            const std::vector<utils::MemBuf::Ptr> &packets,
                             const std::error_code &ec);
-  void onPacketReceived(Connector *connector, utils::MemBuf &packet_buffer,
+  void onPacketReceived(Connector *connector,
+                        const std::vector<utils::MemBuf::Ptr> &packets,
                         const std::error_code &ec);
   void onPacketSent(Connector *connector, const std::error_code &ec);
   void onConnectorClosed(Connector *connector);
@@ -86,5 +88,20 @@ class Forwarder : public utils::Singleton<Forwarder> {
   Configuration config_;
 };
 
+class ForwarderGlobal : public ::utils::Singleton<ForwarderGlobal> {
+  friend class utils::Singleton<ForwarderGlobal>;
+
+ public:
+  ~ForwarderGlobal() {}
+  std::shared_ptr<Forwarder> &getReference() { return forwarder_; }
+
+ private:
+  ForwarderGlobal() : forwarder_(std::make_shared<Forwarder>()) {}
+
+ private:
+  std::shared_ptr<Forwarder> forwarder_;
+};
+
 }  // namespace core
-}  // namespace transport
\ No newline at end of file
+
+}  // namespace transport
diff --git a/libtransport/src/io_modules/forwarder/forwarder_module.cc b/libtransport/src/io_modules/forwarder/forwarder_module.cc
index 4f95b9ca0..0ced84ab4 100644
--- a/libtransport/src/io_modules/forwarder/forwarder_module.cc
+++ b/libtransport/src/io_modules/forwarder/forwarder_module.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,11 +25,10 @@ ForwarderModule::ForwarderModule()
     : IoModule(),
       name_(""),
       connector_id_(Connector::invalid_connector),
-      forwarder_(Forwarder::getInstance()) {}
+      forwarder_ptr_(ForwarderGlobal::getInstance().getReference()),
+      forwarder_(*forwarder_ptr_) {}
 
-ForwarderModule::~ForwarderModule() {
-  forwarder_.deleteConnector(connector_id_);
-}
+ForwarderModule::~ForwarderModule() {}
 
 bool ForwarderModule::isConnected() { return true; }
 
@@ -42,7 +41,7 @@ void ForwarderModule::send(Packet &packet) {
   // local_faces_.at(1 - local_id_).onPacket(packet);
 }
 
-void ForwarderModule::send(const uint8_t *packet, std::size_t len) {
+void ForwarderModule::send(const utils::MemBuf::Ptr &buffer) {
   // not supported
   throw errors::NotImplementedException();
 }
@@ -58,11 +57,13 @@ void ForwarderModule::closeConnection() {
 }
 
 void ForwarderModule::init(Connector::PacketReceivedCallback &&receive_callback,
+                           Connector::PacketSentCallback &&sent_callback,
                            Connector::OnReconnectCallback &&reconnect_callback,
                            asio::io_service &io_service,
                            const std::string &app_name) {
   connector_id_ = forwarder_.registerLocalConnector(
-      io_service, std::move(receive_callback), std::move(reconnect_callback));
+      io_service, std::move(receive_callback), std::move(sent_callback),
+      std::move(reconnect_callback));
   name_ = app_name;
 }
 
@@ -78,7 +79,9 @@ void ForwarderModule::connect(bool is_consumer) {
 
 std::uint32_t ForwarderModule::getMtu() { return interface_mtu; }
 
-bool ForwarderModule::isControlMessage(const uint8_t *message) { return false; }
+bool ForwarderModule::isControlMessage(utils::MemBuf &packet_buffer) {
+  return false;
+}
 
 extern "C" IoModule *create_module(void) { return new ForwarderModule(); }
 
diff --git a/libtransport/src/io_modules/forwarder/forwarder_module.h b/libtransport/src/io_modules/forwarder/forwarder_module.h
index 58bfb7996..52a12b67e 100644
--- a/libtransport/src/io_modules/forwarder/forwarder_module.h
+++ b/libtransport/src/io_modules/forwarder/forwarder_module.h
@@ -38,11 +38,12 @@ class ForwarderModule : public IoModule {
   void connect(bool is_consumer) override;
 
   void send(Packet &packet) override;
-  void send(const uint8_t *packet, std::size_t len) override;
+  void send(const utils::MemBuf::Ptr &buffer) override;
 
   bool isConnected() override;
 
   void init(Connector::PacketReceivedCallback &&receive_callback,
+            Connector::PacketSentCallback &&sent_callback,
             Connector::OnReconnectCallback &&reconnect_callback,
             asio::io_service &io_service,
             const std::string &app_name = "Libtransport") override;
@@ -51,15 +52,19 @@ class ForwarderModule : public IoModule {
 
   std::uint32_t getMtu() override;
 
-  bool isControlMessage(const uint8_t *message) override;
+  bool isControlMessage(utils::MemBuf &packet_buffer) override;
 
   void processControlMessageReply(utils::MemBuf &packet_buffer) override;
 
   void closeConnection() override;
 
  private:
+  static void initForwarder();
+
+ private:
   std::string name_;
   Connector::Id connector_id_;
+  std::shared_ptr<Forwarder> forwarder_ptr_;
   Forwarder &forwarder_;
 };
 
diff --git a/libtransport/src/io_modules/forwarder/udp_tunnel.cc b/libtransport/src/io_modules/forwarder/udp_tunnel.cc
deleted file mode 100644
index bf6a69b92..000000000
--- a/libtransport/src/io_modules/forwarder/udp_tunnel.cc
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
- */
-
-#include <glog/logging.h>
-#include <hicn/transport/utils/branch_prediction.h>
-#include <io_modules/forwarder/errors.h>
-#include <io_modules/forwarder/udp_tunnel.h>
-
-#include <iostream>
-#include <thread>
-#include <vector>
-
-namespace transport {
-namespace core {
-
-UdpTunnelConnector::~UdpTunnelConnector() {}
-
-void UdpTunnelConnector::connect(const std::string &hostname, uint16_t port,
-                                 const std::string &bind_address,
-                                 uint16_t bind_port) {
-  if (state_ == State::CLOSED) {
-    state_ = State::CONNECTING;
-    endpoint_iterator_ = resolver_.resolve({hostname, std::to_string(port)});
-    remote_endpoint_send_ = *endpoint_iterator_;
-    socket_->open(remote_endpoint_send_.protocol());
-
-    if (!bind_address.empty() && bind_port != 0) {
-      using namespace asio::ip;
-      socket_->bind(
-          udp::endpoint(address::from_string(bind_address), bind_port));
-    }
-
-    state_ = State::CONNECTED;
-
-    remote_endpoint_ = Endpoint(remote_endpoint_send_);
-    local_endpoint_ = Endpoint(socket_->local_endpoint());
-
-    doRecvPacket();
-
-#ifdef LINUX
-    send_timer_.expires_from_now(std::chrono::microseconds(50));
-    send_timer_.async_wait(std::bind(&UdpTunnelConnector::writeHandler, this,
-                                     std::placeholders::_1));
-#endif
-  }
-}
-
-void UdpTunnelConnector::send(Packet &packet) {
-  strand_->post([this, pkt{packet.shared_from_this()}]() {
-    bool write_in_progress = !output_buffer_.empty();
-    output_buffer_.push_back(std::move(pkt));
-    if (TRANSPORT_EXPECT_TRUE(state_ == State::CONNECTED)) {
-      if (!write_in_progress) {
-        doSendPacket();
-      }
-    } else {
-      data_available_ = true;
-    }
-  });
-}
-
-void UdpTunnelConnector::send(const uint8_t *packet, std::size_t len) {}
-
-void UdpTunnelConnector::close() {
-  DLOG_IF(INFO, VLOG_IS_ON(2)) << "UDPTunnelConnector::close";
-  state_ = State::CLOSED;
-  bool is_socket_owned = socket_.use_count() == 1;
-  if (is_socket_owned) {
-    io_service_.dispatch([this]() {
-      this->socket_->close();
-      // on_close_callback_(shared_from_this());
-    });
-  }
-}
-
-void UdpTunnelConnector::doSendPacket() {
-#ifdef LINUX
-  send_timer_.expires_from_now(std::chrono::microseconds(50));
-  send_timer_.async_wait(std::bind(&UdpTunnelConnector::writeHandler, this,
-                                   std::placeholders::_1));
-#else
-  auto packet = output_buffer_.front().get();
-  auto array = std::vector<asio::const_buffer>();
-
-  const ::utils::MemBuf *current = packet;
-  do {
-    array.push_back(asio::const_buffer(current->data(), current->length()));
-    current = current->next();
-  } while (current != packet);
-
-  socket_->async_send_to(
-      std::move(array), remote_endpoint_send_,
-      strand_->wrap([this](std::error_code ec, std::size_t length) {
-        if (TRANSPORT_EXPECT_TRUE(!ec)) {
-          sent_callback_(this, make_error_code(forwarder_error::success));
-        } else if (ec.value() ==
-                   static_cast<int>(std::errc::operation_canceled)) {
-          // The connection has been closed by the application.
-          return;
-        } else {
-          sendFailed();
-          sent_callback_(this, ec);
-        }
-
-        output_buffer_.pop_front();
-        if (!output_buffer_.empty()) {
-          doSendPacket();
-        }
-      }));
-#endif
-}
-
-#ifdef LINUX
-void UdpTunnelConnector::writeHandler(std::error_code ec) {
-  if (TRANSPORT_EXPECT_FALSE(state_ != State::CONNECTED)) {
-    return;
-  }
-
-  auto len = std::min(output_buffer_.size(), std::size_t(Connector::max_burst));
-
-  if (len) {
-    int m = 0;
-    for (auto &p : output_buffer_) {
-      auto packet = p.get();
-      ::utils::MemBuf *current = packet;
-      int b = 0;
-      do {
-        // array.push_back(asio::const_buffer(current->data(),
-        // current->length()));
-        tx_iovecs_[m][b].iov_base = current->writableData();
-        tx_iovecs_[m][b].iov_len = current->length();
-        current = current->next();
-        b++;
-      } while (current != packet);
-
-      tx_msgs_[m].msg_hdr.msg_iov = tx_iovecs_[m];
-      tx_msgs_[m].msg_hdr.msg_iovlen = b;
-      tx_msgs_[m].msg_hdr.msg_name = remote_endpoint_send_.data();
-      tx_msgs_[m].msg_hdr.msg_namelen = remote_endpoint_send_.size();
-      m++;
-
-      if (--len == 0) {
-        break;
-      }
-    }
-
-    int retval = sendmmsg(socket_->native_handle(), tx_msgs_, m, MSG_DONTWAIT);
-    if (retval > 0) {
-      while (retval--) {
-        output_buffer_.pop_front();
-      }
-    } else if (retval != EWOULDBLOCK && retval != EAGAIN) {
-      LOG(ERROR) << "Error sending messages! " << strerror(errno)
-                 << " << retval";
-      return;
-    }
-  }
-
-  if (!output_buffer_.empty()) {
-    send_timer_.expires_from_now(std::chrono::microseconds(50));
-    send_timer_.async_wait(std::bind(&UdpTunnelConnector::writeHandler, this,
-                                     std::placeholders::_1));
-  }
-}
-
-void UdpTunnelConnector::readHandler(std::error_code ec) {
-  DLOG_IF(INFO, VLOG_IS_ON(3)) << "UdpTunnelConnector receive packet";
-
-  if (TRANSPORT_EXPECT_TRUE(!ec)) {
-    if (TRANSPORT_EXPECT_TRUE(state_ == State::CONNECTED)) {
-      if (current_position_ == 0) {
-        for (int i = 0; i < max_burst; i++) {
-          auto read_buffer = getRawBuffer();
-          rx_iovecs_[i][0].iov_base = read_buffer.first;
-          rx_iovecs_[i][0].iov_len = read_buffer.second;
-          rx_msgs_[i].msg_hdr.msg_iov = rx_iovecs_[i];
-          rx_msgs_[i].msg_hdr.msg_iovlen = 1;
-        }
-      }
-
-      int res = recvmmsg(socket_->native_handle(), rx_msgs_ + current_position_,
-                         max_burst - current_position_, MSG_DONTWAIT, nullptr);
-      if (res < 0) {
-        LOG(ERROR) << "Error receiving messages! " << strerror(errno) << " "
-                   << res;
-        return;
-      }
-
-      for (int i = 0; i < res; i++) {
-        auto packet = getPacketFromBuffer(
-            reinterpret_cast<uint8_t *>(
-                rx_msgs_[current_position_].msg_hdr.msg_iov[0].iov_base),
-            rx_msgs_[current_position_].msg_len);
-        receiveSuccess(*packet);
-        receive_callback_(this, *packet,
-                          make_error_code(forwarder_error::success));
-        ++current_position_;
-      }
-
-      doRecvPacket();
-    } else {
-      LOG(ERROR)
-          << "Error in UDP: Receiving packets from a not connected socket.";
-    }
-  } else if (ec.value() == static_cast<int>(std::errc::operation_canceled)) {
-    LOG(ERROR) << "The connection has been closed by the application.";
-    return;
-  } else {
-    if (TRANSPORT_EXPECT_TRUE(state_ == State::CONNECTED)) {
-      // receive_callback_(this, *read_msg_, ec);
-      LOG(ERROR) << "Error in UDP connector: " << ec.value() << " "
-                 << ec.message();
-    } else {
-      LOG(ERROR) << "Error in connector while not connected. " << ec.value()
-                 << " " << ec.message();
-    }
-  }
-}
-#endif
-
-void UdpTunnelConnector::doRecvPacket() {
-#ifdef LINUX
-  if (state_ == State::CONNECTED) {
-#if ((ASIO_VERSION / 100 % 1000) < 11)
-    socket_->async_receive(asio::null_buffers(),
-#else
-    socket_->async_wait(asio::ip::tcp::socket::wait_read,
-#endif
-                           std::bind(&UdpTunnelConnector::readHandler, this,
-                                     std::placeholders::_1));
-  }
-#else
-  DLOG_IF(INFO, VLOG_IS_ON(3)) << "UdpTunnelConnector receive packet";
-  read_msg_ = getRawBuffer();
-  socket_->async_receive_from(
-      asio::buffer(read_msg_.first, read_msg_.second), remote_endpoint_recv_,
-      [this](std::error_code ec, std::size_t length) {
-        DLOG_IF(INFO, VLOG_IS_ON(3))
-            << "UdpTunnelConnector received packet length=" << length;
-        if (TRANSPORT_EXPECT_TRUE(!ec)) {
-          if (TRANSPORT_EXPECT_TRUE(state_ == State::CONNECTED)) {
-            auto packet = getPacketFromBuffer(read_msg_.first, length);
-            receiveSuccess(*packet);
-            receive_callback_(this, *packet,
-                              make_error_code(forwarder_error::success));
-            doRecvPacket();
-          } else {
-            LOG(ERROR) << "Error in UDP: Receiving packets from a not "
-                          "connected socket.";
-          }
-        } else if (ec.value() ==
-                   static_cast<int>(std::errc::operation_canceled)) {
-          LOG(ERROR) << "The connection has been closed by the application.";
-          return;
-        } else {
-          if (TRANSPORT_EXPECT_TRUE(state_ == State::CONNECTED)) {
-            LOG(ERROR) << "Error in UDP connector: " << ec.value()
-                       << ec.message();
-          } else {
-            LOG(ERROR) << "Error while not connected";
-          }
-        }
-      });
-#endif
-}
-
-void UdpTunnelConnector::doConnect() {
-  asio::async_connect(
-      *socket_, endpoint_iterator_,
-      [this](std::error_code ec, asio::ip::udp::resolver::iterator) {
-        if (!ec) {
-          state_ = State::CONNECTED;
-          doRecvPacket();
-
-          if (data_available_) {
-            data_available_ = false;
-            doSendPacket();
-          }
-        } else {
-          LOG(ERROR) << "UDP Connection failed!!!";
-          timer_.expires_from_now(std::chrono::milliseconds(500));
-          timer_.async_wait(std::bind(&UdpTunnelConnector::doConnect, this));
-        }
-      });
-}
-
-}  // namespace core
-
-}  // namespace transport
diff --git a/libtransport/src/io_modules/hicn-light-ng/CMakeLists.txt b/libtransport/src/io_modules/hicn-light-ng/CMakeLists.txt
new file mode 100644
index 000000000..325a8bd1d
--- /dev/null
+++ b/libtransport/src/io_modules/hicn-light-ng/CMakeLists.txt
@@ -0,0 +1,62 @@
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+  find_package(Libhicnctrl ${CURRENT_VERSION} REQUIRED NO_MODULE)
+
+  if (DISABLE_SHARED_LIBRARIES)
+    set(LIBTYPE static)
+  else()
+    set(LIBTYPE shared)
+  endif()
+
+  list(APPEND LIBHICNCTRL_LIBRARIES hicn::hicnctrl.${LIBTYPE})
+else()
+  if (DISABLE_SHARED_LIBRARIES)
+    if (WIN32)
+      set(LIBHICNCTRL_LIBRARIES ${LIBHICNCTRL_STATIC})
+    else ()
+      set(LIBHICNCTRL_LIBRARIES ${LIBHICNCTRL_STATIC} log)
+    endif ()
+    list(APPEND DEPENDENCIES
+      ${LIBHICNCTRL_STATIC}
+    )
+  else()
+    set(LIBHICNCTRL_LIBRARIES ${LIBHICNCTRL_SHARED})
+    list(APPEND DEPENDENCIES
+      ${LIBHICNCTRL_SHARED}
+    )
+  endif()
+endif()
+
+list(APPEND MODULE_HEADER_FILES
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_forwarder_module.h
+)
+
+list(APPEND MODULE_SOURCE_FILES
+  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_forwarder_module.cc
+)
+
+build_module(hicnlightng_module
+  SHARED
+  SOURCES ${MODULE_SOURCE_FILES}
+  DEPENDS ${DEPENDENCIES}
+  COMPONENT ${LIBTRANSPORT_COMPONENT}
+  LINK_LIBRARIES PRIVATE ${LIBHICNCTRL_LIBRARIES}
+  INCLUDE_DIRS
+    PRIVATE
+      ${LIBTRANSPORT_INTERNAL_INCLUDE_DIRS}
+      ${Libhicnctrl_INCLUDE_DIRS}
+  DEFINITIONS ${COMPILER_DEFINITIONS}
+  COMPILE_OPTIONS ${COMPILER_OPTIONS}
+)
diff --git a/libtransport/src/io_modules/hicn-light-ng/hicn_forwarder_module.cc b/libtransport/src/io_modules/hicn-light-ng/hicn_forwarder_module.cc
new file mode 100644
index 000000000..f67bd9447
--- /dev/null
+++ b/libtransport/src/io_modules/hicn-light-ng/hicn_forwarder_module.cc
@@ -0,0 +1,264 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <core/udp_connector.h>
+#include <io_modules/hicn-light-ng/hicn_forwarder_module.h>
+
+extern "C" {
+#include <hicn/ctrl/hicn-light-ng.h>
+}
+
+namespace transport {
+
+namespace core {
+
+HicnForwarderModule::HicnForwarderModule()
+    : IoModule(), connector_(nullptr), seq_(0) {}
+
+HicnForwarderModule::~HicnForwarderModule() {}
+
+void HicnForwarderModule::connect(bool is_consumer) {
+  connector_->connect("localhost", 9695);
+  connector_->setRole(is_consumer ? Connector::Role::CONSUMER
+                                  : Connector::Role::PRODUCER);
+}
+
+bool HicnForwarderModule::isConnected() { return connector_->isConnected(); }
+
+void HicnForwarderModule::send(Packet &packet) {
+  IoModule::send(packet);
+  packet.setChecksum();
+  connector_->send(packet);
+}
+
+void HicnForwarderModule::send(const utils::MemBuf::Ptr &packet) {
+  counters_.tx_packets++;
+  counters_.tx_bytes += packet->length();
+
+  // Perfect forwarding
+  connector_->send(packet);
+}
+
+void HicnForwarderModule::registerRoute(const Prefix &prefix) {
+  auto command = createCommandRoute(prefix.toSockaddr(),
+                                    (uint8_t)prefix.getPrefixLength());
+  if (!command) {
+    // TODO error
+    return;
+  }
+  send(command);
+}
+
+void HicnForwarderModule::sendMapme() {
+  auto command = createCommandMapmeSendUpdate();
+  if (!command) {
+    // TODO error
+    return;
+  }
+  send(command);
+}
+
+void HicnForwarderModule::setForwardingStrategy(const Prefix &prefix,
+                                                std::string &strategy) {
+  auto command = createCommandSetForwardingStrategy(
+      prefix.toSockaddr(), (uint8_t)prefix.getPrefixLength(), strategy);
+  if (!command) {
+    // TODO error
+    return;
+  }
+  send(command);
+}
+
+void HicnForwarderModule::closeConnection() {
+  auto command = createCommandDeleteConnection();
+  if (!command) {
+    // TODO error
+    return;
+  }
+
+  connector_->setSentCallback([](Connector *c, const std::error_code &ec) {
+    if (!ec) {
+      c->close();
+    }
+  });
+
+  send(command);
+}
+
+void HicnForwarderModule::init(
+    Connector::PacketReceivedCallback &&receive_callback,
+    Connector::PacketSentCallback &&sent_callback,
+    Connector::OnReconnectCallback &&reconnect_callback,
+    asio::io_service &io_service, const std::string &app_name) {
+  if (!connector_) {
+    connector_.reset(new UdpTunnelConnector(
+        io_service, std::move(receive_callback), std::move(sent_callback),
+        nullptr, std::move(reconnect_callback)));
+  }
+}
+
+void HicnForwarderModule::processControlMessageReply(
+    utils::MemBuf &packet_buffer) {
+  if (packet_buffer.data()[0] == NACK_LIGHT) {
+    throw errors::RuntimeException(
+        "Received Nack message from hicn light forwarder.");
+  }
+}
+
+std::uint32_t HicnForwarderModule::getMtu() { return interface_mtu; }
+
+bool HicnForwarderModule::isControlMessage(utils::MemBuf &packet_buffer) {
+  return packet_buffer.data()[0] == ACK_LIGHT ||
+         packet_buffer.data()[0] == NACK_LIGHT;
+}
+
+/**
+ * @return A valid msg_route_add_t structure if the command was successful, or
+ * with .command_id == COMMAND_TYPE_UNDEFINED in case of error.
+ */
+utils::MemBuf::Ptr HicnForwarderModule::createCommandRoute(
+    std::unique_ptr<sockaddr> &&addr, uint8_t prefix_length) {
+  utils::MemBuf::Ptr ret = utils::MemBuf::create(sizeof(msg_route_add_t));
+  auto command = reinterpret_cast<msg_route_add_t *>(ret->writableData());
+  ret->append(sizeof(msg_route_add_t));
+  std::memset(command, 0, sizeof(*command));
+
+  if (!IS_VALID_FAMILY(addr->sa_family)) return nullptr;
+
+  *command = {
+      .header =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_ROUTE_ADD,
+              .length = 1,
+              .seq_num = 0,
+          },
+      .payload =
+          {
+              .cost = 1,
+              .family = (uint8_t)addr->sa_family,
+              .len = prefix_length,
+          },
+  };
+
+  switch (addr->sa_family) {
+    case AF_INET:
+      command->payload.address.v4.as_inaddr =
+          ((sockaddr_in *)addr.get())->sin_addr;
+      break;
+    case AF_INET6:
+      command->payload.address.v6.as_in6addr =
+          ((sockaddr_in6 *)addr.get())->sin6_addr;
+      break;
+  }
+  snprintf(command->payload.symbolic_or_connid, SYMBOLIC_NAME_LEN, "%s",
+           "SELF");
+
+  return ret;
+}
+
+utils::MemBuf::Ptr HicnForwarderModule::createCommandDeleteConnection() {
+  utils::MemBuf::Ptr ret =
+      utils::MemBuf::create(sizeof(msg_connection_remove_t));
+  auto command =
+      reinterpret_cast<msg_connection_remove_t *>(ret->writableData());
+  ret->append(sizeof(msg_connection_remove_t));
+  std::memset(command, 0, sizeof(*command));
+
+  *command = {
+      .header =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_CONNECTION_REMOVE,
+              .length = 1,
+              .seq_num = 0,
+          },
+  };
+
+  snprintf(command->payload.symbolic_or_connid, SYMBOLIC_NAME_LEN, "%s",
+           "SELF");
+
+  return ret;
+}
+
+utils::MemBuf::Ptr HicnForwarderModule::createCommandMapmeSendUpdate() {
+  utils::MemBuf::Ptr ret =
+      utils::MemBuf::create(sizeof(msg_mapme_send_update_t));
+  auto command =
+      reinterpret_cast<msg_mapme_send_update_t *>(ret->writableData());
+  ret->append(sizeof(msg_mapme_send_update_t));
+  std::memset(command, 0, sizeof(*command));
+
+  *command = {
+      .header =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_MAPME_SEND_UPDATE,
+              .length = 1,
+              .seq_num = seq_++,
+          },
+  };
+
+  return ret;
+}
+
+utils::MemBuf::Ptr HicnForwarderModule::createCommandSetForwardingStrategy(
+    std::unique_ptr<sockaddr> &&addr, uint32_t prefix_len,
+    std::string strategy) {
+  utils::MemBuf::Ptr ret = utils::MemBuf::create(sizeof(msg_strategy_set_t));
+  auto command = reinterpret_cast<msg_strategy_set_t *>(ret->writableData());
+  ret->append(sizeof(msg_strategy_set_t));
+  std::memset(command, 0, sizeof(*command));
+
+  if (!IS_VALID_FAMILY(addr->sa_family)) return nullptr;
+
+  strategy_type_t strategy_type = strategy_type_from_str(strategy.c_str());
+  if (strategy_type == STRATEGY_TYPE_UNDEFINED) return nullptr;
+
+  *command = {
+      .header =
+          {
+              .message_type = REQUEST_LIGHT,
+              .command_id = COMMAND_TYPE_STRATEGY_SET,
+              .length = 1,
+              .seq_num = seq_++,
+          },
+      .payload =
+          {
+              .family = (uint8_t)addr->sa_family,
+              .len = (uint8_t)prefix_len,
+              .type = (uint8_t)strategy_type,
+          },
+  };
+
+  switch (addr->sa_family) {
+    case AF_INET:
+      command->payload.address.v4.as_inaddr =
+          ((sockaddr_in *)addr.get())->sin_addr;
+      break;
+    case AF_INET6:
+      command->payload.address.v6.as_in6addr =
+          ((sockaddr_in6 *)addr.get())->sin6_addr;
+      break;
+  }
+
+  return ret;
+}
+
+extern "C" IoModule *create_module(void) { return new HicnForwarderModule(); }
+
+}  // namespace core
+
+}  // namespace transport
diff --git a/libtransport/src/io_modules/udp/hicn_forwarder_module.h b/libtransport/src/io_modules/hicn-light-ng/hicn_forwarder_module.h
index 845db73bf..0bf82757d 100644
--- a/libtransport/src/io_modules/udp/hicn_forwarder_module.h
+++ b/libtransport/src/io_modules/hicn-light-ng/hicn_forwarder_module.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -18,15 +18,17 @@
 #include <hicn/transport/core/io_module.h>
 #include <hicn/transport/core/prefix.h>
 
+extern "C" {
+#include <hicn/ctrl/hicn-light-ng.h>
+}
+
 namespace transport {
 
 namespace core {
 
-class UdpSocketConnector;
+class UdpTunnelConnector;
 
 class HicnForwarderModule : public IoModule {
-  static constexpr uint8_t ack_code = 0xc2;
-  static constexpr uint8_t nack_code = 0xc3;
   static constexpr std::uint16_t interface_mtu = 1500;
 
  public:
@@ -56,27 +58,45 @@ class HicnForwarderModule : public IoModule {
   void connect(bool is_consumer) override;
 
   void send(Packet &packet) override;
-  void send(const uint8_t *packet, std::size_t len) override;
+  void send(const utils::MemBuf::Ptr &buffer) override;
 
   bool isConnected() override;
 
   void init(Connector::PacketReceivedCallback &&receive_callback,
+            Connector::PacketSentCallback &&sent_callback,
             Connector::OnReconnectCallback &&reconnect_callback,
             asio::io_service &io_service,
             const std::string &app_name = "Libtransport") override;
 
   void registerRoute(const Prefix &prefix) override;
 
+  void sendMapme() override;
+
+  void setForwardingStrategy(const Prefix &prefix,
+                             std::string &strategy) override;
+
   std::uint32_t getMtu() override;
 
-  bool isControlMessage(const uint8_t *message) override;
+  bool isControlMessage(utils::MemBuf &packet_buffer) override;
 
   void processControlMessageReply(utils::MemBuf &packet_buffer) override;
 
   void closeConnection() override;
 
  private:
-  UdpSocketConnector *connector_;
+  utils::MemBuf::Ptr createCommandRoute(std::unique_ptr<sockaddr> &&addr,
+                                        uint8_t prefix_length);
+  utils::MemBuf::Ptr createCommandDeleteConnection();
+  utils::MemBuf::Ptr createCommandMapmeSendUpdate();
+  utils::MemBuf::Ptr createCommandSetForwardingStrategy(
+      std::unique_ptr<sockaddr> &&addr, uint32_t prefix_len,
+      std::string strategy);
+
+ private:
+  std::shared_ptr<UdpTunnelConnector> connector_;
+
+  /* Sequence number used for sending control messages */
+  uint32_t seq_;
 };
 
 extern "C" IoModule *create_module(void);
diff --git a/libtransport/src/io_modules/loopback/CMakeLists.txt b/libtransport/src/io_modules/loopback/CMakeLists.txt
index b5ae0b7f7..817effb3b 100644
--- a/libtransport/src/io_modules/loopback/CMakeLists.txt
+++ b/libtransport/src/io_modules/loopback/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -20,11 +20,11 @@ list(APPEND MODULE_SOURCE_FILES
 )
 
 build_module(loopback_module
-    SHARED
     SOURCES ${MODULE_SOURCE_FILES}
     DEPENDS ${DEPENDENCIES}
     COMPONENT ${LIBTRANSPORT_COMPONENT}
-    INCLUDE_DIRS ${LIBTRANSPORT_INCLUDE_DIRS} ${LIBTRANSPORT_INTERNAL_INCLUDE_DIRS}
+    INCLUDE_DIRS
+      PRIVATE ${LIBTRANSPORT_INTERNAL_INCLUDE_DIRS} ${Libhicn_INCLUDE_DIRS}
     DEFINITIONS ${COMPILER_DEFINITIONS}
-    COMPILE_OPTIONS ${COMPILE_FLAGS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS}
 )
diff --git a/libtransport/src/io_modules/loopback/local_face.cc b/libtransport/src/io_modules/loopback/local_face.cc
index b73444330..7ef3f1a59 100644
--- a/libtransport/src/io_modules/loopback/local_face.cc
+++ b/libtransport/src/io_modules/loopback/local_face.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/io_modules/loopback/local_face.h b/libtransport/src/io_modules/loopback/local_face.h
index 1f4101447..f54f38afa 100644
--- a/libtransport/src/io_modules/loopback/local_face.h
+++ b/libtransport/src/io_modules/loopback/local_face.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/io_modules/loopback/loopback_module.cc b/libtransport/src/io_modules/loopback/loopback_module.cc
index f7dd5e7b0..5b7ed5f61 100644
--- a/libtransport/src/io_modules/loopback/loopback_module.cc
+++ b/libtransport/src/io_modules/loopback/loopback_module.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -41,7 +41,7 @@ void LoopbackModule::send(Packet &packet) {
   local_faces_.at(1 - local_id_)->send(packet);
 }
 
-void LoopbackModule::send(const uint8_t *packet, std::size_t len) {
+void LoopbackModule::send(const utils::MemBuf::Ptr &buffer) {
   // not supported
   throw errors::NotImplementedException();
 }
@@ -57,6 +57,7 @@ void LoopbackModule::closeConnection() {
 }
 
 void LoopbackModule::init(Connector::PacketReceivedCallback &&receive_callback,
+                          Connector::PacketSentCallback &&sent_callback,
                           Connector::OnReconnectCallback &&reconnect_callback,
                           asio::io_service &io_service,
                           const std::string &app_name) {
@@ -64,8 +65,9 @@ void LoopbackModule::init(Connector::PacketReceivedCallback &&receive_callback,
     local_id_ = global_counter_++;
     local_faces_.emplace(
         local_faces_.begin() + local_id_,
-        new LocalConnector(io_service, std::move(receive_callback), nullptr,
-                           nullptr, std::move(reconnect_callback)));
+        new LocalConnector(io_service, std::move(receive_callback),
+                           std::move(sent_callback), nullptr,
+                           std::move(reconnect_callback)));
   }
 }
 
@@ -75,7 +77,9 @@ void LoopbackModule::processControlMessageReply(utils::MemBuf &packet_buffer) {
 
 std::uint32_t LoopbackModule::getMtu() { return interface_mtu; }
 
-bool LoopbackModule::isControlMessage(const uint8_t *message) { return false; }
+bool LoopbackModule::isControlMessage(utils::MemBuf &packet_buffer) {
+  return false;
+}
 
 extern "C" IoModule *create_module(void) { return new LoopbackModule(); }
 
diff --git a/libtransport/src/io_modules/loopback/loopback_module.h b/libtransport/src/io_modules/loopback/loopback_module.h
index 219fa8841..2779ae7e3 100644
--- a/libtransport/src/io_modules/loopback/loopback_module.h
+++ b/libtransport/src/io_modules/loopback/loopback_module.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -36,11 +36,12 @@ class LoopbackModule : public IoModule {
   void connect(bool is_consumer) override;
 
   void send(Packet &packet) override;
-  void send(const uint8_t *packet, std::size_t len) override;
+  void send(const utils::MemBuf::Ptr &buffer) override;
 
   bool isConnected() override;
 
   void init(Connector::PacketReceivedCallback &&receive_callback,
+            Connector::PacketSentCallback &&sent_callback,
             Connector::OnReconnectCallback &&reconnect_callback,
             asio::io_service &io_service,
             const std::string &app_name = "Libtransport") override;
@@ -49,7 +50,7 @@ class LoopbackModule : public IoModule {
 
   std::uint32_t getMtu() override;
 
-  bool isControlMessage(const uint8_t *message) override;
+  bool isControlMessage(utils::MemBuf &packet_buffer) override;
 
   void processControlMessageReply(utils::MemBuf &packet_buffer) override;
 
diff --git a/libtransport/src/io_modules/memif/CMakeLists.txt b/libtransport/src/io_modules/memif/CMakeLists.txt
index fc1c1f135..134ac1db6 100644
--- a/libtransport/src/io_modules/memif/CMakeLists.txt
+++ b/libtransport/src/io_modules/memif/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,18 +11,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-find_package(Vpp REQUIRED)
-find_package(Libmemif REQUIRED)
+
+##############################################################
+# Dependencies and third party libs
+##############################################################
+find_package(Vpp ${VPP_DEFAULT_VERSION} EXACT REQUIRED)
 
 if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-  find_package(HicnPlugin REQUIRED)
-  find_package(SafeVapi REQUIRED)
+  find_package(HicnPlugin ${CURRENT_VERSION} REQUIRED)
+  find_package(SafeVapi ${CURRENT_VERSION} REQUIRED)
 else()
   list(APPEND DEPENDENCIES
     ${SAFE_VAPI_SHARED}
   )
 endif()
 
+list(APPEND DEPENDENCIES
+  ${MEMIF_THIRD_PARTY_DEPENDENCIES}
+)
+
+##############################################################
+# Sources
+##############################################################
 list(APPEND MODULE_HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/hicn_vapi.h
   ${CMAKE_CURRENT_SOURCE_DIR}/memif_connector.h
@@ -32,23 +42,23 @@ list(APPEND MODULE_HEADER_FILES
 
 list(APPEND MODULE_SOURCE_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/hicn_vapi.c
-    ${CMAKE_CURRENT_SOURCE_DIR}/memif_connector.cc
     ${CMAKE_CURRENT_SOURCE_DIR}/memif_vapi.c
     ${CMAKE_CURRENT_SOURCE_DIR}/vpp_forwarder_module.cc
 )
 
 build_module(memif_module
-    SHARED
     SOURCES ${MODULE_SOURCE_FILES}
     DEPENDS ${DEPENDENCIES}
     COMPONENT ${LIBTRANSPORT_COMPONENT}-io-modules
-    LINK_LIBRARIES ${LIBMEMIF_LIBRARIES} ${SAFE_VAPI_LIBRARIES}
+    OBJECT_LIBRARIES ${MEMIF_THIRD_PARTY_OBJECT_LIBRARIES}
+    LINK_LIBRARIES PRIVATE ${HICN_LIBRARIES} ${SAFE_VAPI_LIBRARIES}
     INCLUDE_DIRS
-      ${LIBTRANSPORT_INCLUDE_DIRS}
-      ${LIBTRANSPORT_INTERNAL_INCLUDE_DIRS}
-      ${VPP_INCLUDE_DIRS}
-      ${LIBMEMIF_INCLUDE_DIRS}
-      ${SAFE_VAPI_INCLUDE_DIRS}
+      PUBLIC
+        ${MEMIF_THIRD_PARTY_INCLUDE_DIRS}
+        ${LIBTRANSPORT_INTERNAL_INCLUDE_DIRS}
+        ${VPP_INCLUDE_DIRS}
+        ${LIBMEMIF_INCLUDE_DIRS}
+        ${SAFE_VAPI_INCLUDE_DIRS}
     DEFINITIONS ${COMPILER_DEFINITIONS}
-    COMPILE_OPTIONS ${COMPILE_FLAGS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS} ${MARCH_COMPILER_OPTIONS}
 )
diff --git a/libtransport/src/io_modules/memif/hicn_vapi.c b/libtransport/src/io_modules/memif/hicn_vapi.c
index 6d78026ab..753679f54 100644
--- a/libtransport/src/io_modules/memif/hicn_vapi.c
+++ b/libtransport/src/io_modules/memif/hicn_vapi.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -27,8 +27,6 @@
 #include <vlibapi/api.h>
 #include <vlibmemory/api.h>
 #include <vnet/ip/format.h>
-#include <vnet/ip/ip4_packet.h>
-#include <vnet/ip/ip6_packet.h>
 #include <vpp_plugins/hicn/error.h>
 #include <vppinfra/error.h>
 
@@ -46,9 +44,6 @@ u8 *format_vl_api_address_union(u8 *s, va_list *args) { return NULL; }
 
 /*********************************************************************************/
 
-DEFINE_VAPI_MSG_IDS_HICN_API_JSON
-DEFINE_VAPI_MSG_IDS_IP_API_JSON
-
 static vapi_error_e register_prod_app_cb(
     vapi_ctx_t ctx, void *callback_ctx, vapi_error_e rv, bool is_last,
     vapi_payload_hicn_api_register_prod_app_reply *reply) {
@@ -78,7 +73,7 @@ int hicn_vapi_register_prod_app(vapi_ctx_t ctx,
   vapi_msg_hicn_api_register_prod_app *msg =
       vapi_alloc_hicn_api_register_prod_app(ctx);
 
-  if (ip46_address_is_ip4((ip46_address_t *)&input_params->prefix->address)) {
+  if (ip_address_is_v4((ip_address_t *)&input_params->prefix->address)) {
     memcpy(&msg->payload.prefix.address.un.ip4, &input_params->prefix->address,
            sizeof(ip4_address_t));
     msg->payload.prefix.address.af = ADDRESS_IP4;
@@ -190,7 +185,7 @@ int hicn_vapi_register_route(vapi_ctx_t ctx,
   vapi_msg_ip_route_add_del *msg = vapi_alloc_ip_route_add_del(ctx, 1);
 
   msg->payload.is_add = 1;
-  if (ip46_address_is_ip4((ip46_address_t *)(input_params->prod_addr))) {
+  if (ip_address_is_v4((ip_address_t *)(input_params->prod_addr))) {
     memcpy(&msg->payload.route.prefix.address.un.ip4,
            &input_params->prefix->address.v4, sizeof(ip4_address_t));
     msg->payload.route.prefix.address.af = ADDRESS_IP4;
@@ -204,7 +199,7 @@ int hicn_vapi_register_route(vapi_ctx_t ctx,
 
   msg->payload.route.paths[0].sw_if_index = ~0;
   msg->payload.route.paths[0].table_id = 0;
-  if (ip46_address_is_ip4((ip46_address_t *)(input_params->prod_addr))) {
+  if (ip_address_is_v4((ip_address_t *)(input_params->prod_addr))) {
     memcpy(&(msg->payload.route.paths[0].nh.address.ip4),
            input_params->prod_addr->v4.as_u8, sizeof(ip4_address_t));
     msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP4;
@@ -214,7 +209,7 @@ int hicn_vapi_register_route(vapi_ctx_t ctx,
     msg->payload.route.paths[0].proto = FIB_API_PATH_NH_PROTO_IP6;
   }
 
-  msg->payload.route.paths[0].type = FIB_API_PATH_FLAG_NONE;
+  msg->payload.route.paths[0].type = FIB_API_PATH_TYPE_NORMAL;
   msg->payload.route.paths[0].flags = FIB_API_PATH_FLAG_NONE;
 
   int ret = vapi_ip_route_add_del(ctx, msg, reigster_route_cb, NULL);
diff --git a/libtransport/src/io_modules/memif/hicn_vapi.h b/libtransport/src/io_modules/memif/hicn_vapi.h
index e94c97749..967179f68 100644
--- a/libtransport/src/io_modules/memif/hicn_vapi.h
+++ b/libtransport/src/io_modules/memif/hicn_vapi.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/io_modules/memif/memif_connector.cc b/libtransport/src/io_modules/memif/memif_connector.cc
deleted file mode 100644
index 68ad52b63..000000000
--- a/libtransport/src/io_modules/memif/memif_connector.cc
+++ /dev/null
@@ -1,492 +0,0 @@
-/*
- * 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 <glog/logging.h>
-#include <hicn/transport/errors/not_implemented_exception.h>
-#include <io_modules/memif/memif_connector.h>
-#include <sys/epoll.h>
-
-#include <cstdlib>
-
-extern "C" {
-#include <memif/libmemif.h>
-};
-
-#define CANCEL_TIMER 1
-
-namespace transport {
-
-namespace core {
-
-struct memif_connection {
-  uint16_t index;
-  /* memif conenction handle */
-  memif_conn_handle_t conn;
-  /* transmit queue id */
-  uint16_t tx_qid;
-  /* tx buffers */
-  memif_buffer_t *tx_bufs;
-  /* allocated tx buffers counter */
-  /* number of tx buffers pointing to shared memory */
-  uint16_t tx_buf_num;
-  /* rx buffers */
-  memif_buffer_t *rx_bufs;
-  /* allcoated rx buffers counter */
-  /* number of rx buffers pointing to shared memory */
-  uint16_t rx_buf_num;
-  /* interface ip address */
-  uint8_t ip_addr[4];
-};
-
-std::once_flag MemifConnector::flag_;
-utils::EpollEventReactor MemifConnector::main_event_reactor_;
-
-MemifConnector::MemifConnector(PacketReceivedCallback &&receive_callback,
-                               PacketSentCallback &&packet_sent,
-                               OnCloseCallback &&close_callback,
-                               OnReconnectCallback &&on_reconnect,
-                               asio::io_service &io_service,
-                               std::string app_name)
-    : Connector(std::move(receive_callback), std::move(packet_sent),
-                std::move(close_callback), std::move(on_reconnect)),
-      memif_worker_(nullptr),
-      timer_set_(false),
-      send_timer_(std::make_unique<utils::FdDeadlineTimer>(event_reactor_)),
-      disconnect_timer_(
-          std::make_unique<utils::FdDeadlineTimer>(event_reactor_)),
-      io_service_(io_service),
-      work_(asio::make_work_guard(io_service_)),
-      memif_connection_(std::make_unique<memif_connection_t>()),
-      tx_buf_counter_(0),
-      is_reconnection_(false),
-      data_available_(false),
-      app_name_(app_name),
-      socket_filename_("") {
-  std::call_once(MemifConnector::flag_, &MemifConnector::init, this);
-}
-
-MemifConnector::~MemifConnector() { close(); }
-
-void MemifConnector::init() {
-  /* initialize memory interface */
-  int err = memif_init(controlFdUpdate, const_cast<char *>(app_name_.c_str()),
-                       nullptr, nullptr, nullptr);
-
-  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
-    LOG(ERROR) << "memif_init: " << memif_strerror(err);
-  }
-}
-
-void MemifConnector::connect(uint32_t memif_id, long memif_mode) {
-  state_ = State::CONNECTING;
-
-  memif_id_ = memif_id;
-  socket_filename_ = "/run/vpp/memif.sock";
-
-  createMemif(memif_id, memif_mode, nullptr);
-
-  while (state_ != State::CONNECTED) {
-    MemifConnector::main_event_reactor_.runOneEvent();
-  }
-
-  int err;
-
-  /* get interrupt queue id */
-  int fd = -1;
-  err = memif_get_queue_efd(memif_connection_->conn, 0, &fd);
-  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
-    LOG(ERROR) << "memif_get_queue_efd: " << memif_strerror(err);
-    return;
-  }
-
-  // Remove fd from main epoll
-  main_event_reactor_.delFileDescriptor(fd);
-
-  // Add fd to epoll of instance
-  event_reactor_.addFileDescriptor(
-      fd, EPOLLIN, [this](const utils::Event &evt) -> int {
-        return onInterrupt(memif_connection_->conn, this, 0);
-      });
-
-  memif_worker_ = std::make_unique<std::thread>(
-      std::bind(&MemifConnector::threadMain, this));
-}
-
-int MemifConnector::createMemif(uint32_t index, uint8_t mode, char *s) {
-  memif_connection_t *c = memif_connection_.get();
-
-  /* setting memif connection arguments */
-  memif_conn_args_t args;
-  memset(&args, 0, sizeof(args));
-
-  args.is_master = mode;
-  args.log2_ring_size = MEMIF_LOG2_RING_SIZE;
-  args.buffer_size = MEMIF_BUF_SIZE;
-  args.num_s2m_rings = 1;
-  args.num_m2s_rings = 1;
-  strncpy((char *)args.interface_name, IF_NAME, strlen(IF_NAME) + 1);
-  args.mode = memif_interface_mode_t::MEMIF_INTERFACE_MODE_IP;
-
-  int err;
-
-  err = memif_create_socket(&args.socket, socket_filename_.c_str(), nullptr);
-
-  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
-    throw errors::RuntimeException(memif_strerror(err));
-  }
-
-  args.interface_id = index;
-  /* last argument for memif_create (void * private_ctx) is used by user
-     to identify connection. this context is returned with callbacks */
-
-  /* default interrupt */
-  if (s == nullptr) {
-    err = memif_create(&c->conn, &args, onConnect, onDisconnect, onInterrupt,
-                       this);
-
-    if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
-      throw errors::RuntimeException(memif_strerror(err));
-    }
-  }
-
-  c->index = (uint16_t)index;
-  c->tx_qid = 0;
-  /* alloc memif buffers */
-  c->rx_buf_num = 0;
-  c->rx_bufs = static_cast<memif_buffer_t *>(
-      malloc(sizeof(memif_buffer_t) * MAX_MEMIF_BUFS));
-  c->tx_buf_num = 0;
-  c->tx_bufs = static_cast<memif_buffer_t *>(
-      malloc(sizeof(memif_buffer_t) * MAX_MEMIF_BUFS));
-
-  // memif_set_rx_mode (c->conn, MEMIF_RX_MODE_POLLING, 0);
-
-  return 0;
-}
-
-int MemifConnector::deleteMemif() {
-  memif_connection_t *c = memif_connection_.get();
-
-  if (c->rx_bufs) {
-    free(c->rx_bufs);
-  }
-
-  c->rx_bufs = nullptr;
-  c->rx_buf_num = 0;
-
-  if (c->tx_bufs) {
-    free(c->tx_bufs);
-  }
-
-  c->tx_bufs = nullptr;
-  c->tx_buf_num = 0;
-
-  int err;
-  /* disconenct then delete memif connection */
-  err = memif_delete(&c->conn);
-
-  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
-    LOG(ERROR) << "memif_delete: " << memif_strerror(err);
-  }
-
-  if (TRANSPORT_EXPECT_FALSE(c->conn != nullptr)) {
-    LOG(ERROR) << "memif delete fail";
-  }
-
-  return 0;
-}
-
-int MemifConnector::controlFdUpdate(int fd, uint8_t events, void *private_ctx) {
-  /* convert memif event definitions to epoll events */
-  if (events & MEMIF_FD_EVENT_DEL) {
-    return MemifConnector::main_event_reactor_.delFileDescriptor(fd);
-  }
-
-  uint32_t evt = 0;
-
-  if (events & MEMIF_FD_EVENT_READ) {
-    evt |= EPOLLIN;
-  }
-
-  if (events & MEMIF_FD_EVENT_WRITE) {
-    evt |= EPOLLOUT;
-  }
-
-  if (events & MEMIF_FD_EVENT_MOD) {
-    return MemifConnector::main_event_reactor_.modFileDescriptor(fd, evt);
-  }
-
-  return MemifConnector::main_event_reactor_.addFileDescriptor(
-      fd, evt, [](const utils::Event &evt) -> int {
-        uint32_t event = 0;
-        int memif_err = 0;
-
-        if (evt.events & EPOLLIN) {
-          event |= MEMIF_FD_EVENT_READ;
-        }
-
-        if (evt.events & EPOLLOUT) {
-          event |= MEMIF_FD_EVENT_WRITE;
-        }
-
-        if (evt.events & EPOLLERR) {
-          event |= MEMIF_FD_EVENT_ERROR;
-        }
-
-        memif_err = memif_control_fd_handler(evt.data.fd, event);
-
-        if (TRANSPORT_EXPECT_FALSE(memif_err != MEMIF_ERR_SUCCESS)) {
-          LOG(ERROR) << "memif_control_fd_handler: "
-                     << memif_strerror(memif_err);
-        }
-
-        return 0;
-      });
-}
-
-int MemifConnector::bufferAlloc(long n, uint16_t qid) {
-  memif_connection_t *c = memif_connection_.get();
-  int err;
-  uint16_t r;
-  /* set data pointer to shared memory and set buffer_len to shared mmeory
-   * buffer len */
-  err = memif_buffer_alloc(c->conn, qid, c->tx_bufs, n, &r, 2000);
-
-  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
-    LOG(ERROR) << "memif_buffer_alloc: " << memif_strerror(err);
-    return -1;
-  }
-
-  c->tx_buf_num += r;
-  return r;
-}
-
-int MemifConnector::txBurst(uint16_t qid) {
-  memif_connection_t *c = memif_connection_.get();
-  int err;
-  uint16_t r;
-  /* inform peer memif interface about data in shared memory buffers */
-  /* mark memif buffers as free */
-  err = memif_tx_burst(c->conn, qid, c->tx_bufs, c->tx_buf_num, &r);
-
-  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
-    LOG(ERROR) << "memif_tx_burst: " << memif_strerror(err);
-  }
-
-  // err = memif_refill_queue(c->conn, qid, r, 0);
-
-  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
-    LOG(ERROR) << "memif_tx_burst: " << memif_strerror(err);
-    c->tx_buf_num -= r;
-    return -1;
-  }
-
-  c->tx_buf_num -= r;
-  return 0;
-}
-
-void MemifConnector::sendCallback(const std::error_code &ec) {
-  timer_set_ = false;
-
-  if (TRANSPORT_EXPECT_TRUE(!ec && state_ == State::CONNECTED)) {
-    doSend();
-  }
-}
-
-void MemifConnector::processInputBuffer(std::uint16_t total_packets) {
-  utils::MemBuf::Ptr ptr;
-
-  for (; total_packets > 0; total_packets--) {
-    if (input_buffer_.pop(ptr)) {
-      receive_callback_(this, *ptr, std::make_error_code(std::errc(0)));
-    }
-  }
-}
-
-/* informs user about connected status. private_ctx is used by user to identify
-   connection (multiple connections WIP) */
-int MemifConnector::onConnect(memif_conn_handle_t conn, void *private_ctx) {
-  MemifConnector *connector = (MemifConnector *)private_ctx;
-  connector->state_ = State::CONNECTED;
-  memif_refill_queue(conn, 0, -1, 0);
-
-  return 0;
-}
-
-/* informs user about disconnected status. private_ctx is used by user to
-   identify connection (multiple connections WIP) */
-int MemifConnector::onDisconnect(memif_conn_handle_t conn, void *private_ctx) {
-  MemifConnector *connector = (MemifConnector *)private_ctx;
-  connector->state_ = State::CLOSED;
-  return 0;
-}
-
-void MemifConnector::threadMain() { event_reactor_.runEventLoop(1000); }
-
-int MemifConnector::onInterrupt(memif_conn_handle_t conn, void *private_ctx,
-                                uint16_t qid) {
-  MemifConnector *connector = (MemifConnector *)private_ctx;
-
-  memif_connection_t *c = connector->memif_connection_.get();
-  int err = MEMIF_ERR_SUCCESS, ret_val;
-  uint16_t total_packets = 0;
-  uint16_t rx;
-
-  do {
-    err = memif_rx_burst(conn, qid, c->rx_bufs, MAX_MEMIF_BUFS, &rx);
-    ret_val = err;
-
-    if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS &&
-                               err != MEMIF_ERR_NOBUF)) {
-      LOG(ERROR) << "memif_rx_burst: " << memif_strerror(err);
-      goto error;
-    }
-
-    c->rx_buf_num += rx;
-
-    if (TRANSPORT_EXPECT_FALSE(connector->io_service_.stopped())) {
-      LOG(ERROR) << "socket stopped: ignoring " << rx << " packets";
-      goto error;
-    }
-
-    std::size_t packet_length;
-    for (int i = 0; i < rx; i++) {
-      auto buffer = connector->getRawBuffer();
-      packet_length = (c->rx_bufs + i)->len;
-      std::memcpy(buffer.first, (c->rx_bufs + i)->data, packet_length);
-      auto packet = connector->getPacketFromBuffer(buffer.first, packet_length);
-
-      if (!connector->input_buffer_.push(std::move(packet))) {
-        LOG(ERROR) << "Error pushing packet. Ring buffer full.";
-
-        // TODO Here we should consider the possibility to signal the congestion
-        // to the application, that would react properly (e.g. slow down
-        // message)
-      }
-    }
-
-    /* mark memif buffers and shared memory buffers as free */
-    /* free processed buffers */
-
-    err = memif_refill_queue(conn, qid, rx, 0);
-
-    if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
-      LOG(ERROR) << "memif_buffer_free: " << memif_strerror(err);
-    }
-
-    c->rx_buf_num -= rx;
-    total_packets += rx;
-
-  } while (ret_val == MEMIF_ERR_NOBUF);
-
-  connector->io_service_.post(
-      std::bind(&MemifConnector::processInputBuffer, connector, total_packets));
-
-  return 0;
-
-error:
-  err = memif_refill_queue(c->conn, qid, rx, 0);
-
-  if (TRANSPORT_EXPECT_FALSE(err != MEMIF_ERR_SUCCESS)) {
-    LOG(ERROR) << "memif_buffer_free: " << memif_strerror(err);
-  }
-  c->rx_buf_num -= rx;
-
-  return 0;
-}
-
-void MemifConnector::close() {
-  if (state_ != State::CLOSED) {
-    disconnect_timer_->expiresFromNow(std::chrono::microseconds(50));
-    disconnect_timer_->asyncWait([this](const std::error_code &ec) {
-      deleteMemif();
-      event_reactor_.stop();
-    });
-
-    if (memif_worker_ && memif_worker_->joinable()) {
-      memif_worker_->join();
-    }
-  }
-}
-
-void MemifConnector::send(Packet &packet) {
-  {
-    utils::SpinLock::Acquire locked(write_msgs_lock_);
-    output_buffer_.push_back(packet.shared_from_this());
-  }
-#if CANCEL_TIMER
-  if (!timer_set_) {
-    timer_set_ = true;
-    send_timer_->expiresFromNow(std::chrono::microseconds(50));
-    send_timer_->asyncWait(
-        std::bind(&MemifConnector::sendCallback, this, std::placeholders::_1));
-  }
-#endif
-}
-
-int MemifConnector::doSend() {
-  std::size_t max = 0;
-  int32_t n = 0;
-  std::size_t size = 0;
-
-  {
-    utils::SpinLock::Acquire locked(write_msgs_lock_);
-    size = output_buffer_.size();
-  }
-
-  do {
-    max = size < MAX_MEMIF_BUFS ? size : MAX_MEMIF_BUFS;
-    n = bufferAlloc(max, memif_connection_->tx_qid);
-
-    if (TRANSPORT_EXPECT_FALSE(n < 0)) {
-      LOG(ERROR) << "Error allocating buffers.";
-      return -1;
-    }
-
-    for (uint16_t i = 0; i < n; i++) {
-      utils::SpinLock::Acquire locked(write_msgs_lock_);
-
-      auto packet = output_buffer_.front().get();
-      const utils::MemBuf *current = packet;
-      std::size_t offset = 0;
-      uint8_t *shared_buffer =
-          reinterpret_cast<uint8_t *>(memif_connection_->tx_bufs[i].data);
-      do {
-        std::memcpy(shared_buffer + offset, current->data(), current->length());
-        offset += current->length();
-        current = current->next();
-      } while (current != packet);
-
-      memif_connection_->tx_bufs[i].len = uint32_t(offset);
-
-      output_buffer_.pop_front();
-    }
-
-    txBurst(memif_connection_->tx_qid);
-
-    utils::SpinLock::Acquire locked(write_msgs_lock_);
-    size = output_buffer_.size();
-  } while (size > 0);
-
-  return 0;
-}
-
-void MemifConnector::send(const uint8_t *packet, std::size_t len) {
-  throw errors::NotImplementedException();
-}
-
-}  // end namespace core
-
-}  // end namespace transport
diff --git a/libtransport/src/io_modules/memif/memif_vapi.c b/libtransport/src/io_modules/memif/memif_vapi.c
index b3da2b012..54e2c3134 100644
--- a/libtransport/src/io_modules/memif/memif_vapi.c
+++ b/libtransport/src/io_modules/memif/memif_vapi.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -22,8 +22,6 @@
 #include <vapi/vapi_safe.h>
 #include <vppinfra/clib.h>
 
-DEFINE_VAPI_MSG_IDS_MEMIF_API_JSON
-
 static vapi_error_e memif_details_cb(vapi_ctx_t ctx, void *callback_ctx,
                                      vapi_error_e rv, bool is_last,
                                      vapi_payload_memif_details *reply) {
@@ -45,6 +43,9 @@ static vapi_error_e memif_details_cb(vapi_ctx_t ctx, void *callback_ctx,
 int memif_vapi_get_next_memif_id(vapi_ctx_t ctx, uint32_t *memif_id) {
   vapi_lock();
   vapi_msg_memif_dump *msg = vapi_alloc_memif_dump(ctx);
+
+  // Initialize memif id to 0
+  *memif_id = 0;
   int ret = vapi_memif_dump(ctx, msg, memif_details_cb, memif_id);
   vapi_unlock();
   return ret;
diff --git a/libtransport/src/io_modules/memif/memif_vapi.h b/libtransport/src/io_modules/memif/memif_vapi.h
index bcf06ed43..f5f0639e7 100644
--- a/libtransport/src/io_modules/memif/memif_vapi.h
+++ b/libtransport/src/io_modules/memif/memif_vapi.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -44,6 +44,10 @@ typedef struct memif_output_params_s {
 
 int memif_vapi_get_next_memif_id(vapi_ctx_t ctx, uint32_t *memif_id);
 
+int memif_vapi_create_socket(vapi_ctx_t ctx,
+                             memif_create_params_t *input_params,
+                             memif_output_params_t *output_params);
+
 int memif_vapi_create_memif(vapi_ctx_t ctx, memif_create_params_t *input_params,
                             memif_output_params_t *output_params);
 
diff --git a/libtransport/src/io_modules/memif/vpp_forwarder_module.cc b/libtransport/src/io_modules/memif/vpp_forwarder_module.cc
index 44c8376df..65260077a 100644
--- a/libtransport/src/io_modules/memif/vpp_forwarder_module.cc
+++ b/libtransport/src/io_modules/memif/vpp_forwarder_module.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,16 +13,16 @@
  * limitations under the License.
  */
 
+#include <core/memif_connector.h>
 #include <glog/logging.h>
 #include <hicn/transport/config.h>
 #include <hicn/transport/errors/not_implemented_exception.h>
 #include <io_modules/memif/hicn_vapi.h>
-#include <io_modules/memif/memif_connector.h>
 #include <io_modules/memif/memif_vapi.h>
 #include <io_modules/memif/vpp_forwarder_module.h>
 
 extern "C" {
-#include <memif/libmemif.h>
+#include <libmemif.h>
 };
 
 typedef enum { MASTER = 0, SLAVE = 1 } memif_role_t;
@@ -39,21 +39,24 @@ namespace core {
 VPPForwarderModule::VPPForwarderModule()
     : IoModule(),
       connector_(nullptr),
+      memif_id_(0),
       sw_if_index_(~0),
       face_id1_(~0),
       face_id2_(~0),
       is_consumer_(false) {}
 
-VPPForwarderModule::~VPPForwarderModule() { delete connector_; }
+VPPForwarderModule::~VPPForwarderModule() {}
 
 void VPPForwarderModule::init(
     Connector::PacketReceivedCallback &&receive_callback,
+    Connector::PacketSentCallback &&sent_callback,
     Connector::OnReconnectCallback &&reconnect_callback,
     asio::io_service &io_service, const std::string &app_name) {
   if (!connector_) {
-    connector_ =
-        new MemifConnector(std::move(receive_callback), 0, 0,
-                           std::move(reconnect_callback), io_service, app_name);
+    connector_ = std::make_unique<MemifConnector>(
+        std::move(receive_callback), std::move(sent_callback),
+        Connector::OnCloseCallback(0), std::move(reconnect_callback),
+        io_service, app_name);
   }
 }
 
@@ -62,7 +65,7 @@ void VPPForwarderModule::processControlMessageReply(
   throw errors::NotImplementedException();
 }
 
-bool VPPForwarderModule::isControlMessage(const uint8_t *message) {
+bool VPPForwarderModule::isControlMessage(utils::MemBuf &packet_buffer) {
   return false;
 }
 
@@ -73,12 +76,12 @@ void VPPForwarderModule::send(Packet &packet) {
   connector_->send(packet);
 }
 
-void VPPForwarderModule::send(const uint8_t *packet, std::size_t len) {
+void VPPForwarderModule::send(const utils::MemBuf::Ptr &buffer) {
   counters_.tx_packets++;
-  counters_.tx_bytes += len;
+  counters_.tx_bytes += buffer->length();
 
   // Perfect forwarding
-  connector_->send(packet, len);
+  connector_->send(buffer);
 }
 
 std::uint32_t VPPForwarderModule::getMtu() { return interface_mtu; }
@@ -170,7 +173,8 @@ void VPPForwarderModule::connect(bool is_consumer) {
     consumerConnection();
   }
 
-  connector_->connect(memif_id_, 0);
+  connector_->connect(memif_id_, 0 /* is_master = false */,
+                      memif_socket_filename);
   connector_->setRole(is_consumer_ ? Connector::Role::CONSUMER
                                    : Connector::Role::PRODUCER);
 }
@@ -207,7 +211,8 @@ void VPPForwarderModule::registerRoute(const Prefix &prefix) {
       throw errors::RuntimeException(hicn_vapi_get_error_string(ret));
     }
 
-    inet6_address_ = *output.prod_addr;
+    std::memcpy(inet6_address_.v6.as_u8, output.prod_addr->v6.as_u8,
+                sizeof(inet6_address_));
 
     face_id1_ = output.face_id;
   } else {
@@ -228,8 +233,6 @@ void VPPForwarderModule::registerRoute(const Prefix &prefix) {
 
 void VPPForwarderModule::closeConnection() {
   if (VPPForwarderModule::sock_) {
-    connector_->close();
-
     if (is_consumer_) {
       hicn_del_face_app_input_params params;
       params.face_id = face_id1_;
@@ -242,6 +245,8 @@ void VPPForwarderModule::closeConnection() {
       hicn_vapi_face_prod_del(VPPForwarderModule::sock_, &params);
     }
 
+    connector_->close();
+
     if (sw_if_index_ != uint32_t(~0)) {
       int ret =
           memif_vapi_delete_memif(VPPForwarderModule::sock_, sw_if_index_);
diff --git a/libtransport/src/io_modules/memif/vpp_forwarder_module.h b/libtransport/src/io_modules/memif/vpp_forwarder_module.h
index 8c4114fed..162ee0ca5 100644
--- a/libtransport/src/io_modules/memif/vpp_forwarder_module.h
+++ b/libtransport/src/io_modules/memif/vpp_forwarder_module.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -32,7 +32,8 @@ namespace core {
 class MemifConnector;
 
 class VPPForwarderModule : public IoModule {
-  static constexpr std::uint16_t interface_mtu = 1500;
+  static inline std::uint16_t interface_mtu = 1500;
+  static inline std::string const memif_socket_filename = "/run/vpp/memif.sock";
 
  public:
   VPPForwarderModule();
@@ -41,11 +42,12 @@ class VPPForwarderModule : public IoModule {
   void connect(bool is_consumer) override;
 
   void send(Packet &packet) override;
-  void send(const uint8_t *packet, std::size_t len) override;
+  void send(const utils::MemBuf::Ptr &buffer) override;
 
   bool isConnected() override;
 
   void init(Connector::PacketReceivedCallback &&receive_callback,
+            Connector::PacketSentCallback &&sent_callback,
             Connector::OnReconnectCallback &&reconnect_callback,
             asio::io_service &io_service,
             const std::string &app_name = "Libtransport") override;
@@ -54,7 +56,7 @@ class VPPForwarderModule : public IoModule {
 
   std::uint32_t getMtu() override;
 
-  bool isControlMessage(const uint8_t *message) override;
+  bool isControlMessage(utils::MemBuf &packet_buffer) override;
 
   void processControlMessageReply(utils::MemBuf &packet_buffer) override;
 
@@ -66,7 +68,7 @@ class VPPForwarderModule : public IoModule {
   void producerConnection();
 
  private:
-  MemifConnector *connector_;
+  std::shared_ptr<MemifConnector> connector_;
   uint32_t memif_id_;
   uint32_t sw_if_index_;
   // A consumer socket in vpp has two faces (ipv4 and ipv6)
diff --git a/libtransport/src/io_modules/raw_socket/raw_socket_connector.cc b/libtransport/src/io_modules/raw_socket/raw_socket_connector.cc
deleted file mode 100644
index 62efdc3a5..000000000
--- a/libtransport/src/io_modules/raw_socket/raw_socket_connector.cc
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- * 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 <core/raw_socket_connector.h>
-#include <hicn/transport/utils/conversions.h>
-#include <net/if.h>
-#include <netdb.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-
-#define MY_DEST_MAC0 0x0a
-#define MY_DEST_MAC1 0x7b
-#define MY_DEST_MAC2 0x7c
-#define MY_DEST_MAC3 0x1c
-#define MY_DEST_MAC4 0x4a
-#define MY_DEST_MAC5 0x14
-
-namespace transport {
-
-namespace core {
-
-RawSocketConnector::RawSocketConnector(
-    PacketReceivedCallback &&receive_callback,
-    OnReconnect &&on_reconnect_callback, asio::io_service &io_service,
-    std::string app_name)
-    : Connector(std::move(receive_callback), std::move(on_reconnect_callback)),
-      io_service_(io_service),
-      socket_(io_service_, raw_protocol(PF_PACKET, SOCK_RAW)),
-      // resolver_(io_service_),
-      timer_(io_service_),
-      read_msg_(packet_pool_.makePtr(nullptr)),
-      data_available_(false),
-      app_name_(app_name) {
-  memset(&link_layer_address_, 0, sizeof(link_layer_address_));
-}
-
-RawSocketConnector::~RawSocketConnector() {}
-
-void RawSocketConnector::connect(const std::string &interface_name,
-                                 const std::string &mac_address_str) {
-  state_ = ConnectorState::CONNECTING;
-  memset(&ethernet_header_, 0, sizeof(ethernet_header_));
-  struct ifreq ifr;
-  struct ifreq if_mac;
-  uint8_t mac_address[6];
-
-  utils::convertStringToMacAddress(mac_address_str, mac_address);
-
-  // Get interface mac address
-  int fd = static_cast<int>(socket_.native_handle());
-
-  /* Get the index of the interface to send on */
-  memset(&ifr, 0, sizeof(struct ifreq));
-  strncpy(ifr.ifr_name, interface_name.c_str(), interface_name.size());
-
-  // if (ioctl(fd, SIOCGIFINDEX, &if_idx) < 0) {
-  //     perror("SIOCGIFINDEX");
-  // }
-
-  /* Get the MAC address of the interface to send on */
-  memset(&if_mac, 0, sizeof(struct ifreq));
-  strncpy(if_mac.ifr_name, interface_name.c_str(), interface_name.size());
-  if (ioctl(fd, SIOCGIFHWADDR, &if_mac) < 0) {
-    perror("SIOCGIFHWADDR");
-    throw errors::RuntimeException("Interface does not exist");
-  }
-
-  /* Ethernet header */
-  for (int i = 0; i < 6; i++) {
-    ethernet_header_.ether_shost[i] =
-        ((uint8_t *)&if_mac.ifr_hwaddr.sa_data)[i];
-    ethernet_header_.ether_dhost[i] = mac_address[i];
-  }
-
-  /* Ethertype field */
-  ethernet_header_.ether_type = htons(ETH_P_IPV6);
-
-  strcpy(ifr.ifr_name, interface_name.c_str());
-
-  if (0 == ioctl(fd, SIOCGIFHWADDR, &ifr)) {
-    memcpy(link_layer_address_.sll_addr, ifr.ifr_hwaddr.sa_data, 6);
-  }
-
-  // memset(&ifr, 0, sizeof(ifr));
-  // ioctl(fd, SIOCGIFFLAGS, &ifr);
-  // ifr.ifr_flags |= IFF_PROMISC;
-  // ioctl(fd, SIOCSIFFLAGS, &ifr);
-
-  link_layer_address_.sll_family = AF_PACKET;
-  link_layer_address_.sll_protocol = htons(ETH_P_ALL);
-  link_layer_address_.sll_ifindex = if_nametoindex(interface_name.c_str());
-  link_layer_address_.sll_hatype = 1;
-  link_layer_address_.sll_halen = 6;
-
-  // startConnectionTimer();
-  doConnect();
-  doRecvPacket();
-}
-
-void RawSocketConnector::send(const uint8_t *packet, std::size_t len,
-                              const PacketSentCallback &packet_sent) {
-  if (packet_sent != 0) {
-    socket_.async_send(
-        asio::buffer(packet, len),
-        [packet_sent](std::error_code ec, std::size_t /*length*/) {
-          packet_sent();
-        });
-  } else {
-    if (state_ == ConnectorState::CONNECTED) {
-      socket_.send(asio::buffer(packet, len));
-    }
-  }
-}
-
-void RawSocketConnector::send(const Packet::MemBufPtr &packet) {
-  io_service_.post([this, packet]() {
-    bool write_in_progress = !output_buffer_.empty();
-    output_buffer_.push_back(std::move(packet));
-    if (TRANSPORT_EXPECT_TRUE(state_ == ConnectorState::CONNECTED)) {
-      if (!write_in_progress) {
-        doSendPacket();
-      } else {
-        // Tell the handle connect it has data to write
-        data_available_ = true;
-      }
-    }
-  });
-}
-
-void RawSocketConnector::close() {
-  io_service_.post([this]() { socket_.close(); });
-}
-
-void RawSocketConnector::doSendPacket() {
-  auto packet = output_buffer_.front().get();
-  auto array = std::vector<asio::const_buffer>();
-
-  const utils::MemBuf *current = packet;
-  do {
-    array.push_back(asio::const_buffer(current->data(), current->length()));
-    current = current->next();
-  } while (current != packet);
-
-  socket_.async_send(
-      std::move(array),
-      [this /*, packet*/](std::error_code ec, std::size_t bytes_transferred) {
-        if (TRANSPORT_EXPECT_TRUE(!ec)) {
-          output_buffer_.pop_front();
-          if (!output_buffer_.empty()) {
-            doSendPacket();
-          }
-        } else {
-          LOG(ERROR) << ec.value() << " " << ec.message();
-        }
-      });
-}
-
-void RawSocketConnector::doRecvPacket() {
-  read_msg_ = getPacket();
-  socket_.async_receive(
-      asio::buffer(read_msg_->writableData(), packet_size),
-      [this](std::error_code ec, std::size_t bytes_transferred) mutable {
-        if (!ec) {
-          // Ignore packets that are not for us
-          uint8_t *dst_mac_address = const_cast<uint8_t *>(read_msg_->data());
-          if (!std::memcmp(dst_mac_address, ethernet_header_.ether_shost,
-                           ETHER_ADDR_LEN)) {
-            read_msg_->append(bytes_transferred);
-            read_msg_->trimStart(sizeof(struct ether_header));
-            receive_callback_(std::move(read_msg_));
-          }
-        } else {
-          LOG(ERROR) << ec.value() << " " << ec.message();
-        }
-        doRecvPacket();
-      });
-}
-
-void RawSocketConnector::doConnect() {
-  state_ = ConnectorState::CONNECTED;
-  socket_.bind(raw_endpoint(&link_layer_address_, sizeof(link_layer_address_)));
-}
-
-}  // end namespace core
-
-}  // end namespace transport
diff --git a/libtransport/src/io_modules/raw_socket/raw_socket_connector.h b/libtransport/src/io_modules/raw_socket/raw_socket_connector.h
deleted file mode 100644
index 06892b3d8..000000000
--- a/libtransport/src/io_modules/raw_socket/raw_socket_connector.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * 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.
- */
-
-#pragma once
-
-#include <core/connector.h>
-#include <hicn/transport/config.h>
-#include <hicn/transport/core/asio_wrapper.h>
-#include <hicn/transport/core/name.h>
-#include <linux/if_packet.h>
-#include <net/ethernet.h>
-#include <sys/socket.h>
-
-#include <deque>
-
-namespace transport {
-
-namespace core {
-
-using asio::generic::raw_protocol;
-using raw_endpoint = asio::generic::basic_endpoint<raw_protocol>;
-
-class RawSocketConnector : public Connector {
- public:
-  RawSocketConnector(PacketReceivedCallback &&receive_callback,
-                     OnReconnect &&reconnect_callback,
-                     asio::io_service &io_service,
-                     std::string app_name = "Libtransport");
-
-  ~RawSocketConnector() override;
-
-  void send(const Packet::MemBufPtr &packet) override;
-
-  void send(const uint8_t *packet, std::size_t len,
-            const PacketSentCallback &packet_sent = 0) override;
-
-  void close() override;
-
-  void connect(const std::string &interface_name,
-               const std::string &mac_address_str);
-
- private:
-  void doConnect();
-
-  void doRecvPacket();
-
-  void doSendPacket();
-
- private:
-  asio::io_service &io_service_;
-  raw_protocol::socket socket_;
-
-  struct ether_header ethernet_header_;
-
-  struct sockaddr_ll link_layer_address_;
-
-  asio::steady_timer timer_;
-
-  utils::ObjectPool<utils::MemBuf>::Ptr read_msg_;
-
-  bool data_available_;
-  std::string app_name_;
-};
-
-}  // end namespace core
-
-}  // end namespace transport
diff --git a/libtransport/src/io_modules/raw_socket/raw_socket_interface.cc b/libtransport/src/io_modules/raw_socket/raw_socket_interface.cc
deleted file mode 100644
index dcf489f59..000000000
--- a/libtransport/src/io_modules/raw_socket/raw_socket_interface.cc
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * 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 <core/raw_socket_interface.h>
-#include <hicn/transport/utils/linux.h>
-
-#include <fstream>
-
-namespace transport {
-
-namespace core {
-
-static std::string config_folder_path = "/etc/transport/interface.conf.d";
-
-RawSocketInterface::RawSocketInterface(RawSocketConnector &connector)
-    : ForwarderInterface<RawSocketInterface, RawSocketConnector>(connector) {}
-
-RawSocketInterface::~RawSocketInterface() {}
-
-void RawSocketInterface::connect(bool is_consumer) {
-  std::string complete_filename =
-      config_folder_path + std::string("/") + output_interface_;
-
-  std::ifstream is(complete_filename);
-  std::string interface;
-
-  if (is) {
-    is >> remote_mac_address_;
-  }
-
-  // Get interface ip address
-  struct sockaddr_in6 address = {0};
-  utils::retrieveInterfaceAddress(output_interface_, &address);
-
-  std::memcpy(&inet6_address_.v6.as_u8, &address.sin6_addr,
-              sizeof(address.sin6_addr));
-  connector_.connect(output_interface_, remote_mac_address_);
-}
-
-void RawSocketInterface::registerRoute(Prefix &prefix) { return; }
-
-}  // namespace core
-
-}  // namespace transport
diff --git a/libtransport/src/io_modules/raw_socket/raw_socket_interface.h b/libtransport/src/io_modules/raw_socket/raw_socket_interface.h
deleted file mode 100644
index 7036cac7e..000000000
--- a/libtransport/src/io_modules/raw_socket/raw_socket_interface.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * 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.
- */
-
-#pragma once
-
-#include <core/forwarder_interface.h>
-#include <core/raw_socket_connector.h>
-#include <hicn/transport/core/prefix.h>
-
-#include <atomic>
-#include <deque>
-
-namespace transport {
-
-namespace core {
-
-class RawSocketInterface
-    : public ForwarderInterface<RawSocketInterface, RawSocketConnector> {
- public:
-  typedef RawSocketConnector ConnectorType;
-
-  RawSocketInterface(RawSocketConnector &connector);
-
-  ~RawSocketInterface();
-
-  void connect(bool is_consumer);
-
-  void registerRoute(Prefix &prefix);
-
-  std::uint16_t getMtu() { return interface_mtu; }
-
-  TRANSPORT_ALWAYS_INLINE static bool isControlMessageImpl(
-      const uint8_t *message) {
-    return false;
-  }
-
-  TRANSPORT_ALWAYS_INLINE void processControlMessageReplyImpl(
-      Packet::MemBufPtr &&packet_buffer) {}
-
-  TRANSPORT_ALWAYS_INLINE void closeConnection(){};
-
- private:
-  static constexpr std::uint16_t interface_mtu = 1500;
-  std::string remote_mac_address_;
-};
-
-}  // namespace core
-
-}  // namespace transport
diff --git a/libtransport/src/io_modules/udp/CMakeLists.txt b/libtransport/src/io_modules/udp/CMakeLists.txt
deleted file mode 100644
index b9c19d063..000000000
--- a/libtransport/src/io_modules/udp/CMakeLists.txt
+++ /dev/null
@@ -1,32 +0,0 @@
-# Copyright (c) 2021 Cisco and/or its affiliates.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at:
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-list(APPEND MODULE_HEADER_FILES
-  ${CMAKE_CURRENT_SOURCE_DIR}/hicn_forwarder_module.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/udp_socket_connector.h
-)
-
-list(APPEND MODULE_SOURCE_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/hicn_forwarder_module.cc
-    ${CMAKE_CURRENT_SOURCE_DIR}/udp_socket_connector.cc
-)
-
-build_module(hicnlight_module
-    SHARED
-    SOURCES ${MODULE_SOURCE_FILES}
-    DEPENDS ${DEPENDENCIES}
-    COMPONENT ${LIBTRANSPORT_COMPONENT}
-    INCLUDE_DIRS ${LIBTRANSPORT_INCLUDE_DIRS} ${LIBTRANSPORT_INTERNAL_INCLUDE_DIRS}
-    DEFINITIONS ${COMPILER_DEFINITIONS}
-    COMPILE_OPTIONS ${COMPILE_FLAGS}
-)
diff --git a/libtransport/src/io_modules/udp/hicn_forwarder_module.cc b/libtransport/src/io_modules/udp/hicn_forwarder_module.cc
deleted file mode 100644
index ba08dd8c0..000000000
--- a/libtransport/src/io_modules/udp/hicn_forwarder_module.cc
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- * Copyright (c) 2017-2020 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 <io_modules/udp/hicn_forwarder_module.h>
-#include <io_modules/udp/udp_socket_connector.h>
-
-union AddressLight {
-  uint32_t ipv4;
-  struct in6_addr ipv6;
-};
-
-typedef struct {
-  uint8_t message_type;
-  uint8_t command_id;
-  uint16_t length;
-  uint32_t seq_num;
-} CommandHeader;
-
-typedef struct {
-  uint8_t message_type;
-  uint8_t command_id;
-  uint16_t length;
-  uint32_t seq_num;
-  char symbolic_or_connid[16];
-  union AddressLight address;
-  uint16_t cost;
-  uint8_t address_type;
-  uint8_t len;
-} RouteToSelfCommand;
-
-typedef struct {
-  uint8_t message_type;
-  uint8_t command_id;
-  uint16_t length;
-  uint32_t seq_num;
-  char symbolic_or_connid[16];
-} DeleteSelfConnectionCommand;
-
-namespace {
-static constexpr uint8_t addr_inet = 1;
-static constexpr uint8_t addr_inet6 = 2;
-static constexpr uint8_t add_route_command = 3;
-static constexpr uint8_t delete_connection_command = 5;
-static constexpr uint8_t request_light = 0xc0;
-static constexpr char identifier[] = "SELF";
-
-void fillCommandHeader(CommandHeader *header) {
-  // Allocate and fill the header
-  header->message_type = request_light;
-  header->length = 1;
-}
-
-RouteToSelfCommand createCommandRoute(std::unique_ptr<sockaddr> &&addr,
-                                      uint8_t prefix_length) {
-  RouteToSelfCommand command = {0};
-
-  // check and set IP address
-  if (addr->sa_family == AF_INET) {
-    command.address_type = addr_inet;
-    command.address.ipv4 = ((sockaddr_in *)addr.get())->sin_addr.s_addr;
-  } else if (addr->sa_family == AF_INET6) {
-    command.address_type = addr_inet6;
-    command.address.ipv6 = ((sockaddr_in6 *)addr.get())->sin6_addr;
-  }
-
-  // Fill remaining payload fields
-#ifndef _WIN32
-  strcpy(command.symbolic_or_connid, identifier);
-#else
-  strcpy_s(command.symbolic_or_connid, 16, identifier);
-#endif
-  command.cost = 1;
-  command.len = (uint8_t)prefix_length;
-
-  // Allocate and fill the header
-  command.command_id = add_route_command;
-  fillCommandHeader((CommandHeader *)&command);
-
-  return command;
-}
-
-DeleteSelfConnectionCommand createCommandDeleteConnection() {
-  DeleteSelfConnectionCommand command = {0};
-  fillCommandHeader((CommandHeader *)&command);
-  command.command_id = delete_connection_command;
-
-#ifndef _WIN32
-  strcpy(command.symbolic_or_connid, identifier);
-#else
-  strcpy_s(command.symbolic_or_connid, 16, identifier);
-#endif
-
-  return command;
-}
-
-}  // namespace
-
-namespace transport {
-
-namespace core {
-
-HicnForwarderModule::HicnForwarderModule() : IoModule(), connector_(nullptr) {}
-
-HicnForwarderModule::~HicnForwarderModule() {}
-
-void HicnForwarderModule::connect(bool is_consumer) {
-  connector_->connect();
-  connector_->setRole(is_consumer ? Connector::Role::CONSUMER
-                                  : Connector::Role::PRODUCER);
-}
-
-bool HicnForwarderModule::isConnected() { return connector_->isConnected(); }
-
-void HicnForwarderModule::send(Packet &packet) {
-  IoModule::send(packet);
-  packet.setChecksum();
-  connector_->send(packet);
-}
-
-void HicnForwarderModule::send(const uint8_t *packet, std::size_t len) {
-  counters_.tx_packets++;
-  counters_.tx_bytes += len;
-
-  // Perfect forwarding
-  connector_->send(packet, len);
-}
-
-void HicnForwarderModule::registerRoute(const Prefix &prefix) {
-  auto command = createCommandRoute(prefix.toSockaddr(),
-                                    (uint8_t)prefix.getPrefixLength());
-  send((uint8_t *)&command, sizeof(RouteToSelfCommand));
-}
-
-void HicnForwarderModule::closeConnection() {
-  auto command = createCommandDeleteConnection();
-  send((uint8_t *)&command, sizeof(DeleteSelfConnectionCommand));
-  connector_->close();
-}
-
-void HicnForwarderModule::init(
-    Connector::PacketReceivedCallback &&receive_callback,
-    Connector::OnReconnectCallback &&reconnect_callback,
-    asio::io_service &io_service, const std::string &app_name) {
-  if (!connector_) {
-    connector_ = new UdpSocketConnector(std::move(receive_callback), nullptr,
-                                        nullptr, std::move(reconnect_callback),
-                                        io_service, app_name);
-  }
-}
-
-void HicnForwarderModule::processControlMessageReply(
-    utils::MemBuf &packet_buffer) {
-  if (packet_buffer.data()[0] == nack_code) {
-    throw errors::RuntimeException(
-        "Received Nack message from hicn light forwarder.");
-  }
-}
-
-std::uint32_t HicnForwarderModule::getMtu() { return interface_mtu; }
-
-bool HicnForwarderModule::isControlMessage(const uint8_t *message) {
-  return message[0] == ack_code || message[0] == nack_code;
-}
-
-extern "C" IoModule *create_module(void) { return new HicnForwarderModule(); }
-
-}  // namespace core
-
-}  // namespace transport
diff --git a/libtransport/src/io_modules/udp/udp_socket_connector.cc b/libtransport/src/io_modules/udp/udp_socket_connector.cc
deleted file mode 100644
index 1412d8c07..000000000
--- a/libtransport/src/io_modules/udp/udp_socket_connector.cc
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * 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.
- */
-
-#ifdef _WIN32
-#include <hicn/transport/portability/win_portability.h>
-#endif
-
-#include <glog/logging.h>
-#include <hicn/transport/errors/errors.h>
-#include <hicn/transport/utils/object_pool.h>
-#include <io_modules/udp/udp_socket_connector.h>
-
-#include <thread>
-#include <vector>
-
-namespace transport {
-
-namespace core {
-
-UdpSocketConnector::UdpSocketConnector(
-    PacketReceivedCallback &&receive_callback, PacketSentCallback &&packet_sent,
-    OnCloseCallback &&close_callback, OnReconnectCallback &&on_reconnect,
-    asio::io_service &io_service, std::string app_name)
-    : Connector(std::move(receive_callback), std::move(packet_sent),
-                std::move(close_callback), std::move(on_reconnect)),
-      io_service_(io_service),
-      socket_(io_service_),
-      resolver_(io_service_),
-      connection_timer_(io_service_),
-      read_msg_(std::make_pair(nullptr, 0)),
-      is_reconnection_(false),
-      data_available_(false),
-      app_name_(app_name) {}
-
-UdpSocketConnector::~UdpSocketConnector() {}
-
-void UdpSocketConnector::connect(std::string ip_address, std::string port) {
-  endpoint_iterator_ = resolver_.resolve(
-      {ip_address, port, asio::ip::resolver_query_base::numeric_service});
-
-  state_ = Connector::State::CONNECTING;
-  doConnect();
-}
-
-void UdpSocketConnector::send(const uint8_t *packet, std::size_t len) {
-  socket_.async_send(asio::buffer(packet, len),
-                     [this](std::error_code ec, std::size_t /*length*/) {
-                       if (sent_callback_) {
-                         sent_callback_(this, ec);
-                       }
-                     });
-}
-
-void UdpSocketConnector::send(Packet &packet) {
-  io_service_.post([this, _packet{packet.shared_from_this()}]() {
-    bool write_in_progress = !output_buffer_.empty();
-    output_buffer_.push_back(std::move(_packet));
-    if (TRANSPORT_EXPECT_TRUE(state_ == Connector::State::CONNECTED)) {
-      if (!write_in_progress) {
-        doWrite();
-      }
-    } else {
-      // Tell the handle connect it has data to write
-      data_available_ = true;
-    }
-  });
-}
-
-void UdpSocketConnector::close() {
-  if (io_service_.stopped()) {
-    doClose();
-  } else {
-    io_service_.dispatch(std::bind(&UdpSocketConnector::doClose, this));
-  }
-}
-
-void UdpSocketConnector::doClose() {
-  if (state_ != Connector::State::CLOSED) {
-    state_ = Connector::State::CLOSED;
-    if (socket_.is_open()) {
-      socket_.shutdown(asio::ip::tcp::socket::shutdown_type::shutdown_both);
-      socket_.close();
-    }
-  }
-}
-
-void UdpSocketConnector::doWrite() {
-  auto packet = output_buffer_.front().get();
-  auto array = std::vector<asio::const_buffer>();
-
-  const utils::MemBuf *current = packet;
-  do {
-    array.push_back(asio::const_buffer(current->data(), current->length()));
-    current = current->next();
-  } while (current != packet);
-
-  socket_.async_send(std::move(array), [this](std::error_code ec,
-                                              std::size_t length) {
-    if (TRANSPORT_EXPECT_TRUE(!ec)) {
-      output_buffer_.pop_front();
-      if (!output_buffer_.empty()) {
-        doWrite();
-      }
-    } else if (ec.value() == static_cast<int>(std::errc::operation_canceled)) {
-      // The connection has been closed by the application.
-      return;
-    } else {
-      LOG(ERROR) << ec.value() << " " << ec.message();
-      tryReconnect();
-    }
-  });
-}
-
-void UdpSocketConnector::doRead() {
-  read_msg_ = getRawBuffer();
-  socket_.async_receive(
-      asio::buffer(read_msg_.first, read_msg_.second),
-      [this](std::error_code ec, std::size_t length) {
-        if (TRANSPORT_EXPECT_TRUE(!ec)) {
-          auto packet = getPacketFromBuffer(read_msg_.first, length);
-          receive_callback_(this, *packet, std::make_error_code(std::errc(0)));
-          doRead();
-        } else if (ec.value() ==
-                   static_cast<int>(std::errc::operation_canceled)) {
-          // The connection has been closed by the application.
-          return;
-        } else {
-          LOG(ERROR) << ec.value() << " " << ec.message();
-          tryReconnect();
-        }
-      });
-}
-
-void UdpSocketConnector::tryReconnect() {
-  if (state_ == Connector::State::CONNECTED) {
-    LOG(ERROR) << "Connection lost. Trying to reconnect...";
-    state_ = Connector::State::CONNECTING;
-    is_reconnection_ = true;
-    io_service_.post([this]() {
-      if (socket_.is_open()) {
-        socket_.shutdown(asio::ip::tcp::socket::shutdown_type::shutdown_both);
-        socket_.close();
-      }
-
-      doConnect();
-      startConnectionTimer();
-      std::this_thread::sleep_for(std::chrono::milliseconds(500));
-    });
-  }
-}
-
-void UdpSocketConnector::doConnect() {
-  asio::async_connect(
-      socket_, endpoint_iterator_,
-      [this](std::error_code ec, udp::resolver::iterator) {
-        if (!ec) {
-          connection_timer_.cancel();
-          state_ = Connector::State::CONNECTED;
-          doRead();
-
-          if (data_available_) {
-            data_available_ = false;
-            doWrite();
-          }
-
-          if (is_reconnection_) {
-            is_reconnection_ = false;
-          }
-
-          on_reconnect_callback_(this);
-        } else {
-          doConnect();
-          std::this_thread::sleep_for(std::chrono::milliseconds(500));
-        }
-      });
-}
-
-bool UdpSocketConnector::checkConnected() {
-  return state_ == Connector::State::CONNECTED;
-}
-
-void UdpSocketConnector::startConnectionTimer() {
-  connection_timer_.expires_from_now(std::chrono::seconds(60));
-  connection_timer_.async_wait(std::bind(&UdpSocketConnector::handleDeadline,
-                                         this, std::placeholders::_1));
-}
-
-void UdpSocketConnector::handleDeadline(const std::error_code &ec) {
-  if (!ec) {
-    io_service_.post([this]() {
-      socket_.close();
-      LOG(ERROR) << "Error connecting. Is the forwarder running?";
-    });
-  }
-}
-
-}  // end namespace core
-
-}  // end namespace transport
diff --git a/libtransport/src/io_modules/udp/udp_socket_connector.h b/libtransport/src/io_modules/udp/udp_socket_connector.h
deleted file mode 100644
index c483e14aa..000000000
--- a/libtransport/src/io_modules/udp/udp_socket_connector.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * 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.
- */
-
-#pragma once
-
-#include <hicn/transport/config.h>
-#include <hicn/transport/core/asio_wrapper.h>
-#include <hicn/transport/core/connector.h>
-#include <hicn/transport/core/content_object.h>
-#include <hicn/transport/core/global_object_pool.h>
-#include <hicn/transport/core/interest.h>
-#include <hicn/transport/core/name.h>
-#include <hicn/transport/core/packet.h>
-#include <hicn/transport/utils/branch_prediction.h>
-
-#include <deque>
-
-namespace transport {
-namespace core {
-
-using asio::ip::udp;
-
-class UdpSocketConnector : public Connector {
- public:
-  UdpSocketConnector(PacketReceivedCallback &&receive_callback,
-                     PacketSentCallback &&packet_sent,
-                     OnCloseCallback &&close_callback,
-                     OnReconnectCallback &&on_reconnect,
-                     asio::io_service &io_service,
-                     std::string app_name = "Libtransport");
-
-  ~UdpSocketConnector() override;
-
-  void send(Packet &packet) override;
-
-  void send(const uint8_t *packet, std::size_t len) override;
-
-  void close() override;
-
-  void connect(std::string ip_address = "127.0.0.1", std::string port = "9695");
-
- private:
-  void doConnect();
-
-  void doRead();
-
-  void doWrite();
-
-  void doClose();
-
-  bool checkConnected();
-
- private:
-  void handleDeadline(const std::error_code &ec);
-
-  void startConnectionTimer();
-
-  void tryReconnect();
-
-  asio::io_service &io_service_;
-  asio::ip::udp::socket socket_;
-  asio::ip::udp::resolver resolver_;
-  asio::ip::udp::resolver::iterator endpoint_iterator_;
-  asio::steady_timer connection_timer_;
-
-  std::pair<uint8_t *, std::size_t> read_msg_;
-
-  bool is_reconnection_;
-  bool data_available_;
-
-  std::string app_name_;
-};
-
-}  // end namespace core
-
-}  // end namespace transport
diff --git a/libtransport/src/libhicntransport-config.cmake.in b/libtransport/src/libhicntransport-config.cmake.in
new file mode 100644
index 000000000..9b8c51962
--- /dev/null
+++ b/libtransport/src/libhicntransport-config.cmake.in
@@ -0,0 +1,8 @@
+@PACKAGE_INIT@
+
+set(Libhicntransport_VERSION_MAJOR "@VERSION_MAJOR@")
+set(Libhicntransport_VERSION_MINOR "@VERSION_MINOR@")
+set(Libhicntransport_VERSION_PATCH "@VERSION_PATCH@")
+
+set_and_check(Libhicntransport_INCLUDE_DIRS  "@PACKAGE_Libhicntransport_INCLUDE_DIRS@")
+include("${CMAKE_CURRENT_LIST_DIR}/libhicntransport-targets.cmake")
diff --git a/libtransport/src/protocols/CMakeLists.txt b/libtransport/src/protocols/CMakeLists.txt
index b763e95e2..51879a9ed 100644
--- a/libtransport/src/protocols/CMakeLists.txt
+++ b/libtransport/src/protocols/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -52,9 +52,15 @@ list(APPEND SOURCE_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/errors.cc
 )
 
-set(RAAQM_CONFIG_INSTALL_PREFIX
-  ${CMAKE_INSTALL_FULL_SYSCONFDIR}/hicn
-)
+if (${CMAKE_SYSTEM_NAME} MATCHES Darwin OR ${CMAKE_SYSTEM_NAME} MATCHES Linux)
+  set(RAAQM_CONFIG_INSTALL_PREFIX
+    ${CMAKE_INSTALL_FULL_SYSCONFDIR}/hicn
+  )
+else()
+  set(RAAQM_CONFIG_INSTALL_PREFIX
+    ${CMAKE_INSTALL_PREFIX}/etc/hicn
+  )
+endif()
 
 set(raaqm_config_path
   ${RAAQM_CONFIG_INSTALL_PREFIX}/consumer.conf
@@ -67,7 +73,7 @@ set(TRANSPORT_CONFIG
 
 install(
   FILES ${TRANSPORT_CONFIG}
-  DESTINATION ${CMAKE_INSTALL_FULL_SYSCONFDIR}/hicn
+  DESTINATION ${RAAQM_CONFIG_INSTALL_PREFIX}
   COMPONENT ${LIBTRANSPORT_COMPONENT}
 )
 
diff --git a/libtransport/src/protocols/byte_stream_reassembly.cc b/libtransport/src/protocols/byte_stream_reassembly.cc
index ac36d4e61..3278595b7 100644
--- a/libtransport/src/protocols/byte_stream_reassembly.cc
+++ b/libtransport/src/protocols/byte_stream_reassembly.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/protocols/byte_stream_reassembly.h b/libtransport/src/protocols/byte_stream_reassembly.h
index 278740bd3..bfcac3181 100644
--- a/libtransport/src/protocols/byte_stream_reassembly.h
+++ b/libtransport/src/protocols/byte_stream_reassembly.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/protocols/cbr.cc b/libtransport/src/protocols/cbr.cc
index 1548cc68d..446ea8b99 100644
--- a/libtransport/src/protocols/cbr.cc
+++ b/libtransport/src/protocols/cbr.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -37,11 +37,11 @@ void CbrTransportProtocol::afterDataUnsatisfied(uint64_t segment) {}
 void CbrTransportProtocol::afterContentReception(
     const Interest &interest, const ContentObject &content_object) {
   auto segment = content_object.getName().getSuffix();
-  auto now = utils::SteadyClock::now();
-  auto rtt = std::chrono::duration_cast<utils::Microseconds>(
-      now - interest_timepoints_[segment & mask]);
+  auto now = utils::SteadyTime::Clock::now();
+  auto rtt = utils::SteadyTime::getDurationMs(
+      interest_timepoints_[segment & mask], now);
   // Update stats
-  updateStats(segment, rtt.count(), now);
+  updateStats(segment, rtt, now);
 }
 
 }  // end namespace protocol
diff --git a/libtransport/src/protocols/cbr.h b/libtransport/src/protocols/cbr.h
index 41cdbc98c..c178dbf60 100644
--- a/libtransport/src/protocols/cbr.h
+++ b/libtransport/src/protocols/cbr.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/protocols/congestion_window_protocol.h b/libtransport/src/protocols/congestion_window_protocol.h
index 36ac6eb17..f9ff208cc 100644
--- a/libtransport/src/protocols/congestion_window_protocol.h
+++ b/libtransport/src/protocols/congestion_window_protocol.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/protocols/data_processing_events.h b/libtransport/src/protocols/data_processing_events.h
index 28732502b..182de3ed8 100644
--- a/libtransport/src/protocols/data_processing_events.h
+++ b/libtransport/src/protocols/data_processing_events.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/protocols/datagram_reassembly.cc b/libtransport/src/protocols/datagram_reassembly.cc
index 069873a52..3a32c81f5 100644
--- a/libtransport/src/protocols/datagram_reassembly.cc
+++ b/libtransport/src/protocols/datagram_reassembly.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/protocols/datagram_reassembly.h b/libtransport/src/protocols/datagram_reassembly.h
index de294df06..0def32dd2 100644
--- a/libtransport/src/protocols/datagram_reassembly.h
+++ b/libtransport/src/protocols/datagram_reassembly.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/protocols/errors.cc b/libtransport/src/protocols/errors.cc
index 183fcc574..a7dd26e16 100644
--- a/libtransport/src/protocols/errors.cc
+++ b/libtransport/src/protocols/errors.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/protocols/errors.h b/libtransport/src/protocols/errors.h
index 58dadae5a..33d5fbee4 100644
--- a/libtransport/src/protocols/errors.h
+++ b/libtransport/src/protocols/errors.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/protocols/fec/CMakeLists.txt b/libtransport/src/protocols/fec/CMakeLists.txt
index 6d61ae043..8ae0a7360 100644
--- a/libtransport/src/protocols/fec/CMakeLists.txt
+++ b/libtransport/src/protocols/fec/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
diff --git a/libtransport/src/protocols/fec/fec.cc b/libtransport/src/protocols/fec/fec.cc
index 16a04cb98..912e7a40f 100644
--- a/libtransport/src/protocols/fec/fec.cc
+++ b/libtransport/src/protocols/fec/fec.cc
@@ -44,6 +44,7 @@
 
 #include "fec.h"
 
+#include <assert.h>
 #include <hicn/transport/portability/platform.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -60,72 +61,6 @@
 #endif
 
 /*
- * compatibility stuff
- */
-#ifdef MSDOS /* but also for others, e.g. sun... */
-#define NEED_BCOPY
-#define bcmp(a, b, n) memcmp(a, b, n)
-#endif
-
-#ifdef ANDROID
-#define bcmp(a, b, n) memcmp(a, b, n)
-#endif
-
-#ifdef NEED_BCOPY
-#define bcopy(s, d, siz) memcpy((d), (s), (siz))
-#define bzero(d, siz) memset((d), '\0', (siz))
-#endif
-
-/*
- * stuff used for testing purposes only
- */
-
-#ifdef TEST
-#define DEB(x)
-#define DDB(x) x
-#define DEBUG 0 /* minimal debugging */
-#ifdef MSDOS
-#include <time.h>
-struct timeval {
-  unsigned long ticks;
-};
-#define gettimeofday(x, dummy) \
-  { (x)->ticks = clock(); }
-#define DIFF_T(a, b) (1 + 1000000 * (a.ticks - b.ticks) / CLOCKS_PER_SEC)
-typedef unsigned long u_long;
-typedef unsigned short u_short;
-#else /* typically, unix systems */
-#include <sys/time.h>
-#define DIFF_T(a, b) \
-  (1 + 1000000 * (a.tv_sec - b.tv_sec) + (a.tv_usec - b.tv_usec))
-#endif
-
-#define TICK(t)                                  \
-  {                                              \
-    struct timeval x;                            \
-    gettimeofday(&x, NULL);                      \
-    t = x.tv_usec + 1000000 * (x.tv_sec & 0xff); \
-  }
-#define TOCK(t)               \
-  {                           \
-    u_long t1;                \
-    TICK(t1);                 \
-    if (t1 < t)               \
-      t = 256000000 + t1 - t; \
-    else                      \
-      t = t1 - t;             \
-    if (t == 0) t = 1;        \
-  }
-
-u_long ticks[10]; /* vars for timekeeping */
-#else
-#define DEB(x)
-#define DDB(x)
-#define TICK(x)
-#define TOCK(x)
-#endif /* TEST */
-
-/*
  * You should not need to change anything beyond this point.
  * The first part of the file implements linear algebra in GF.
  *
@@ -402,31 +337,17 @@ static void matmul(gf *a, gf *b, gf *c, int n, int k, int m) {
   }
 }
 
-#ifdef DEBUGG
-/*
- * returns 1 if the square matrix is identiy
- * (only for test)
- */
-static int is_identity(gf *m, int k) {
-  int row, col;
-  for (row = 0; row < k; row++)
-    for (col = 0; col < k; col++)
-      if ((row == col && *m != 1) || (row != col && *m != 0))
-        return 0;
-      else
-        m++;
-  return 1;
-}
-#endif /* debug */
-
 /*
  * invert_mat() takes a matrix and produces its inverse
  * k is the size of the matrix.
  * (Gauss-Jordan, adapted from Numerical Recipes in C)
  * Return non-zero if singular.
  */
-DEB(int pivloops = 0; int pivswaps = 0; /* diagnostic */)
+int pivloops = 0;
+int pivswaps = 0; /* diagnostic */
 static int invert_mat(gf *src, int k) {
+  assert(k > 0);
+
   gf c, *p;
   int irow, icol, row, col, i, ix;
 
@@ -436,9 +357,9 @@ static int invert_mat(gf *src, int k) {
   int *ipiv = (int *)my_malloc(k * sizeof(int), "ipiv");
   gf *id_row = NEW_GF_MATRIX(1, k);
   gf *temp_row = NEW_GF_MATRIX(1, k);
-
-  bzero(id_row, k * sizeof(gf));
-  DEB(pivloops = 0; pivswaps = 0; /* diagnostic */)
+  memset(id_row, '\0', k * sizeof(gf));
+  pivloops = 0;
+  pivswaps = 0; /* diagnostic */
   /*
    * ipiv marks elements already used as pivots.
    */
@@ -459,7 +380,7 @@ static int invert_mat(gf *src, int k) {
     for (row = 0; row < k; row++) {
       if (ipiv[row] != 1) {
         for (ix = 0; ix < k; ix++) {
-          DEB(pivloops++;)
+          pivloops++;
           if (ipiv[ix] == 0) {
             if (src[row * k + ix] != 0) {
               irow = row;
@@ -497,12 +418,9 @@ static int invert_mat(gf *src, int k) {
       fprintf(stderr, "singular matrix 2\n");
       goto fail;
     }
-    if (c != 1) { /* otherwhise this is a NOP */
-      /*
-       * this is done often , but optimizing is not so
-       * fruitful, at least in the obvious ways (unrolling)
-       */
-      DEB(pivswaps++;)
+
+    if (c != 1) {
+      pivswaps++;
       c = inverse[c];
       pivot_row[icol] = 1;
       for (ix = 0; ix < k; ix++) pivot_row[ix] = gf_mul(c, pivot_row[ix]);
@@ -515,7 +433,7 @@ static int invert_mat(gf *src, int k) {
      * we can optimize the addmul).
      */
     id_row[icol] = 1;
-    if (bcmp(pivot_row, id_row, k * sizeof(gf)) != 0) {
+    if (memcmp(pivot_row, id_row, k * sizeof(gf)) != 0) {
       for (p = src, ix = 0; ix < k; ix++, p += k) {
         if (ix != icol) {
           c = p[icol];
@@ -560,6 +478,8 @@ fail:
  */
 
 int invert_vdm(gf *src, int k) {
+  assert(k > 0);
+
   int i, j, row, col;
   gf *b, *c, *p;
   gf t, xx;
@@ -614,14 +534,8 @@ int invert_vdm(gf *src, int k) {
 
 static int fec_initialized = 0;
 static void init_fec() {
-  TICK(ticks[0]);
   generate_gf();
-  TOCK(ticks[0]);
-  DDB(fprintf(stderr, "generate_gf took %ldus\n", ticks[0]);)
-  TICK(ticks[0]);
   init_mul_table();
-  TOCK(ticks[0]);
-  DDB(fprintf(stderr, "init_mul_table took %ldus\n", ticks[0]);)
   fec_initialized = 1;
 }
 
@@ -680,19 +594,14 @@ struct fec_parms *fec_new(int k, int n) {
    * k*k vandermonde matrix, multiply right the bottom n-k rows
    * by the inverse, and construct the identity matrix at the top.
    */
-  TICK(ticks[3]);
   invert_vdm(tmp_m, k); /* much faster than invert_mat */
   matmul(tmp_m + k * k, tmp_m, retval->enc_matrix + k * k, n - k, k, k);
   /*
    * the upper matrix is I so do not bother with a slow multiply
    */
-  bzero(retval->enc_matrix, k * k * sizeof(gf));
+  memset(retval->enc_matrix, '\0', k * k * sizeof(gf));
   for (p = retval->enc_matrix, col = 0; col < k; col++, p += k + 1) *p = 1;
   free(tmp_m);
-  TOCK(ticks[3]);
-
-  DDB(fprintf(stderr, "--- %ld us to build encoding matrix\n", ticks[3]);)
-  DEB(pr_matrix(retval->enc_matrix, n, k, "encoding_matrix");)
   return retval;
 }
 
@@ -708,10 +617,10 @@ void fec_encode(struct fec_parms *code, gf *src[], gf *fec, int index, int sz) {
   if (GF_BITS > 8) sz /= 2;
 
   if (index < k)
-    bcopy(src[index], fec, sz * sizeof(gf));
+    memcpy(fec, src[index], sz * sizeof(gf));
   else if (index < code->n) {
     p = &(code->enc_matrix[index * k]);
-    bzero(fec, sz * sizeof(gf));
+    memset(fec, '\0', sz * sizeof(gf));
     for (i = 0; i < k; i++) addmul(fec, src[i], p[i], sz);
   } else
     fprintf(stderr, "Invalid index %d (max %d)\n", index, code->n - 1);
@@ -733,22 +642,13 @@ static int shuffle(gf *pkt[], int index[], int k) {
       int c = index[i];
 
       if (index[c] == c) {
-        DEB(fprintf(stderr, "\nshuffle, error at %d\n", i);)
+        fprintf(stderr, "\nshuffle, error at %d\n", i);
         return 1;
       }
       SWAP(index[i], index[c], int);
       SWAP(pkt[i], pkt[c], gf *);
     }
   }
-  DEB(/* just test that it works... */
-      for (i = 0; i < k; i++) {
-        if (index[i] < k && index[i] != i) {
-          fprintf(stderr, "shuffle: after\n");
-          for (i = 0; i < k; i++) fprintf(stderr, "%3d ", index[i]);
-          fprintf(stderr, "\n");
-          return 1;
-        }
-      })
   return 0;
 }
 
@@ -757,20 +657,16 @@ static int shuffle(gf *pkt[], int index[], int k) {
  * indexes. The matrix must be already allocated as
  * a vector of k*k elements, in row-major order
  */
-static gf *build_decode_matrix(struct fec_parms *code, gf *pkt[], int index[]) {
+static gf *build_decode_matrix(struct fec_parms *code, int index[]) {
   int i, k = code->k;
   gf *p, *matrix = NEW_GF_MATRIX(k, k);
 
-  TICK(ticks[9]);
   for (i = 0, p = matrix; i < k; i++, p += k) {
-#if 1 /* this is simply an optimization, not very useful indeed */
     if (index[i] < k) {
-      bzero(p, k * sizeof(gf));
+      memset(p, '\0', k * sizeof(gf));
       p[i] = 1;
-    } else
-#endif
-        if (index[i] < code->n)
-      bcopy(&(code->enc_matrix[index[i] * k]), p, k * sizeof(gf));
+    } else if (index[i] < code->n)
+      memcpy(p, &(code->enc_matrix[index[i] * k]), k * sizeof(gf));
     else {
       fprintf(stderr, "decode: invalid index %d (max %d)\n", index[i],
               code->n - 1);
@@ -778,12 +674,10 @@ static gf *build_decode_matrix(struct fec_parms *code, gf *pkt[], int index[]) {
       return NULL;
     }
   }
-  TICK(ticks[9]);
   if (invert_mat(matrix, k)) {
     free(matrix);
     matrix = NULL;
   }
-  TOCK(ticks[9]);
   return matrix;
 }
 
@@ -800,39 +694,29 @@ static gf *build_decode_matrix(struct fec_parms *code, gf *pkt[], int index[]) {
  */
 int fec_decode(struct fec_parms *code, gf *pkt[], int index[], int sz) {
   gf *m_dec;
-  gf **new_pkt;
+  gf **new_pkt = nullptr;
   int row, col, k = code->k;
+  int i = 0;
 
   if (GF_BITS > 8) sz /= 2;
 
   if (shuffle(pkt, index, k)) /* error if true */
     return 1;
-  m_dec = build_decode_matrix(code, pkt, index);
+  m_dec = build_decode_matrix(code, index);
 
   if (m_dec == NULL) return 1; /* error */
   /*
    * do the actual decoding
    */
-  new_pkt = (gf **)my_malloc(k * sizeof(gf *), "new pkt pointers");
+  new_pkt = pkt + k;
   for (row = 0; row < k; row++) {
     if (index[row] >= k) {
-      new_pkt[row] = (gf *)my_malloc(sz * sizeof(gf), "new pkt buffer");
-      bzero(new_pkt[row], sz * sizeof(gf));
+      memset(new_pkt[i], '\0', sz * sizeof(gf));
       for (col = 0; col < k; col++)
-        addmul(new_pkt[row], pkt[col], m_dec[row * k + col], sz);
-    }
-  }
-  /*
-   * move pkts to their final destination
-   */
-  for (row = 0; row < k; row++) {
-    if (index[row] >= k) {
-      bcopy(new_pkt[row], pkt[row], sz * sizeof(gf));
-      free(new_pkt[row]);
+        addmul(new_pkt[i], pkt[col], m_dec[row * k + col], sz);
+      i++;
     }
   }
-  free(new_pkt);
   free(m_dec);
-
   return 0;
 }
diff --git a/libtransport/src/protocols/fec/rely.cc b/libtransport/src/protocols/fec/rely.cc
index 7a30a62e2..d4d98a90b 100644
--- a/libtransport/src/protocols/fec/rely.cc
+++ b/libtransport/src/protocols/fec/rely.cc
@@ -23,38 +23,39 @@ namespace transport {
 namespace protocol {
 namespace fec {
 
-RelyEncoder::RelyEncoder(uint32_t k, uint32_t n, uint32_t seq_offset)
+RelyEncoder::RelyEncoder(uint32_t k, uint32_t n, uint32_t /* seq_offset */)
     : RelyBase(k, n) {
   configure(kmtu, ktimeout, kmax_stream_size);
   set_repair_trigger(k_, n_ - k_, n_ - k_);
 }
 
 void RelyEncoder::onPacketProduced(core::ContentObject &content_object,
-                                   uint32_t offset) {
+                                   uint32_t offset, uint32_t metadata) {
   // Get pointer to payload, leaving space to insert FEC header.
   // TODO Check if this additional header is really needed.
-  auto data = content_object.writableData() + offset - sizeof(fec_header);
-  auto length = content_object.length() - offset + sizeof(fec_header);
+  auto data = content_object.writableData() + offset - sizeof(fec_metadata);
+  auto length = content_object.length() - offset + sizeof(fec_metadata);
 
   // Check packet length does not exceed maximum length supported by the
   // encoder (otherwise segmentation would take place).
-  assert(length < max_packet_bytes());
+  DCHECK(length < max_packet_bytes());
   DLOG_IF(INFO, VLOG_IS_ON(4))
-      << "Encoding packet of length " << length - sizeof(fec_header);
+      << "Encoding packet of length " << length - sizeof(fec_metadata);
 
-  // Get the suffix. With rely we need to write it in the fec_header in order to
-  // be able to recognize the seq number upon recovery.
+  // Get the suffix. With rely we need to write it in the fec_metadata in order
+  // to be able to recognize the seq number upon recovery.
   auto suffix = content_object.getName().getSuffix();
   DLOG_IF(INFO, VLOG_IS_ON(4)) << "Producing packet " << suffix
                                << " (index == " << current_index_ << ")";
 
-  // Consume payload. Add fec_header in front before feeding payload to encoder,
-  // and copy original content of packet
-  fec_header *h = reinterpret_cast<fec_header *>(data);
-  fec_header copy = *h;
+  // Consume payload. Add fec_metadata in front before feeding payload to
+  // encoder, and copy original content of packet
+  fec_metadata *h = reinterpret_cast<fec_metadata *>(data);
+  fec_metadata copy = *h;
   h->setSeqNumberBase(suffix);
+  h->setMetadataBase(metadata);
   auto packets = consume(data, length, getCurrentTime());
-  assert(packets == 1);
+  DCHECK(packets == 1);
 
   // Update packet counter
   current_index_ += packets;
@@ -62,7 +63,7 @@ void RelyEncoder::onPacketProduced(core::ContentObject &content_object,
   // Restore original packet content and increment data pointer to the correct
   // position
   *h = copy;
-  data += sizeof(fec_header);
+  data += sizeof(fec_metadata);
 
   // Check position of this packet inside N size block
   auto i = current_index_ % n_;
@@ -74,24 +75,24 @@ void RelyEncoder::onPacketProduced(core::ContentObject &content_object,
     // TODO Optimize it by copying only the RELY header
 
     // Be sure encoder can produce
-    assert(can_produce());
+    DCHECK(can_produce());
 
     // Check new payload size and make sure it fits in packet buffer
     auto new_payload_size = produce_bytes();
     int difference = new_payload_size - length;
 
-    assert(difference > 0);
-    assert(content_object.ensureCapacity(difference));
+    DCHECK(difference > 0);
+    DCHECK(content_object.ensureCapacity(difference));
 
     // Update length
     DLOG_IF(INFO, VLOG_IS_ON(4)) << "The packet length will be incremented by "
-                                 << difference + sizeof(fec_header);
-    content_object.append(difference + sizeof(fec_header));
+                                 << difference + sizeof(fec_metadata);
+    content_object.append(difference + sizeof(fec_metadata));
     content_object.updateLength();
 
     // Make sure we got a source packet, otherwise we would put a repair symbol
     // in a source packet
-    assert(rely::packet_is_systematic(produce_data()));
+    DCHECK(rely::packet_is_systematic(produce_data()));
 
     // Copy rely packet replacing old source packet.
     std::memcpy(data, produce_data(), new_payload_size);
@@ -111,7 +112,7 @@ void RelyEncoder::onPacketProduced(core::ContentObject &content_object,
   while (can_produce()) {
     // The current index MUST be k_, because we enforce n - k repair to be
     // produced after k sources
-    assert(current_index_ == k_);
+    DCHECK(current_index_ == k_);
 
     buffer packet;
     if (!buffer_callback_) {
@@ -130,7 +131,7 @@ void RelyEncoder::onPacketProduced(core::ContentObject &content_object,
     std::memcpy(packet->writableData(), produce_data(), produce_bytes());
 
     // Push symbol in repair_packets
-    packets_.emplace_back(0, std::move(packet));
+    packets_.emplace_back(0, metadata, std::move(packet));
 
     // Advance the encoder
     produce_next();
@@ -143,7 +144,7 @@ void RelyEncoder::onPacketProduced(core::ContentObject &content_object,
   // If we have generated repair symbols, let's notify caller via the installed
   // callback
   if (packets_.size()) {
-    assert(packets_.size() == n_ - k_);
+    DCHECK(packets_.size() == n_ - k_);
     fec_callback_(packets_);
     packets_.clear();
     current_index_ = 0;
@@ -156,7 +157,7 @@ RelyDecoder::RelyDecoder(uint32_t k, uint32_t n, uint32_t seq_offset)
 }
 
 void RelyDecoder::onDataPacket(core::ContentObject &content_object,
-                               uint32_t offset) {
+                               uint32_t offset, uint32_t metadata) {
   // Adjust pointers to point to packet payload
   auto data = content_object.writableData() + offset;
   auto size = content_object.length() - offset;
@@ -164,30 +165,38 @@ void RelyDecoder::onDataPacket(core::ContentObject &content_object,
   // Pass payload to decoder
   consume(data, size, getCurrentTime());
 
+  producePackets();
+}
+
+void RelyDecoder::producePackets() {
   // Drain decoder if possible
   while (can_produce()) {
-    // Get size of decoded packet
-    auto size = produce_bytes();
-
-    // Get buffer to copy packet in
-    auto packet = core::PacketManager<>::getInstance().getMemBuf();
+    auto fec_header_size = sizeof(fec_metadata);
+    auto payload_size = produce_bytes() - sizeof(fec_metadata);
 
-    // Copy buffer
-    packet->append(size);
-    std::memcpy(packet->writableData(), produce_data(), size);
+    buffer packet;
+    if (!buffer_callback_) {
+      packet = core::PacketManager<>::getInstance().getMemBuf();
+      packet->append(payload_size);
+    } else {
+      packet = buffer_callback_(payload_size);
+    }
 
     // Read seq number
-    fec_header *h = reinterpret_cast<fec_header *>(packet->writableData());
+    const fec_metadata *h =
+        reinterpret_cast<const fec_metadata *>(produce_data());
     uint32_t index = h->getSeqNumberBase();
+    uint32_t metadata = h->getMetadataBase();
 
     DLOG_IF(INFO, VLOG_IS_ON(4))
         << "The index written in the packet is " << index;
 
-    // Remove FEC header
-    packet->trimStart(sizeof(fec_header));
+    // Copy payload
+    std::memcpy(packet->writableData(), produce_data() + fec_header_size,
+                payload_size);
 
     // Save packet in buffer
-    packets_.emplace_back(index, std::move(packet));
+    packets_.emplace_back(index, metadata, std::move(packet));
 
     // Advance to next packet
     produce_next();
@@ -198,8 +207,28 @@ void RelyDecoder::onDataPacket(core::ContentObject &content_object,
     fec_callback_(packets_);
     packets_.clear();
   }
+
+  flushOutOfOrder();
+}
+
+void RelyDecoder::flushOutOfOrder() {
+  if (flush_timer_ == nullptr) return;
+  flush_timer_->cancel();
+
+  if (has_upcoming_flush()) {
+    flush_timer_->expires_from_now(std::chrono::milliseconds(
+        std::max((int64_t)0, upcoming_flush(getCurrentTime()))));
+
+    flush_timer_->async_wait([this](const std::error_code &ec) {
+      if (ec) return;
+      if (has_upcoming_flush()) {
+        flush(getCurrentTime());
+        producePackets();
+      }
+    });
+  }
 }
 
 }  // namespace fec
 }  // namespace protocol
-}  // namespace transport
\ No newline at end of file
+}  // namespace transport
diff --git a/libtransport/src/protocols/fec/rely.h b/libtransport/src/protocols/fec/rely.h
index bfbdb30bc..001a26002 100644
--- a/libtransport/src/protocols/fec/rely.h
+++ b/libtransport/src/protocols/fec/rely.h
@@ -33,8 +33,12 @@ namespace fec {
  * @brief Table of used codes.
  */
 #define foreach_rely_fec_type \
+  _(Rely, 1, 2)               \
   _(Rely, 1, 3)               \
+  _(Rely, 1, 4)               \
   _(Rely, 2, 3)               \
+  _(Rely, 2, 6)               \
+  _(Rely, 3, 9)               \
   _(Rely, 4, 5)               \
   _(Rely, 4, 6)               \
   _(Rely, 4, 7)               \
@@ -74,11 +78,17 @@ class RelyBase : public virtual FECBase {
    * decoding operations. It may be removed once we know the meaning of the
    * fields in the rely header.
    */
-  struct fec_header {
-    uint32_t seq_number;
-
+  class fec_metadata {
+   public:
     void setSeqNumberBase(uint32_t suffix) { seq_number = htonl(suffix); }
-    uint32_t getSeqNumberBase() { return ntohl(seq_number); }
+    uint32_t getSeqNumberBase() const { return ntohl(seq_number); }
+
+    void setMetadataBase(uint32_t value) { metadata = htonl(value); }
+    uint32_t getMetadataBase() const { return ntohl(metadata); }
+
+   private:
+    uint32_t seq_number;
+    uint32_t metadata;
   };
 
   /**
@@ -112,21 +122,20 @@ class RelyBase : public virtual FECBase {
 #if RELY_DEBUG
     return time_++;
 #else
-    auto _time = utils::SteadyClock::now().time_since_epoch();
-    auto time = std::chrono::duration_cast<utils::Milliseconds>(_time).count();
-    return time;
+    return utils::SteadyTime::nowMs().count();
 #endif
   }
 
- protected:
   uint32_t k_;
   uint32_t n_;
+
   std::uint32_t seq_offset_;
+
   /**
    * @brief Vector of packets to be passed to caller callbacks. For encoder it
    * will contain the repair packets, for decoder the recovered sources.
    */
-  std::vector<std::pair<uint32_t, buffer>> packets_;
+  BufferArray packets_;
 
   /**
    * @brief Current index to be used for local packet count.
@@ -142,50 +151,54 @@ class RelyBase : public virtual FECBase {
  * @brief The Rely Encoder implementation.
  *
  */
-class RelyEncoder : private RelyBase,
-                    private rely::encoder,
-                    public ProducerFEC {
+class RelyEncoder : RelyBase, rely::encoder, public ProducerFEC {
  public:
   RelyEncoder(uint32_t k, uint32_t n, uint32_t seq_offset = 0);
   /**
    * Producers will call this function when they produce a data packet.
    */
-  void onPacketProduced(core::ContentObject &content_object,
-                        uint32_t offset) override;
+  void onPacketProduced(core::ContentObject &content_object, uint32_t offset,
+                        uint32_t metadata = FECBase::INVALID_METADATA) override;
 
   /**
    * @brief Get the fec header size, if added to source packets
    */
   std::size_t getFecHeaderSize() override {
-    return header_bytes() + sizeof(fec_header) + 4;
+    return header_bytes() + sizeof(fec_metadata) + 4;
   }
 
-  void reset() override {}
+  void reset() override {
+    // Nothing to do here
+  }
 };
 
-class RelyDecoder : private RelyBase,
-                    private rely::decoder,
-                    public ConsumerFEC {
+class RelyDecoder : RelyBase, rely::decoder, public ConsumerFEC {
  public:
   RelyDecoder(uint32_t k, uint32_t n, uint32_t seq_offset = 0);
 
   /**
    * Consumers will call this function when they receive a data packet
    */
-  void onDataPacket(core::ContentObject &content_object,
-                    uint32_t offset) override;
+  void onDataPacket(core::ContentObject &content_object, uint32_t offset,
+                    uint32_t metadata = FECBase::INVALID_METADATA) override;
 
   /**
    * @brief Get the fec header size, if added to source packets
    */
   std::size_t getFecHeaderSize() override {
-    return header_bytes() + sizeof(fec_header);
+    return header_bytes() + sizeof(fec_metadata);
+  }
+
+  void reset() override {
+    // Nothing to do here
   }
 
-  void reset() override {}
+ private:
+  void producePackets();
+  void flushOutOfOrder();
 };
 
 }  // namespace fec
 
 }  // namespace protocol
-}  // namespace transport
\ No newline at end of file
+}  // namespace transport
diff --git a/libtransport/src/protocols/fec/rs.cc b/libtransport/src/protocols/fec/rs.cc
index 2c23d515d..9c0a3d4fb 100644
--- a/libtransport/src/protocols/fec/rs.cc
+++ b/libtransport/src/protocols/fec/rs.cc
@@ -46,23 +46,26 @@ bool BlockCode::addRepairSymbol(const fec::buffer &packet, uint32_t i,
   to_decode_ = true;
   DLOG_IF(INFO, VLOG_IS_ON(4)) << "Adding symbol of size " << packet->length();
   return addSymbol(packet, i, offset,
-                   packet->length() - sizeof(fec_header) - offset);
+                   packet->length() - sizeof(fec_header) - offset,
+                   FECBase::INVALID_METADATA);
 }
 
 bool BlockCode::addSourceSymbol(const fec::buffer &packet, uint32_t i,
-                                uint32_t offset) {
+                                uint32_t offset, uint32_t metadata) {
   DLOG_IF(INFO, VLOG_IS_ON(4)) << "Adding source symbol of size "
                                << packet->length() << ", offset " << offset;
-  return addSymbol(packet, i, offset, packet->length() - offset);
+  return addSymbol(packet, i, offset, packet->length() - offset, metadata);
 }
 
 bool BlockCode::addSymbol(const fec::buffer &packet, uint32_t i,
-                          uint32_t offset, std::size_t size) {
+                          uint32_t offset, std::size_t size,
+                          uint32_t metadata) {
   if (size > max_buffer_size_) {
     max_buffer_size_ = size;
   }
 
-  operator[](current_block_size_++) = std::make_tuple(i, packet, offset);
+  operator[](current_block_size_) = RSBufferInfo(offset, i, metadata, packet);
+  current_block_size_++;
 
   if (current_block_size_ >= k_) {
     if (to_decode_) {
@@ -80,12 +83,13 @@ bool BlockCode::addSymbol(const fec::buffer &packet, uint32_t i,
 
 void BlockCode::encode() {
   gf *data[n_];
-  uint32_t base = std::get<0>(operator[](0));
+  uint32_t base = operator[](0).getIndex();
 
   // Set packet length in first 2 bytes
   for (uint32_t i = 0; i < k_; i++) {
-    auto &packet = std::get<1>(operator[](i));
-    auto offset = std::get<2>(operator[](i));
+    auto &packet = operator[](i).getBuffer();
+    auto offset = operator[](i).getOffset();
+    auto metadata_base = operator[](i).getMetadata();
 
     auto ret =
         packet->ensureCapacityAndFillUnused(max_buffer_size_ + offset, 0);
@@ -98,10 +102,11 @@ void BlockCode::encode() {
     // Buffers should hold 2 *after* the padding, in order to be
     // able to set the length for the encoding operation.
     // packet->trimStart(offset);
-    uint16_t *length = reinterpret_cast<uint16_t *>(packet->writableData() +
-                                                    max_buffer_size_ + offset);
+    fec_metadata *metadata = reinterpret_cast<fec_metadata *>(
+        packet->writableData() + max_buffer_size_ + offset);
     auto buffer_length = packet->length() - offset;
-    *length = htons(buffer_length);
+    metadata->setPacketLength(buffer_length);
+    metadata->setMetadataBase(metadata_base);
 
     DLOG_IF(INFO, VLOG_IS_ON(4)) << "Current buffer size: " << packet->length();
 
@@ -109,7 +114,7 @@ void BlockCode::encode() {
   }
 
   // Finish to fill source block with the buffers to hold the repair symbols
-  auto length = max_buffer_size_ + sizeof(fec_header) + LEN_SIZE_BYTES;
+  auto length = max_buffer_size_ + sizeof(fec_header) + METADATA_BYTES;
   for (uint32_t i = k_; i < n_; i++) {
     buffer packet;
     if (!params_.buffer_callback_) {
@@ -133,19 +138,20 @@ void BlockCode::encode() {
     DLOG_IF(INFO, VLOG_IS_ON(4)) << "Current symbol size: " << packet->length();
 
     data[i] = packet->writableData();
-    operator[](i) = std::make_tuple(i, std::move(packet), uint32_t(0));
+    operator[](i) = RSBufferInfo(uint32_t(0), i, FECBase::INVALID_METADATA,
+                                 std::move(packet));
   }
 
   // Generate repair symbols and put them in corresponding buffers
   DLOG_IF(INFO, VLOG_IS_ON(4))
       << "Calling encode with max_buffer_size_ = " << max_buffer_size_;
   for (uint32_t i = k_; i < n_; i++) {
-    fec_encode(code_, data, data[i], i, max_buffer_size_ + LEN_SIZE_BYTES);
+    fec_encode(code_, data, data[i], i, max_buffer_size_ + METADATA_BYTES);
   }
 
   // Re-include header in repair packets
   for (uint32_t i = k_; i < n_; i++) {
-    auto &packet = std::get<1>(operator[](i));
+    auto &packet = operator[](i).getBuffer();
     packet->prepend(sizeof(fec_header));
     DLOG_IF(INFO, VLOG_IS_ON(4))
         << "Produced repair symbol of size = " << packet->length();
@@ -153,16 +159,31 @@ void BlockCode::encode() {
 }
 
 void BlockCode::decode() {
-  gf *data[k_];
+  gf *data[n_];
   uint32_t index[k_];
+  buffer aux_fec_packets[n_ - k_];
+  // FEC packet number  k0
+  uint32_t k0 = 0;
+
+  // Reorder block by index with in-place sorting
+  for (uint32_t i = 0; i < k_;) {
+    uint32_t idx = operator[](i).getIndex();
+    if (idx >= k_ || idx == i) {
+      i++;
+    } else {
+      std::swap(operator[](i), operator[](idx));
+    }
+  }
 
   for (uint32_t i = 0; i < k_; i++) {
-    auto &packet = std::get<1>(operator[](i));
-    index[i] = std::get<0>(operator[](i));
-    auto offset = std::get<2>(operator[](i));
+    auto &packet = operator[](i).getBuffer();
+    index[i] = operator[](i).getIndex();
+    auto offset = operator[](i).getOffset();
+    auto metadata_base = operator[](i).getMetadata();
     sorted_index_[i] = index[i];
 
     if (index[i] < k_) {
+      operator[](i).setReceived();
       DLOG_IF(INFO, VLOG_IS_ON(4))
           << "DECODE SOURCE - index " << index[i]
           << " - Current buffer size: " << packet->length();
@@ -173,49 +194,51 @@ void BlockCode::decode() {
       // able to set the length for the encoding operation
       packet->trimStart(offset);
       packet->ensureCapacityAndFillUnused(max_buffer_size_, 0);
-      uint16_t *length = reinterpret_cast<uint16_t *>(
-          packet->writableData() + max_buffer_size_ - LEN_SIZE_BYTES);
-
-      *length = htons(packet->length());
+      fec_metadata *metadata = reinterpret_cast<fec_metadata *>(
+          packet->writableData() + max_buffer_size_ - METADATA_BYTES);
+      metadata->setPacketLength(packet->length());
+      metadata->setMetadataBase(metadata_base);
     } else {
       DLOG_IF(INFO, VLOG_IS_ON(4))
           << "DECODE SYMBOL - index " << index[i]
           << " - Current buffer size: " << packet->length();
       packet->trimStart(sizeof(fec_header) + offset);
+      aux_fec_packets[k0] = core::PacketManager<>::getInstance().getMemBuf();
+      data[k_ + k0] = aux_fec_packets[k0]->writableData();
+      k0++;
     }
-
     data[i] = packet->writableData();
   }
-
   // We decode the source block
   DLOG_IF(INFO, VLOG_IS_ON(4))
       << "Calling decode with max_buffer_size_ = " << max_buffer_size_;
+
   fec_decode(code_, data, reinterpret_cast<int *>(index), max_buffer_size_);
 
   // Find the index in the block for recovered packets
-  for (uint32_t i = 0; i < k_; i++) {
-    if (index[i] != i) {
-      for (uint32_t j = 0; j < k_; j++)
-        if (sorted_index_[j] == uint32_t(index[i])) {
-          sorted_index_[j] = i;
-        }
-    }
-  }
-
-  // Reorder block by index with in-place sorting
-  for (uint32_t i = 0; i < k_; i++) {
-    for (uint32_t j = sorted_index_[i]; j != i; j = sorted_index_[i]) {
-      std::swap(sorted_index_[j], sorted_index_[i]);
-      std::swap(operator[](j), operator[](i));
+  for (uint32_t i = 0, j = 0; i < k_; i++) {
+    if (index[i] >= k_) {
+      operator[](i).setBuffer(aux_fec_packets[j++]);
+      operator[](i).setIndex(i);
     }
   }
 
   // Adjust length according to the one written in the source packet
   for (uint32_t i = 0; i < k_; i++) {
-    auto &packet = std::get<1>(operator[](i));
-    uint16_t *length = reinterpret_cast<uint16_t *>(
-        packet->writableData() + max_buffer_size_ - LEN_SIZE_BYTES);
-    packet->setLength(ntohs(*length));
+    auto &packet = operator[](i).getBuffer();
+    fec_metadata *metadata = reinterpret_cast<fec_metadata *>(
+        packet->writableData() + max_buffer_size_ - METADATA_BYTES);
+    // Adjust buffer length
+    packet->setLength(metadata->getPacketLength());
+    // Adjust metadata
+    operator[](i).setMetadata(metadata->getMetadataBase());
+
+    // reset the point to the beginning of the packets for all received packets
+    if (operator[](i).getReceived()) {
+      auto &packet = operator[](i).getBuffer();
+      auto offset = operator[](i).getOffset();
+      packet->prepend(offset);
+    }
   }
 }
 
@@ -252,12 +275,11 @@ RSEncoder::RSEncoder(uint32_t k, uint32_t n, uint32_t seq_offset)
       source_block_(k_, n_, seq_offset_, current_code_, *this) {}
 
 void RSEncoder::consume(const fec::buffer &packet, uint32_t index,
-                        uint32_t offset) {
-  if (!source_block_.addSourceSymbol(packet, index, offset)) {
-    std::vector<std::pair<uint32_t, buffer>> repair_packets;
+                        uint32_t offset, uint32_t metadata) {
+  if (!source_block_.addSourceSymbol(packet, index, offset, metadata)) {
+    fec::BufferArray repair_packets;
     for (uint32_t i = k_; i < n_; i++) {
-      repair_packets.emplace_back(std::move(std::get<0>(source_block_[i])),
-                                  std::move(std::get<1>(source_block_[i])));
+      repair_packets.emplace_back(std::move(source_block_[i]));
     }
 
     fec_callback_(repair_packets);
@@ -265,9 +287,9 @@ void RSEncoder::consume(const fec::buffer &packet, uint32_t index,
 }
 
 void RSEncoder::onPacketProduced(core::ContentObject &content_object,
-                                 uint32_t offset) {
+                                 uint32_t offset, uint32_t metadata) {
   consume(content_object.shared_from_this(),
-          content_object.getName().getSuffix(), offset);
+          content_object.getName().getSuffix(), offset, metadata);
 }
 
 RSDecoder::RSDecoder(uint32_t k, uint32_t n, uint32_t seq_offset)
@@ -276,10 +298,15 @@ RSDecoder::RSDecoder(uint32_t k, uint32_t n, uint32_t seq_offset)
 void RSDecoder::recoverPackets(SourceBlocks::iterator &src_block_it) {
   DLOG_IF(INFO, VLOG_IS_ON(4)) << "recoverPackets for " << k_;
   auto &src_block = src_block_it->second;
-  std::vector<std::pair<uint32_t, buffer>> source_packets(k_);
+  auto base_index = src_block_it->first;
+  BufferArray source_packets(k_);
+
+  // Iterate over packets in the block and adjust indexed accordingly. This must
+  // be done because indexes are from 0 to (n - k - 1), but we need indexes from
+  // base_index to base_index + (n - k - 1)
   for (uint32_t i = 0; i < src_block.getK(); i++) {
-    source_packets[i] = std::make_pair(src_block_it->first + i,
-                                       std::move(std::get<1>(src_block[i])));
+    src_block[i].setIndex(base_index + src_block[i].getIndex());
+    source_packets[i] = FECBufferInfo(std::move(src_block[i]));
   }
 
   setProcessed(src_block_it->first);
@@ -296,9 +323,9 @@ void RSDecoder::recoverPackets(SourceBlocks::iterator &src_block_it) {
 }
 
 void RSDecoder::consumeSource(const fec::buffer &packet, uint32_t index,
-                              uint32_t offset) {
+                              uint32_t offset, uint32_t metadata) {
   // Normalize index
-  assert(index >= seq_offset_);
+  DCHECK(index >= seq_offset_);
   auto i = (index - seq_offset_) % n_;
 
   // Get base
@@ -324,16 +351,19 @@ void RSDecoder::consumeSource(const fec::buffer &packet, uint32_t index,
   //    protocol that may come in the future.
   auto it = src_blocks_.find(base);
   if (it != src_blocks_.end()) {
-    auto ret = it->second.addSourceSymbol(packet, i, offset);
+    auto ret = it->second.addSourceSymbol(packet, i, offset, metadata);
     if (!ret) {
       recoverPackets(it);
     }
   } else {
     DLOG_IF(INFO, VLOG_IS_ON(4)) << "Adding to parked source packets";
-    auto ret = parked_packets_.emplace(
-        base, std::vector<std::pair<buffer, uint32_t>>());
-    ret.first->second.emplace_back(packet, i);
+    auto ret = parked_packets_.emplace(base, BufferInfoArray());
+    ret.first->second.emplace_back(offset, i, metadata, packet);
 
+    /**
+     * If we reached k source packets, we do not have any missing packet to
+     * recover via FEC. Delete the block.
+     */
     if (ret.first->second.size() >= k_) {
       setProcessed(ret.first->first);
       parked_packets_.erase(ret.first);
@@ -356,8 +386,8 @@ void RSDecoder::consumeRepair(const fec::buffer &packet, uint32_t offset) {
 
   DLOG_IF(INFO, VLOG_IS_ON(4))
       << "Decoder consume called for repair symbol. BASE = " << base
-      << ", index = " << base + i << " and i = " << i << ". K=" << k
-      << ", N=" << n;
+      << ", index = " << base + i << " and i = " << (int)i << ". K=" << (int)k
+      << ", N=" << (int)n;
 
   // check if a source block already exist for this symbol
   auto it = src_blocks_.find(base);
@@ -380,8 +410,9 @@ void RSDecoder::consumeRepair(const fec::buffer &packet, uint32_t offset) {
     auto it2 = parked_packets_.find(base);
     if (it2 != parked_packets_.end()) {
       for (auto &packet_index : it2->second) {
-        auto ret = it->second.addSourceSymbol(packet_index.first,
-                                              packet_index.second, offset);
+        auto ret = it->second.addSourceSymbol(
+            packet_index.getBuffer(), packet_index.getIndex(),
+            packet_index.getOffset(), packet_index.getMetadata());
         if (!ret) {
           recoverPackets(it);
           // Finish to delete packets in same source block that were
@@ -399,7 +430,7 @@ void RSDecoder::consumeRepair(const fec::buffer &packet, uint32_t offset) {
 }
 
 void RSDecoder::onDataPacket(core::ContentObject &content_object,
-                             uint32_t offset) {
+                             uint32_t offset, uint32_t metadata) {
   DLOG_IF(INFO, VLOG_IS_ON(4))
       << "Calling fec for data packet " << content_object.getName()
       << ". Offset: " << offset;
@@ -409,7 +440,7 @@ void RSDecoder::onDataPacket(core::ContentObject &content_object,
   if (isSymbol(suffix)) {
     consumeRepair(content_object.shared_from_this(), offset);
   } else {
-    consumeSource(content_object.shared_from_this(), suffix, offset);
+    consumeSource(content_object.shared_from_this(), suffix, offset, metadata);
   }
 }
 
diff --git a/libtransport/src/protocols/fec/rs.h b/libtransport/src/protocols/fec/rs.h
index e159ad9f7..034c32bdc 100644
--- a/libtransport/src/protocols/fec/rs.h
+++ b/libtransport/src/protocols/fec/rs.h
@@ -34,10 +34,28 @@ namespace protocol {
 namespace fec {
 
 #define foreach_rs_fec_type \
+  _(RS, 1, 2)               \
   _(RS, 1, 3)               \
+  _(RS, 1, 4)               \
+  _(RS, 2, 3)               \
+  _(RS, 2, 4)               \
+  _(RS, 2, 5)               \
+  _(RS, 2, 6)               \
+  _(RS, 3, 6)               \
+  _(RS, 3, 7)               \
+  _(RS, 3, 8)               \
+  _(RS, 3, 9)               \
+  _(RS, 3, 10)              \
+  _(RS, 3, 11)              \
+  _(RS, 3, 12)              \
   _(RS, 4, 5)               \
   _(RS, 4, 6)               \
   _(RS, 4, 7)               \
+  _(RS, 4, 8)               \
+  _(RS, 4, 9)               \
+  _(RS, 4, 10)              \
+  _(RS, 4, 11)              \
+  _(RS, 4, 12)              \
   _(RS, 6, 10)              \
   _(RS, 8, 10)              \
   _(RS, 8, 11)              \
@@ -45,6 +63,8 @@ namespace fec {
   _(RS, 8, 14)              \
   _(RS, 8, 16)              \
   _(RS, 8, 32)              \
+  _(RS, 10, 20)             \
+  _(RS, 10, 25)             \
   _(RS, 10, 30)             \
   _(RS, 10, 40)             \
   _(RS, 10, 60)             \
@@ -56,12 +76,24 @@ namespace fec {
   _(RS, 16, 27)             \
   _(RS, 17, 21)             \
   _(RS, 17, 34)             \
+  _(RS, 20, 45)             \
+  _(RS, 20, 50)             \
+  _(RS, 20, 60)             \
+  _(RS, 20, 70)             \
+  _(RS, 30, 70)             \
+  _(RS, 30, 75)             \
+  _(RS, 30, 85)             \
+  _(RS, 30, 95)             \
   _(RS, 32, 36)             \
   _(RS, 32, 41)             \
   _(RS, 32, 46)             \
   _(RS, 32, 54)             \
   _(RS, 34, 42)             \
   _(RS, 35, 70)             \
+  _(RS, 40, 95)             \
+  _(RS, 40, 100)            \
+  _(RS, 40, 110)            \
+  _(RS, 40, 120)            \
   _(RS, 52, 62)
 
 static const constexpr uint16_t MAX_SOURCE_BLOCK_SIZE = 128;
@@ -73,9 +105,24 @@ static const constexpr uint16_t MAX_SOURCE_BLOCK_SIZE = 128;
  * std::array allows to be constructed in place, saving the allocation at the
  * price os knowing in advance its size.
  */
-using Packets = std::array<std::tuple</* index */ uint32_t, /* buffer */ buffer,
-                                      uint32_t /* offset */>,
-                           MAX_SOURCE_BLOCK_SIZE>;
+class RSBufferInfo : public FECBufferInfo {
+ public:
+  RSBufferInfo() : FECBufferInfo() {}
+
+  RSBufferInfo(uint32_t offset, uint32_t index, uint32_t metadata,
+               buffer buffer)
+      : FECBufferInfo(index, metadata, buffer), offset_(offset) {}
+
+  uint32_t getOffset() { return offset_; }
+  RSBufferInfo &setOffset(uint32_t offset) {
+    offset_ = offset;
+    return *this;
+  }
+
+ private:
+  uint32_t offset_ = 0;
+};
+using Packets = std::array<RSBufferInfo, MAX_SOURCE_BLOCK_SIZE>;
 
 /**
  * FEC Header, prepended to symbol packets.
@@ -123,10 +170,32 @@ class rs;
  */
 class BlockCode : public Packets {
   /**
+   * @brief Metadata to include when encoding the buffers. This does not need to
+   * be sent over the network, but just to be included in the FEC protected
+   * bytes.
+   *
+   */
+  class __attribute__((__packed__)) fec_metadata {
+   public:
+    void setPacketLength(uint16_t length) { packet_length = htons(length); }
+    uint32_t getPacketLength() { return ntohs(packet_length); }
+
+    void setMetadataBase(uint32_t value) { metadata = htonl(value); }
+    uint32_t getMetadataBase() { return ntohl(metadata); }
+
+   private:
+    uint16_t packet_length; /* Used to get the real size of the packet after we
+                               pad it */
+    uint32_t
+        metadata; /* Caller may specify an integer for storing additional
+                     metadata that can be used when recovering the packet. */
+  };
+
+  /**
    * For variable length packet we need to prepend to the padded payload the
    * real length of the packet. This is *not* sent over the network.
    */
-  static constexpr std::size_t LEN_SIZE_BYTES = 2;
+  static constexpr std::size_t METADATA_BYTES = sizeof(fec_metadata);
 
  public:
   BlockCode(uint32_t k, uint32_t n, uint32_t seq_offset, struct fec_parms *code,
@@ -142,7 +211,8 @@ class BlockCode : public Packets {
    * Add a source symbol to the source block.
    */
   bool addSourceSymbol(const fec::buffer &packet, uint32_t i,
-                       uint32_t offset = 0);
+                       uint32_t offset = 0,
+                       uint32_t metadata = FECBase::INVALID_METADATA);
 
   /**
    * Get current length of source block.
@@ -169,7 +239,7 @@ class BlockCode : public Packets {
    * Add symbol to source block
    **/
   bool addSymbol(const fec::buffer &packet, uint32_t i, uint32_t offset,
-                 std::size_t size);
+                 std::size_t size, uint32_t metadata);
 
   /**
    * Starting from k source symbols, get the n - k repair symbols
@@ -310,10 +380,11 @@ class RSEncoder : public rs, public ProducerFEC {
   /**
    * Always consume source symbols.
    */
-  void consume(const fec::buffer &packet, uint32_t index, uint32_t offset = 0);
+  void consume(const fec::buffer &packet, uint32_t index, uint32_t offset = 0,
+               uint32_t metadata = FECBase::INVALID_METADATA);
 
-  void onPacketProduced(core::ContentObject &content_object,
-                        uint32_t offset) override;
+  void onPacketProduced(core::ContentObject &content_object, uint32_t offset,
+                        uint32_t metadata = FECBase::INVALID_METADATA) override;
 
   /**
    * @brief Get the fec header size, if added to source packets
@@ -348,8 +419,8 @@ class RSDecoder : public rs, public ConsumerFEC {
   /**
    * Consume source symbol
    */
-  void consumeSource(const fec::buffer &packet, uint32_t i,
-                     uint32_t offset = 0);
+  void consumeSource(const fec::buffer &packet, uint32_t i, uint32_t offset = 0,
+                     uint32_t metadata = FECBase::INVALID_METADATA);
 
   /**
    * Consume repair symbol
@@ -359,8 +430,8 @@ class RSDecoder : public rs, public ConsumerFEC {
   /**
    * Consumers will call this function when they receive a data packet
    */
-  void onDataPacket(core::ContentObject &content_object,
-                    uint32_t offset) override;
+  void onDataPacket(core::ContentObject &content_object, uint32_t offset,
+                    uint32_t metadata = FECBase::INVALID_METADATA) override;
 
   /**
    * @brief Get the fec header size, if added to source packets
@@ -398,8 +469,8 @@ class RSDecoder : public rs, public ConsumerFEC {
    * not make any sense to build the source block, since we received all the
    * source packet of the block.
    */
-  std::unordered_map<uint32_t, std::vector<std::pair<buffer, uint32_t>>>
-      parked_packets_;
+  using BufferInfoArray = std::vector<RSBufferInfo>;
+  std::unordered_map<uint32_t, BufferInfoArray> parked_packets_;
 };
 
 }  // namespace fec
diff --git a/libtransport/src/protocols/fec_base.h b/libtransport/src/protocols/fec_base.h
index a1929d85e..bda3ee756 100644
--- a/libtransport/src/protocols/fec_base.h
+++ b/libtransport/src/protocols/fec_base.h
@@ -15,6 +15,7 @@
 
 #pragma once
 
+#include <hicn/transport/core/asio_wrapper.h>
 #include <hicn/transport/core/content_object.h>
 #include <hicn/transport/errors/not_implemented_exception.h>
 
@@ -25,12 +26,67 @@ namespace protocol {
 
 namespace fec {
 
-using buffer = typename utils::MemBuf::Ptr;
-using BufferArray = std::vector<std::pair<uint32_t, buffer>>;
+using buffer = utils::MemBuf::Ptr;
+
+class FECBufferInfo {
+ public:
+  FECBufferInfo()
+      : index_(~0), metadata_(~0), received_(false), buffer_(nullptr) {}
+
+  template <typename T>
+  FECBufferInfo(uint32_t index, uint32_t metadata, T &&buffer)
+      : index_(index),
+        metadata_(metadata),
+        received_(false),
+        buffer_(std::forward<T>(buffer)) {}
+
+  // Getters
+  uint32_t getIndex() const { return index_; }
+
+  uint32_t getMetadata() const { return metadata_; }
+
+  bool getReceived() const { return received_; }
+
+  buffer &getBuffer() { return buffer_; }
+
+  // Setters
+  void setReceived() { received_ = true; }
+
+  FECBufferInfo &setIndex(uint32_t index) {
+    index_ = index;
+    return *this;
+  }
+
+  FECBufferInfo &setMetadata(uint32_t metadata) {
+    metadata_ = metadata;
+    return *this;
+  }
+
+  FECBufferInfo &setBuffer(buffer &buffer) {
+    buffer_ = buffer;
+    return *this;
+  }
+
+  FECBufferInfo &setBuffer(buffer &&buffer) {
+    buffer_ = std::move(buffer);
+    return *this;
+  }
+
+ private:
+  uint32_t index_;
+  uint32_t metadata_;
+  bool received_;
+  buffer buffer_;
+};
+
+using BufferArray = typename std::vector<FECBufferInfo>;
 
 class FECBase {
  public:
-  virtual ~FECBase() = default;
+  static inline uint32_t INVALID_METADATA = ~0;
+  static inline uint32_t INVALID_INDEX = ~0;
+
+  virtual ~FECBase() {}
   /**
    * Callback to be called after the encode or the decode operations. In the
    * former case it will contain the symbols, while in the latter the sources.
@@ -64,11 +120,21 @@ class FECBase {
     buffer_callback_ = buffer_callback;
   }
 
+  /**
+   * Creates the timer to flush packets. So far needed only if using Rely and
+   * want to avoid expired packets blocked by missing pkts to wait for a new
+   * packet to arrive and trigger the flush
+   */
+  void setIOService(asio::io_service &io_service) {
+    flush_timer_ = std::make_unique<asio::steady_timer>(io_service);
+  }
+
   virtual void reset() = 0;
 
  protected:
   PacketsReady fec_callback_{0};
   BufferRequested buffer_callback_{0};
+  std::unique_ptr<asio::steady_timer> flush_timer_;
 };
 
 /**
@@ -80,8 +146,9 @@ class ProducerFEC : public virtual FECBase {
   /**
    * Producers will call this function upon production of a new packet.
    */
-  virtual void onPacketProduced(core::ContentObject &content_object,
-                                uint32_t offset) = 0;
+  virtual void onPacketProduced(
+      core::ContentObject &content_object, uint32_t offset,
+      uint32_t metadata = FECBase::INVALID_METADATA) = 0;
 };
 
 /**
@@ -95,9 +162,10 @@ class ConsumerFEC : public virtual FECBase {
    * Consumers will call this function when they receive a data packet
    */
   virtual void onDataPacket(core::ContentObject &content_object,
-                            uint32_t offset) = 0;
+                            uint32_t offset,
+                            uint32_t metadata = FECBase::INVALID_METADATA) = 0;
 };
 
 }  // namespace fec
 }  // namespace protocol
-}  // namespace transport
\ No newline at end of file
+}  // namespace transport
diff --git a/libtransport/src/protocols/incremental_indexer_bytestream.cc b/libtransport/src/protocols/incremental_indexer_bytestream.cc
index cc302a98a..b94f229e5 100644
--- a/libtransport/src/protocols/incremental_indexer_bytestream.cc
+++ b/libtransport/src/protocols/incremental_indexer_bytestream.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -29,9 +29,9 @@ void IncrementalIndexer::onContentObject(core::Interest &interest,
   DLOG_IF(INFO, VLOG_IS_ON(3))
       << "Received content " << content_object.getName();
 
-  assert(reassembly_);
+  DCHECK(reassembly_);
 
-  if (TRANSPORT_EXPECT_FALSE(content_object.testRst())) {
+  if (TRANSPORT_EXPECT_FALSE(content_object.isLast())) {
     final_suffix_ = content_object.getName().getSuffix();
   }
 
diff --git a/libtransport/src/protocols/incremental_indexer_bytestream.h b/libtransport/src/protocols/incremental_indexer_bytestream.h
index c6a669629..422e49ecd 100644
--- a/libtransport/src/protocols/incremental_indexer_bytestream.h
+++ b/libtransport/src/protocols/incremental_indexer_bytestream.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -62,7 +62,7 @@ class IncrementalIndexer : public Indexer {
     next_reassembly_suffix_ = first_suffix_;
   }
 
-  virtual uint32_t checkNextSuffix() override {
+  virtual uint32_t checkNextSuffix() const override {
     return next_download_suffix_ <= final_suffix_ ? next_download_suffix_
                                                   : Indexer::invalid_index;
   }
@@ -76,7 +76,7 @@ class IncrementalIndexer : public Indexer {
     first_suffix_ = suffix;
   }
 
-  uint32_t getFirstSuffix() override { return first_suffix_; }
+  uint32_t getFirstSuffix() const override { return first_suffix_; }
 
   virtual uint32_t jumpToIndex(uint32_t index) override {
     next_download_suffix_ = index;
@@ -95,14 +95,14 @@ class IncrementalIndexer : public Indexer {
     return final_suffix_ != Indexer::invalid_index;
   }
 
-  virtual uint32_t getFinalSuffix() override { return final_suffix_; }
+  virtual uint32_t getFinalSuffix() const override { return final_suffix_; }
 
   void enableFec(fec::FECType fec_type) override {}
 
   void disableFec() override {}
 
   void setNFec(uint32_t n_fec) override {}
-  virtual uint32_t getNFec() override { return 0; }
+  virtual uint32_t getNFec() const override { return 0; }
 
   virtual void onContentObject(core::Interest &interest,
                                core::ContentObject &content_object,
diff --git a/libtransport/src/protocols/index_manager_bytestream.cc b/libtransport/src/protocols/index_manager_bytestream.cc
index c78dc634d..952f36e0e 100644
--- a/libtransport/src/protocols/index_manager_bytestream.cc
+++ b/libtransport/src/protocols/index_manager_bytestream.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/protocols/index_manager_bytestream.h b/libtransport/src/protocols/index_manager_bytestream.h
index e14c8845b..7ea31dfa5 100644
--- a/libtransport/src/protocols/index_manager_bytestream.h
+++ b/libtransport/src/protocols/index_manager_bytestream.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -40,7 +40,9 @@ class IndexManager : public IncrementalIndexer {
     indexer_->setFirstSuffix(suffix);
   }
 
-  uint32_t getFirstSuffix() override { return indexer_->getFirstSuffix(); }
+  uint32_t getFirstSuffix() const override {
+    return indexer_->getFirstSuffix();
+  }
 
   uint32_t getNextReassemblySegment() override {
     return indexer_->getNextReassemblySegment();
@@ -50,22 +52,26 @@ class IndexManager : public IncrementalIndexer {
     return indexer_->isFinalSuffixDiscovered();
   }
 
-  uint32_t getFinalSuffix() override { return indexer_->getFinalSuffix(); }
+  uint32_t getFinalSuffix() const override {
+    return indexer_->getFinalSuffix();
+  }
 
   uint32_t jumpToIndex(uint32_t index) override {
     return indexer_->jumpToIndex(index);
   }
 
   void setNFec(uint32_t n_fec) override { return indexer_->setNFec(n_fec); }
-  uint32_t getNFec() override { return indexer_->getNFec(); }
+  uint32_t getNFec() const override { return indexer_->getNFec(); }
 
   void enableFec(fec::FECType fec_type) override {
     return indexer_->enableFec(fec_type);
   }
 
-  double getFecOverhead() override { return indexer_->getFecOverhead(); }
+  double getFecOverhead() const override { return indexer_->getFecOverhead(); }
 
-  double getMaxFecOverhead() override { return indexer_->getMaxFecOverhead(); }
+  double getMaxFecOverhead() const override {
+    return indexer_->getMaxFecOverhead();
+  }
 
   void disableFec() override { return indexer_->disableFec(); }
 
diff --git a/libtransport/src/protocols/indexer.cc b/libtransport/src/protocols/indexer.cc
index 8d4cf04d7..41465755b 100644
--- a/libtransport/src/protocols/indexer.cc
+++ b/libtransport/src/protocols/indexer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,10 +14,10 @@
  */
 
 #include <implementation/socket_consumer.h>
+#include <protocols/errors.h>
 #include <protocols/indexer.h>
 
 namespace transport {
-
 namespace protocol {
 
 using namespace interface;
@@ -36,6 +36,35 @@ void Indexer::setVerifier() {
   }
 }
 
-}  // end namespace protocol
+void Indexer::applyPolicy(core::Interest &interest,
+                          core::ContentObject &content_object, bool reassembly,
+                          auth::VerificationPolicy policy) const {
+  DCHECK(reassembly_ != nullptr);
+
+  switch (policy) {
+    case auth::VerificationPolicy::ACCEPT: {
+      if (reassembly) {
+        reassembly_->reassemble(content_object);
+      }
+      break;
+    }
+    case auth::VerificationPolicy::UNKNOWN:
+      if (reassembly && reassembly_->reassembleUnverified()) {
+        reassembly_->reassemble(content_object);
+      }
+      break;
+    case auth::VerificationPolicy::DROP:
+      transport_->onPacketDropped(
+          interest, content_object,
+          make_error_code(protocol_error::verification_failed));
+      break;
+    case auth::VerificationPolicy::ABORT: {
+      transport_->onContentReassembled(
+          make_error_code(protocol_error::session_aborted));
+      break;
+    }
+  }
+}
 
+}  // end namespace protocol
 }  // end namespace transport
diff --git a/libtransport/src/protocols/indexer.h b/libtransport/src/protocols/indexer.h
index 7e3a52fb0..1bacb13aa 100644
--- a/libtransport/src/protocols/indexer.h
+++ b/libtransport/src/protocols/indexer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -15,6 +15,7 @@
 
 #pragma once
 
+#include <hicn/transport/auth/policies.h>
 #include <hicn/transport/core/content_object.h>
 #include <hicn/transport/core/interest.h>
 #include <protocols/fec_utils.h>
@@ -44,7 +45,7 @@ class Indexer {
   /**
    * Suffix getters
    */
-  virtual uint32_t checkNextSuffix() = 0;
+  virtual uint32_t checkNextSuffix() const = 0;
   virtual uint32_t getNextSuffix() = 0;
   virtual uint32_t getNextReassemblySegment() = 0;
 
@@ -52,24 +53,24 @@ class Indexer {
    * Set first suffix from where to start.
    */
   virtual void setFirstSuffix(uint32_t suffix) = 0;
-  virtual uint32_t getFirstSuffix() = 0;
+  virtual uint32_t getFirstSuffix() const = 0;
 
   /**
    * Functions to set/enable/disable fec
    */
   virtual void setNFec(uint32_t n_fec) = 0;
-  virtual uint32_t getNFec() = 0;
+  virtual uint32_t getNFec() const = 0;
   virtual void enableFec(fec::FECType fec_type) = 0;
   virtual void disableFec() = 0;
   virtual bool isFec(uint32_t index) { return false; }
-  virtual double getFecOverhead() { return 0.0; }
-  virtual double getMaxFecOverhead() { return 0.0; }
+  virtual double getFecOverhead() const { return 0.0; }
+  virtual double getMaxFecOverhead() const { return 0.0; }
 
   /**
    * Final suffix helpers.
    */
   virtual bool isFinalSuffixDiscovered() = 0;
-  virtual uint32_t getFinalSuffix() = 0;
+  virtual uint32_t getFinalSuffix() const = 0;
 
   /**
    * Set reassembly protocol
@@ -84,9 +85,15 @@ class Indexer {
   virtual void setVerifier();
 
   /**
+   * Apply a verification policy
+   */
+  virtual void applyPolicy(core::Interest &interest,
+                           core::ContentObject &content_object, bool reassembly,
+                           auth::VerificationPolicy policy) const;
+  /**
    * Jump to suffix. This may be useful if, for any protocol dependent
-   * mechanism, we need to suddenly change current suffix. This does not modify
-   * the way suffixes re incremented/decremented (that's part of the
+   * mechanism, we need to suddenly change current suffix. This does not
+   * modify the way suffixes re incremented/decremented (that's part of the
    * implementation).
    */
   virtual uint32_t jumpToIndex(uint32_t index) = 0;
@@ -108,6 +115,7 @@ class Indexer {
   TransportProtocol *transport_;
   Reassembly *reassembly_;
   std::shared_ptr<auth::Verifier> verifier_;
+  auth::CryptoHashType manifest_hash_type_;
 };
 
 }  // end namespace protocol
diff --git a/libtransport/src/protocols/manifest_incremental_indexer_bytestream.cc b/libtransport/src/protocols/manifest_incremental_indexer_bytestream.cc
index 168aa57af..b5ab8184f 100644
--- a/libtransport/src/protocols/manifest_incremental_indexer_bytestream.cc
+++ b/libtransport/src/protocols/manifest_incremental_indexer_bytestream.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -31,8 +31,7 @@ ManifestIncrementalIndexer::ManifestIncrementalIndexer(
     implementation::ConsumerSocket *icn_socket, TransportProtocol *transport)
     : IncrementalIndexer(icn_socket, transport),
       suffix_strategy_(utils::SuffixStrategyFactory::getSuffixStrategy(
-          NextSegmentCalculationStrategy::INCREMENTAL, next_download_suffix_,
-          0)) {}
+          utils::NextSuffixStrategy::INCREMENTAL, next_download_suffix_)) {}
 
 void ManifestIncrementalIndexer::onContentObject(
     core::Interest &interest, core::ContentObject &content_object,
@@ -59,12 +58,7 @@ void ManifestIncrementalIndexer::onContentObject(
 void ManifestIncrementalIndexer::onUntrustedManifest(
     core::Interest &interest, core::ContentObject &content_object,
     bool reassembly) {
-  auto manifest =
-      std::make_unique<ContentObjectManifest>(std::move(content_object));
-
-  auth::VerificationPolicy policy = verifier_->verifyPackets(manifest.get());
-
-  manifest->decode();
+  auth::VerificationPolicy policy = verifier_->verifyPackets(&content_object);
 
   if (policy != auth::VerificationPolicy::ACCEPT) {
     transport_->onContentReassembled(
@@ -72,6 +66,10 @@ void ManifestIncrementalIndexer::onUntrustedManifest(
     return;
   }
 
+  auto manifest =
+      std::make_unique<ContentObjectManifest>(std::move(content_object));
+  manifest->decode();
+
   processTrustedManifest(interest, std::move(manifest), reassembly);
 }
 
@@ -83,9 +81,10 @@ void ManifestIncrementalIndexer::processTrustedManifest(
     throw errors::RuntimeException("Received manifest with unknown version.");
   }
 
-  switch (manifest->getManifestType()) {
+  switch (manifest->getType()) {
     case core::ManifestType::INLINE_MANIFEST: {
-      suffix_strategy_->setFinalSuffix(manifest->getFinalBlockNumber());
+      suffix_strategy_->setFinalSuffix(
+          manifest->getParamsBytestream().final_segment);
 
       // The packets to verify with the received manifest
       std::vector<auth::PacketPtr> packets;
@@ -162,45 +161,15 @@ void ManifestIncrementalIndexer::onUntrustedContentObject(
   applyPolicy(interest, content_object, reassembly, policy);
 }
 
-void ManifestIncrementalIndexer::applyPolicy(
-    core::Interest &interest, core::ContentObject &content_object,
-    bool reassembly, auth::VerificationPolicy policy) {
-  assert(reassembly_);
-  switch (policy) {
-    case auth::VerificationPolicy::ACCEPT: {
-      if (reassembly && !reassembly_->reassembleUnverified()) {
-        reassembly_->reassemble(content_object);
-      }
-      break;
-    }
-    case auth::VerificationPolicy::DROP: {
-      transport_->onPacketDropped(
-          interest, content_object,
-          make_error_code(protocol_error::verification_failed));
-      break;
-    }
-    case auth::VerificationPolicy::ABORT: {
-      transport_->onContentReassembled(
-          make_error_code(protocol_error::session_aborted));
-      break;
-    }
-    case auth::VerificationPolicy::UNKNOWN: {
-      if (reassembly && reassembly_->reassembleUnverified()) {
-        reassembly_->reassemble(content_object);
-      }
-    }
-  }
-}
-
-uint32_t ManifestIncrementalIndexer::checkNextSuffix() {
-  return suffix_strategy_->getNextSuffix();
+uint32_t ManifestIncrementalIndexer::checkNextSuffix() const {
+  return suffix_strategy_->checkNextSuffix();
 }
 
 uint32_t ManifestIncrementalIndexer::getNextSuffix() {
   auto ret = suffix_strategy_->getNextSuffix();
 
   if (ret <= suffix_strategy_->getFinalSuffix() &&
-      ret != utils::SuffixStrategy::INVALID_SUFFIX) {
+      ret != utils::SuffixStrategy::MAX_SUFFIX) {
     suffix_queue_.push(ret);
     return ret;
   }
@@ -208,7 +177,7 @@ uint32_t ManifestIncrementalIndexer::getNextSuffix() {
   return Indexer::invalid_index;
 }
 
-uint32_t ManifestIncrementalIndexer::getFinalSuffix() {
+uint32_t ManifestIncrementalIndexer::getFinalSuffix() const {
   return suffix_strategy_->getFinalSuffix();
 }
 
diff --git a/libtransport/src/protocols/manifest_incremental_indexer_bytestream.h b/libtransport/src/protocols/manifest_incremental_indexer_bytestream.h
index d8cf5892f..12876f35c 100644
--- a/libtransport/src/protocols/manifest_incremental_indexer_bytestream.h
+++ b/libtransport/src/protocols/manifest_incremental_indexer_bytestream.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -39,8 +39,7 @@ class ManifestIncrementalIndexer : public IncrementalIndexer {
   ManifestIncrementalIndexer(IncrementalIndexer &&indexer)
       : IncrementalIndexer(std::move(indexer)),
         suffix_strategy_(utils::SuffixStrategyFactory::getSuffixStrategy(
-            core::NextSegmentCalculationStrategy::INCREMENTAL,
-            next_download_suffix_, 0)) {
+            utils::NextSuffixStrategy::INCREMENTAL, next_download_suffix_)) {
     for (uint32_t i = first_suffix_; i < next_download_suffix_; i++) {
       suffix_queue_.push(i);
     }
@@ -54,7 +53,7 @@ class ManifestIncrementalIndexer : public IncrementalIndexer {
                        core::ContentObject &content_object,
                        bool reassembly) override;
 
-  uint32_t checkNextSuffix() override;
+  uint32_t checkNextSuffix() const override;
 
   uint32_t getNextSuffix() override;
 
@@ -62,7 +61,7 @@ class ManifestIncrementalIndexer : public IncrementalIndexer {
 
   bool isFinalSuffixDiscovered() override;
 
-  uint32_t getFinalSuffix() override;
+  uint32_t getFinalSuffix() const override;
 
  protected:
   std::unique_ptr<utils::SuffixStrategy> suffix_strategy_;
@@ -82,9 +81,6 @@ class ManifestIncrementalIndexer : public IncrementalIndexer {
   void onUntrustedContentObject(core::Interest &interest,
                                 core::ContentObject &content_object,
                                 bool reassembly);
-  void applyPolicy(core::Interest &interest,
-                   core::ContentObject &content_object, bool reassembly,
-                   auth::VerificationPolicy policy);
 };
 
 }  // end namespace protocol
diff --git a/libtransport/src/protocols/prod_protocol_bytestream.cc b/libtransport/src/protocols/prod_protocol_bytestream.cc
index f659cb37c..2a3ec07e1 100644
--- a/libtransport/src/protocols/prod_protocol_bytestream.cc
+++ b/libtransport/src/protocols/prod_protocol_bytestream.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -29,12 +29,7 @@ ByteStreamProductionProtocol::ByteStreamProductionProtocol(
     implementation::ProducerSocket *icn_socket)
     : ProductionProtocol(icn_socket) {}
 
-ByteStreamProductionProtocol::~ByteStreamProductionProtocol() {
-  stop();
-  if (listening_thread_.joinable()) {
-    listening_thread_.join();
-  }
-}
+ByteStreamProductionProtocol::~ByteStreamProductionProtocol() { stop(); }
 
 uint32_t ByteStreamProductionProtocol::produceDatagram(
     const Name &content_name, std::unique_ptr<utils::MemBuf> &&buffer) {
@@ -68,16 +63,16 @@ uint32_t ByteStreamProductionProtocol::produceStream(
     return 0;
   }
 
-  Name name(content_name);
-
-  // Get the atomic variables to ensure they keep the same value
-  // during the production
-
   // Total size of the data packet
   uint32_t data_packet_size;
   socket_->getSocketOption(GeneralTransportOptions::DATA_PACKET_SIZE,
                            data_packet_size);
 
+  // Maximum size of a segment
+  uint32_t max_segment_size;
+  socket_->getSocketOption(GeneralTransportOptions::MAX_SEGMENT_SIZE,
+                           max_segment_size);
+
   // Expiry time
   uint32_t content_object_expiry_time;
   socket_->getSocketOption(GeneralTransportOptions::CONTENT_OBJECT_EXPIRY_TIME,
@@ -88,106 +83,90 @@ uint32_t ByteStreamProductionProtocol::produceStream(
   socket_->getSocketOption(GeneralTransportOptions::HASH_ALGORITHM, hash_algo);
 
   // Suffix calculation strategy
-  core::NextSegmentCalculationStrategy _suffix_strategy;
+  std::shared_ptr<utils::SuffixStrategy> suffix_strategy;
   socket_->getSocketOption(GeneralTransportOptions::SUFFIX_STRATEGY,
-                           _suffix_strategy);
-  auto suffix_strategy = utils::SuffixStrategyFactory::getSuffixStrategy(
-      _suffix_strategy, start_offset);
+                           suffix_strategy);
+  suffix_strategy->reset(start_offset);
 
-  auto buffer_size = buffer->length();
+  // Default format
+  core::Packet::Format default_format;
+  socket_->getSocketOption(GeneralTransportOptions::PACKET_FORMAT,
+                           default_format);
+
+  Name name(content_name);
+  size_t buffer_size = buffer->length();
+  size_t signature_length = signer_->getSignatureFieldSize();
+  uint32_t final_block_number = start_offset;
+
+  // Content-related
+  core::Packet::Format content_format;
+  uint32_t content_header_size;
+  uint64_t content_free_space;
+  uint32_t nb_segments;
   int bytes_segmented = 0;
-  std::size_t header_size;
-  std::size_t manifest_header_size = 0;
-  std::size_t signature_length = 0;
-  std::uint32_t final_block_number = start_offset;
-  uint64_t free_space_for_content = 0;
 
-  core::Packet::Format format;
+  // Manifest-related
+  core::Packet::Format manifest_format;
+  uint32_t manifest_header_size;
+  uint64_t manifest_free_space;
+  uint32_t nb_manifests;
   std::shared_ptr<core::ContentObjectManifest> manifest;
+  uint32_t manifest_capacity = making_manifest_;
   bool is_last_manifest = false;
-
-  // TODO Manifest may still be used for indexing
-  if (making_manifest_ && !signer_) {
-    LOG(FATAL) << "Making manifests without setting producer identity.";
-  }
-
-  core::Packet::Format hf_format = core::Packet::Format::HF_UNSPEC;
-  core::Packet::Format hf_format_ah = core::Packet::Format::HF_UNSPEC;
-
-  if (name.getType() == HNT_CONTIGUOUS_V4 || name.getType() == HNT_IOV_V4) {
-    hf_format = core::Packet::Format::HF_INET_TCP;
-    hf_format_ah = core::Packet::Format::HF_INET_TCP_AH;
-  } else if (name.getType() == HNT_CONTIGUOUS_V6 ||
-             name.getType() == HNT_IOV_V6) {
-    hf_format = core::Packet::Format::HF_INET6_TCP;
-    hf_format_ah = core::Packet::Format::HF_INET6_TCP_AH;
-  } else {
-    throw errors::RuntimeException("Unknown name format.");
-  }
-
-  format = hf_format;
-  if (making_manifest_) {
-    manifest_header_size = core::Packet::getHeaderSizeFromFormat(
-        signer_ ? hf_format_ah : hf_format,
-        signer_ ? signer_->getSignatureFieldSize() : 0);
-  } else if (signer_) {
-    format = hf_format_ah;
-    signature_length = signer_->getSignatureFieldSize();
+  ParamsBytestream transport_params;
+
+  manifest_format = Packet::toAHFormat(default_format);
+  content_format =
+      !making_manifest_ ? Packet::toAHFormat(default_format) : default_format;
+
+  content_header_size =
+      core::Packet::getHeaderSizeFromFormat(content_format, signature_length);
+  manifest_header_size =
+      core::Packet::getHeaderSizeFromFormat(manifest_format, signature_length);
+  content_free_space =
+      std::min(max_segment_size, data_packet_size - content_header_size);
+  manifest_free_space =
+      std::min(max_segment_size, data_packet_size - manifest_header_size);
+
+  // Compute the number of segments the data will be split into
+  nb_segments =
+      uint32_t(std::ceil(double(buffer_size) / double(content_free_space)));
+  if (content_free_space * nb_segments < buffer_size) {
+    nb_segments++;
   }
 
-  header_size = core::Packet::getHeaderSizeFromFormat(format, signature_length);
-  free_space_for_content = data_packet_size - header_size;
-  uint32_t number_of_segments =
-      uint32_t(std::ceil(double(buffer_size) / double(free_space_for_content)));
-  if (free_space_for_content * number_of_segments < buffer_size) {
-    number_of_segments++;
-  }
-
-  // TODO allocate space for all the headers
   if (making_manifest_) {
-    uint32_t segment_in_manifest = static_cast<uint32_t>(
-        std::floor(double(data_packet_size - manifest_header_size -
-                          ContentObjectManifest::getManifestHeaderSize()) /
-                   ContentObjectManifest::getManifestEntrySize()) -
-        1.0);
-    uint32_t number_of_manifests = static_cast<uint32_t>(
-        std::ceil(float(number_of_segments) / segment_in_manifest));
-    final_block_number += number_of_segments + number_of_manifests - 1;
+    nb_manifests = static_cast<uint32_t>(
+        std::ceil(float(nb_segments) / manifest_capacity));
+    final_block_number += nb_segments + nb_manifests - 1;
+    transport_params.final_segment =
+        is_last ? final_block_number : utils::SuffixStrategy::MAX_SUFFIX;
 
     manifest.reset(ContentObjectManifest::createManifest(
+        manifest_format,
         name.setSuffix(suffix_strategy->getNextManifestSuffix()),
         core::ManifestVersion::VERSION_1, core::ManifestType::INLINE_MANIFEST,
-        hash_algo, is_last_manifest, name, _suffix_strategy,
-        signer_ ? signer_->getSignatureFieldSize() : 0));
-    manifest->setLifetime(content_object_expiry_time);
+        is_last_manifest, name, hash_algo, signature_length));
 
-    if (is_last) {
-      manifest->setFinalBlockNumber(final_block_number);
-    } else {
-      manifest->setFinalBlockNumber(utils::SuffixStrategy::INVALID_SUFFIX);
-    }
+    manifest->setLifetime(content_object_expiry_time);
+    manifest->setParamsBytestream(transport_params);
   }
 
-  for (unsigned int packaged_segments = 0;
-       packaged_segments < number_of_segments; packaged_segments++) {
+  auto self = shared_from_this();
+  for (unsigned int packaged_segments = 0; packaged_segments < nb_segments;
+       packaged_segments++) {
     if (making_manifest_) {
-      if (manifest->estimateManifestSize(2) >
-          data_packet_size - manifest_header_size) {
+      if (manifest->estimateManifestSize(1) > manifest_free_space) {
         manifest->encode();
-
-        // If identity set, sign manifest
-        if (signer_) {
-          signer_->signPacket(manifest.get());
-        }
+        signer_->signPacket(manifest.get());
 
         // Send the current manifest
-        passContentObjectToCallbacks(manifest);
-
+        passContentObjectToCallbacks(manifest, self);
         DLOG_IF(INFO, VLOG_IS_ON(3)) << "Send manifest " << manifest->getName();
 
         // Send content objects stored in the queue
         while (!content_queue_.empty()) {
-          passContentObjectToCallbacks(content_queue_.front());
+          passContentObjectToCallbacks(content_queue_.front(), self);
           DLOG_IF(INFO, VLOG_IS_ON(3))
               << "Send content " << content_queue_.front()->getName();
           content_queue_.pop();
@@ -195,86 +174,84 @@ uint32_t ByteStreamProductionProtocol::produceStream(
 
         // Create new manifest. The reference to the last manifest has been
         // acquired in the passContentObjectToCallbacks function, so we can
-        // safely release this reference
+        // safely release this reference.
         manifest.reset(ContentObjectManifest::createManifest(
+            manifest_format,
             name.setSuffix(suffix_strategy->getNextManifestSuffix()),
             core::ManifestVersion::VERSION_1,
-            core::ManifestType::INLINE_MANIFEST, hash_algo, is_last_manifest,
-            name, _suffix_strategy,
-            signer_ ? signer_->getSignatureFieldSize() : 0));
+            core::ManifestType::INLINE_MANIFEST, is_last_manifest, name,
+            hash_algo, signature_length));
 
         manifest->setLifetime(content_object_expiry_time);
-        manifest->setFinalBlockNumber(
-            is_last ? final_block_number
-                    : utils::SuffixStrategy::INVALID_SUFFIX);
+        manifest->setParamsBytestream(transport_params);
       }
     }
 
-    auto content_suffix = suffix_strategy->getNextContentSuffix();
+    // Create content object
+    uint32_t content_suffix = suffix_strategy->getNextContentSuffix();
     auto content_object = std::make_shared<ContentObject>(
-        name.setSuffix(content_suffix), format,
-        signer_ && !making_manifest_ ? signer_->getSignatureFieldSize() : 0);
+        name.setSuffix(content_suffix), content_format,
+        !making_manifest_ ? signature_length : 0);
     content_object->setLifetime(content_object_expiry_time);
 
     auto b = buffer->cloneOne();
-    b->trimStart(free_space_for_content * packaged_segments);
+    b->trimStart(content_free_space * packaged_segments);
     b->trimEnd(b->length());
 
-    if (TRANSPORT_EXPECT_FALSE(packaged_segments == number_of_segments - 1)) {
+    // Segment the input data
+    if (TRANSPORT_EXPECT_FALSE(packaged_segments == nb_segments - 1)) {
       b->append(buffer_size - bytes_segmented);
       bytes_segmented += (int)(buffer_size - bytes_segmented);
 
       if (is_last && making_manifest_) {
         is_last_manifest = true;
       } else if (is_last) {
-        content_object->setRst();
+        content_object->setLast();
       }
 
     } else {
-      b->append(free_space_for_content);
-      bytes_segmented += (int)(free_space_for_content);
+      b->append(content_free_space);
+      bytes_segmented += (int)(content_free_space);
     }
 
+    // Set the segmented data as payload
     content_object->appendPayload(std::move(b));
 
+    // Either we sign the content object or we save its hash into the current
+    // manifest
     if (making_manifest_) {
-      using namespace std::chrono_literals;
       auth::CryptoHash hash = content_object->computeDigest(hash_algo);
       manifest->addSuffixHash(content_suffix, hash);
       content_queue_.push(content_object);
     } else {
-      if (signer_) {
-        signer_->signPacket(content_object.get());
-      }
-      passContentObjectToCallbacks(content_object);
+      signer_->signPacket(content_object.get());
+      passContentObjectToCallbacks(content_object, self);
       DLOG_IF(INFO, VLOG_IS_ON(3))
           << "Send content " << content_object->getName();
     }
   }
 
+  // We send the manifest that hasn't been fully filled yet
   if (making_manifest_) {
     if (is_last_manifest) {
-      manifest->setFinalManifest(is_last_manifest);
+      manifest->setIsLast(is_last_manifest);
     }
 
     manifest->encode();
+    signer_->signPacket(manifest.get());
 
-    if (signer_) {
-      signer_->signPacket(manifest.get());
-    }
-
-    passContentObjectToCallbacks(manifest);
+    passContentObjectToCallbacks(manifest, self);
     DLOG_IF(INFO, VLOG_IS_ON(3)) << "Send manifest " << manifest->getName();
 
     while (!content_queue_.empty()) {
-      passContentObjectToCallbacks(content_queue_.front());
+      passContentObjectToCallbacks(content_queue_.front(), self);
       DLOG_IF(INFO, VLOG_IS_ON(3))
           << "Send content " << content_queue_.front()->getName();
       content_queue_.pop();
     }
   }
 
-  portal_->getIoService().post([this]() {
+  portal_->getThread().add([this, self]() {
     std::shared_ptr<ContentObject> co;
     while (object_queue_for_callbacks_.pop(co)) {
       if (*on_new_segment_) {
@@ -296,7 +273,7 @@ uint32_t ByteStreamProductionProtocol::produceStream(
     }
   });
 
-  portal_->getIoService().dispatch([this, buffer_size]() {
+  portal_->getThread().add([this, buffer_size, self]() {
     if (*on_content_produced_) {
       on_content_produced_->operator()(*socket_->getInterface(),
                                        std::make_error_code(std::errc(0)),
@@ -307,9 +284,10 @@ uint32_t ByteStreamProductionProtocol::produceStream(
   return suffix_strategy->getTotalCount();
 }
 
-void ByteStreamProductionProtocol::scheduleSendBurst() {
-  portal_->getIoService().post([this]() {
-    std::shared_ptr<ContentObject> co;
+void ByteStreamProductionProtocol::scheduleSendBurst(
+    const std::shared_ptr<ByteStreamProductionProtocol> &self) {
+  portal_->getThread().add([this, self]() {
+    ContentObject::Ptr co;
 
     for (uint32_t i = 0; i < burst_size; i++) {
       if (object_queue_for_callbacks_.pop(co)) {
@@ -321,11 +299,15 @@ void ByteStreamProductionProtocol::scheduleSendBurst() {
           on_content_object_to_sign_->operator()(*socket_->getInterface(), *co);
         }
 
+        output_buffer_.insert(co);
+
         if (*on_content_object_in_output_buffer_) {
           on_content_object_in_output_buffer_->operator()(
               *socket_->getInterface(), *co);
         }
 
+        portal_->sendContentObject(*co);
+
         if (*on_content_object_output_) {
           on_content_object_output_->operator()(*socket_->getInterface(), *co);
         }
@@ -337,13 +319,12 @@ void ByteStreamProductionProtocol::scheduleSendBurst() {
 }
 
 void ByteStreamProductionProtocol::passContentObjectToCallbacks(
-    const std::shared_ptr<ContentObject> &content_object) {
-  output_buffer_.insert(content_object);
-  portal_->sendContentObject(*content_object);
+    const std::shared_ptr<ContentObject> &content_object,
+    const std::shared_ptr<ByteStreamProductionProtocol> &self) {
   object_queue_for_callbacks_.push(std::move(content_object));
 
   if (object_queue_for_callbacks_.size() >= burst_size) {
-    scheduleSendBurst();
+    scheduleSendBurst(self);
   }
 }
 
@@ -376,7 +357,5 @@ void ByteStreamProductionProtocol::onInterest(Interest &interest) {
   }
 }
 
-void ByteStreamProductionProtocol::onError(std::error_code ec) {}
-
 }  // namespace protocol
 }  // end namespace transport
diff --git a/libtransport/src/protocols/prod_protocol_bytestream.h b/libtransport/src/protocols/prod_protocol_bytestream.h
index cf36b90a5..809ad8d5c 100644
--- a/libtransport/src/protocols/prod_protocol_bytestream.h
+++ b/libtransport/src/protocols/prod_protocol_bytestream.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -50,16 +50,19 @@ class ByteStreamProductionProtocol : public ProductionProtocol {
   uint32_t produceDatagram(const Name &content_name, const uint8_t *buffer,
                            size_t buffer_size) override;
 
+  auto shared_from_this() { return utils::shared_from(this); }
+
  protected:
   // Consumer Callback
   //   void reset() override;
   void onInterest(core::Interest &i) override;
-  void onError(std::error_code ec) override;
 
  private:
   void passContentObjectToCallbacks(
-      const std::shared_ptr<ContentObject> &content_object);
-  void scheduleSendBurst();
+      const std::shared_ptr<ContentObject> &content_object,
+      const std::shared_ptr<ByteStreamProductionProtocol> &self);
+  void scheduleSendBurst(
+      const std::shared_ptr<ByteStreamProductionProtocol> &self);
 
  private:
   // While manifests are being built, contents are stored in a queue
diff --git a/libtransport/src/protocols/prod_protocol_rtc.cc b/libtransport/src/protocols/prod_protocol_rtc.cc
index cdc882d81..242abd30d 100644
--- a/libtransport/src/protocols/prod_protocol_rtc.cc
+++ b/libtransport/src/protocols/prod_protocol_rtc.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,9 +13,11 @@
  * limitations under the License.
  */
 
+#include <glog/logging.h>
 #include <hicn/transport/core/global_object_pool.h>
 #include <implementation/socket_producer.h>
 #include <protocols/prod_protocol_rtc.h>
+#include <protocols/rtc/probe_handler.h>
 #include <protocols/rtc/rtc_consts.h>
 #include <stdlib.h>
 #include <time.h>
@@ -38,71 +40,89 @@ RTCProductionProtocol::RTCProductionProtocol(
       bytes_production_rate_(0),
       packets_production_rate_(0),
       fec_packets_production_rate_(0),
-      last_round_(std::chrono::duration_cast<std::chrono::milliseconds>(
-                      std::chrono::steady_clock::now().time_since_epoch())
-                      .count()),
+      last_produced_data_ts_(0),
+      last_round_(utils::SteadyTime::nowMs().count()),
       allow_delayed_nacks_(false),
       queue_timer_on_(false),
       consumer_in_sync_(false),
-      on_consumer_in_sync_(nullptr) {
-  srand((unsigned int)time(NULL));
-  prod_label_ = rand() % 256;
+      on_consumer_in_sync_(nullptr),
+      pending_fec_pace_(false),
+      max_len_(0),
+      queue_len_(0),
+      data_aggregation_(true),
+      data_aggregation_timer_switch_(false) {
+  std::uniform_int_distribution<> dis(0, 255);
+  prod_label_ = dis(gen_);
   cache_label_ = (prod_label_ + 1) % 256;
   interests_queue_timer_ =
-      std::make_unique<asio::steady_timer>(portal_->getIoService());
-  round_timer_ = std::make_unique<asio::steady_timer>(portal_->getIoService());
+      std::make_unique<asio::steady_timer>(portal_->getThread().getIoService());
+  round_timer_ =
+      std::make_unique<asio::steady_timer>(portal_->getThread().getIoService());
+  fec_pacing_timer_ =
+      std::make_unique<asio::steady_timer>(portal_->getThread().getIoService());
+  app_packets_timer_ =
+      std::make_unique<asio::steady_timer>(portal_->getThread().getIoService());
   setOutputBufferSize(10000);
-  scheduleRoundTimer();
+}
+
+RTCProductionProtocol::~RTCProductionProtocol() {}
+
+void RTCProductionProtocol::setProducerParam() {
+  // Flow name: here we assume there is only one prefix registered in the portal
+  flow_name_ = portal_->getServedNamespaces().begin()->getName();
+
+  // Manifest
+  uint32_t making_manifest;
+  socket_->getSocketOption(interface::GeneralTransportOptions::MAKE_MANIFEST,
+                           making_manifest);
+
+  // Signer
+  std::shared_ptr<auth::Signer> signer;
+  socket_->getSocketOption(interface::GeneralTransportOptions::SIGNER, signer);
+
+  // Default format
+  core::Packet::Format default_format;
+  socket_->getSocketOption(interface::GeneralTransportOptions::PACKET_FORMAT,
+                           default_format);
 
   // FEC
   using namespace std::placeholders;
   enableFEC(std::bind(&RTCProductionProtocol::onFecPackets, this, _1),
             std::bind(&RTCProductionProtocol::getBuffer, this, _1));
-}
 
-RTCProductionProtocol::~RTCProductionProtocol() {}
+  // Aggregated data
+  socket_->getSocketOption(interface::RtcTransportOptions::AGGREGATED_DATA,
+                           data_aggregation_);
 
-void RTCProductionProtocol::registerNamespaceWithNetwork(
-    const Prefix &producer_namespace) {
-  ProductionProtocol::registerNamespaceWithNetwork(producer_namespace);
-
-  flow_name_ = producer_namespace.getName();
-  auto family = flow_name_.getAddressFamily();
-
-  switch (family) {
-    case AF_INET6:
-      data_header_size_ =
-          signer_ && !making_manifest_
-              ? (uint32_t)Packet::getHeaderSizeFromFormat(
-                    HF_INET6_TCP_AH, signer_->getSignatureFieldSize())
-              : (uint32_t)Packet::getHeaderSizeFromFormat(HF_INET6_TCP);
-      ;
-      break;
-    case AF_INET:
-      data_header_size_ =
-          signer_ && !making_manifest_
-              ? (uint32_t)Packet::getHeaderSizeFromFormat(
-                    HF_INET_TCP_AH, signer_->getSignatureFieldSize())
-              : (uint32_t)Packet::getHeaderSizeFromFormat(HF_INET_TCP);
-      break;
-    default:
-      throw errors::RuntimeException("Unknown name format.");
-  }
+  size_t signature_size = signer->getSignatureFieldSize();
+  data_header_format_ = {
+      !making_manifest ? Packet::toAHFormat(default_format) : default_format,
+      !making_manifest ? signature_size : 0};
+  manifest_header_format_ = {Packet::toAHFormat(default_format),
+                             signature_size};
+  nack_header_format_ = {Packet::toAHFormat(default_format), signature_size};
+  fec_header_format_ = {Packet::toAHFormat(default_format), signature_size};
+
+  // Schedule round timer
+  scheduleRoundTimer();
 }
 
 void RTCProductionProtocol::scheduleRoundTimer() {
   round_timer_->expires_from_now(
       std::chrono::milliseconds(rtc::PRODUCER_STATS_INTERVAL));
-  round_timer_->async_wait([this](std::error_code ec) {
+  std::weak_ptr<RTCProductionProtocol> self = shared_from_this();
+  round_timer_->async_wait([self](const std::error_code &ec) {
     if (ec) return;
-    updateStats();
+
+    auto sp = self.lock();
+    if (sp && sp->isRunning()) {
+      sp->updateStats();
+    }
   });
 }
 
 void RTCProductionProtocol::updateStats() {
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
+  uint64_t now = utils::SteadyTime::nowMs().count();
   uint64_t duration = now - last_round_;
   if (duration == 0) duration = 1;
   double per_second = rtc::MILLI_IN_A_SEC / duration;
@@ -125,11 +145,12 @@ void RTCProductionProtocol::updateStats() {
   if (max_packet_production_ < rtc::WIN_MIN)
     max_packet_production_ = rtc::WIN_MIN;
 
-  if (packets_production_rate_ != 0) {
-    allow_delayed_nacks_ = false;
-  } else if (prev_packets_production_rate == 0) {
-    // at least 2 rounds with production rate = 0
+  if (packets_production_rate_ <= rtc::MIN_PRODUCTION_RATE ||
+      prev_packets_production_rate <= rtc::MIN_PRODUCTION_RATE) {
     allow_delayed_nacks_ = true;
+  } else {
+    // at least 2 rounds with enough packets
+    allow_delayed_nacks_ = false;
   }
 
   // check if the production rate is decreased. if yes send nacks if needed
@@ -170,42 +191,237 @@ uint32_t RTCProductionProtocol::produceDatagram(
   socket_->getSocketOption(interface::GeneralTransportOptions::DATA_PACKET_SIZE,
                            data_packet_size);
 
-  if (TRANSPORT_EXPECT_FALSE((buffer_size + data_header_size_ +
-                              rtc::DATA_HEADER_SIZE) > data_packet_size)) {
+  if (TRANSPORT_EXPECT_FALSE(
+          (Packet::getHeaderSizeFromFormat(data_header_format_.first,
+                                           data_header_format_.second) +
+           rtc::DATA_HEADER_SIZE + buffer_size) > data_packet_size)) {
     return 0;
   }
 
+  if (!data_aggregation_) {
+    // if data aggregation is off emptyQueue will always return doing nothing
+    emptyQueue();
+
+    sendManifest(content_name);
+
+    // create content object
+    auto content_object =
+        core::PacketManager<>::getInstance().getPacket<ContentObject>(
+            data_header_format_.first, data_header_format_.second);
+
+    // add rtc header to the payload
+    struct rtc::data_packet_t header;
+    content_object->appendPayload((const uint8_t *)&header,
+                                  rtc::DATA_HEADER_SIZE);
+    content_object->appendPayload(buffer->data(), buffer->length());
+
+    // schedule actual sending on internal thread
+    portal_->getThread().tryRunHandlerNow(
+        [this, content_object{std::move(content_object)},
+         content_name]() mutable {
+          produceInternal(std::move(content_object), content_name);
+        });
+  } else {
+    // XXX here we assume that all the packets that we push to the queue have
+    // the same name
+    auto app_pkt = utils::MemBuf::copyBuffer(buffer->data(), buffer->length());
+    addPacketToQueue(std::move(app_pkt));
+  }
+
+  return 1;
+}
+
+void RTCProductionProtocol::addPacketToQueue(
+    std::unique_ptr<utils::MemBuf> &&buffer) {
+  std::size_t buffer_size = buffer->length();
+  if ((queue_len_ + buffer_size) > rtc::MAX_RTC_PAYLOAD_SIZE) {
+    emptyQueue();  // this should guaranty that the generated packet will never
+                   // be larger than an MTU
+  }
+
+  waiting_app_packets_.push(std::move(buffer));
+  if (max_len_ < buffer_size) max_len_ = buffer_size;
+  queue_len_ += buffer_size;
+
+  if (waiting_app_packets_.size() >= rtc::MAX_AGGREGATED_PACKETS) {
+    emptyQueue();
+  }
+
+  if (waiting_app_packets_.size() >= 1 && !data_aggregation_timer_switch_) {
+    data_aggregation_timer_switch_ = true;
+    app_packets_timer_->expires_from_now(
+        std::chrono::milliseconds(rtc::AGGREGATED_PACKETS_TIMER));
+    std::weak_ptr<RTCProductionProtocol> self = shared_from_this();
+    app_packets_timer_->async_wait([self](const std::error_code &ec) {
+      if (ec) return;
+
+      auto ptr = self.lock();
+      if (ptr && ptr->isRunning()) {
+        if (!ptr->data_aggregation_timer_switch_) return;
+        ptr->emptyQueue();
+      }
+    });
+  }
+}
+
+void RTCProductionProtocol::emptyQueue() {
+  if (waiting_app_packets_.size() == 0) return;  // queue is empty
+
+  Name n(flow_name_);
+
+  // cancel timer is scheduled
+  if (data_aggregation_timer_switch_) {
+    data_aggregation_timer_switch_ = false;
+    app_packets_timer_->cancel();
+  }
+
+  // send a manifest beforehand if the hash buffer if full
+  sendManifest(n);
+
+  // create content object
   auto content_object =
       core::PacketManager<>::getInstance().getPacket<ContentObject>(
-          signer_ ? Format::HF_INET6_TCP_AH : Format::HF_INET6_TCP,
-          signer_ ? signer_->getSignatureFieldSize() : 0);
+          data_header_format_.first, data_header_format_.second);
+
   // add rtc header to the payload
   struct rtc::data_packet_t header;
   content_object->appendPayload((const uint8_t *)&header,
                                 rtc::DATA_HEADER_SIZE);
-  content_object->appendPayload(buffer->data(), buffer->length());
 
-  // schedule actual sending on internal thread
-  portal_->getIoService().dispatch([this,
-                                    content_object{std::move(content_object)},
-                                    content_name]() mutable {
-    produceInternal(std::move(content_object), content_name);
+  // init aggregated header
+  rtc::AggrPktHeader hdr(
+      (uint8_t *)(content_object->getPayload()->data() + rtc::DATA_HEADER_SIZE),
+      max_len_, waiting_app_packets_.size());
+  uint32_t header_size = hdr.getHeaderLen();
+  content_object->append(header_size);  // leave space for the aggregated header
+
+  uint8_t index = 0;
+  while (waiting_app_packets_.size() != 0) {
+    std::unique_ptr<utils::MemBuf> pkt =
+        std::move(waiting_app_packets_.front());
+    waiting_app_packets_.pop();
+    // XXX for the moment we have a single name, so this works, otherwise we
+    // need to do something else
+    hdr.addPacketToHeader(index, pkt->length());
+    // append packet
+    content_object->appendPayload(pkt->data(), pkt->length());
+    index++;
+  }
+
+  // reset queue values
+  max_len_ = 0;
+  queue_len_ = 0;
+
+  // the packet is ready we need to send it
+  portal_->getThread().tryRunHandlerNow(
+      [this, content_object{std::move(content_object)}, n]() mutable {
+        produceInternal(std::move(content_object), n);
+      });
+}
+
+void RTCProductionProtocol::sendManifest(const Name &name) {
+  if (!making_manifest_) {
+    return;
+  }
+
+  Name manifest_name(name);
+
+  uint32_t data_packet_size;
+  socket_->getSocketOption(interface::GeneralTransportOptions::DATA_PACKET_SIZE,
+                           data_packet_size);
+
+  // The maximum number of entries a manifest can hold
+  uint32_t manifest_capacity = making_manifest_;
+
+  // If there is not enough hashes to fill a manifest, return early
+  if (manifest_entries_.size() < manifest_capacity) {
+    return;
+  }
+
+  // Create a new manifest
+  std::shared_ptr<core::ContentObjectManifest> manifest =
+      createManifest(manifest_name.setSuffix(current_seg_));
+
+  // Fill the manifest with packet hashes that were previously saved
+  uint32_t nb_entries;
+  for (nb_entries = 0; nb_entries < manifest_capacity; ++nb_entries) {
+    if (manifest_entries_.empty()) {
+      break;
+    }
+    std::pair<uint32_t, auth::CryptoHash> front = manifest_entries_.front();
+    manifest->addSuffixHash(front.first, front.second);
+    manifest_entries_.pop();
+  }
+
+  DLOG_IF(INFO, VLOG_IS_ON(3))
+      << "Sending manifest " << manifest->getName().getSuffix() << " of size "
+      << nb_entries;
+
+  // Encode and send the manifest
+  manifest->encode();
+  portal_->getThread().tryRunHandlerNow(
+      [this, content_object{std::move(manifest)}, manifest_name]() mutable {
+        produceInternal(std::move(content_object), manifest_name);
+      });
+}
+
+std::shared_ptr<core::ContentObjectManifest>
+RTCProductionProtocol::createManifest(const Name &content_name) const {
+  Name name(content_name);
+
+  auth::CryptoHashType hash_algo;
+  socket_->getSocketOption(interface::GeneralTransportOptions::HASH_ALGORITHM,
+                           hash_algo);
+
+  uint64_t now = utils::SteadyTime::nowMs().count();
+
+  // Create a new manifest
+  std::shared_ptr<core::ContentObjectManifest> manifest(
+      ContentObjectManifest::createManifest(
+          manifest_header_format_.first, name, core::ManifestVersion::VERSION_1,
+          core::ManifestType::INLINE_MANIFEST, false, name, hash_algo,
+          manifest_header_format_.second));
+
+  // Set connection parameters
+  manifest->setParamsRTC(ParamsRTC{
+      .timestamp = now,
+      .prod_rate = bytes_production_rate_,
+      .prod_seg = current_seg_,
+      .support_fec = false,
   });
 
-  return 1;
+  return manifest;
 }
 
 void RTCProductionProtocol::produceInternal(
     std::shared_ptr<ContentObject> &&content_object, const Name &content_name,
     bool fec) {
+  uint64_t now = utils::SteadyTime::nowMs().count();
+
+  if (fec && (now - last_produced_data_ts_) < rtc::FEC_PACING_TIME) {
+    paced_fec_packets_.push(std::pair<uint64_t, ContentObject::Ptr>(
+        now, std::move(content_object)));
+    postponeFecPacket();
+  } else {
+    // need to check if there are FEC packets waiting to be sent
+    flushFecPkts(current_seg_);
+    producePktInternal(std::move(content_object), content_name, fec);
+  }
+}
+
+void RTCProductionProtocol::producePktInternal(
+    std::shared_ptr<ContentObject> &&content_object, const Name &content_name,
+    bool fec) {
+  bool is_manifest = content_object->getPayloadType() == PayloadType::MANIFEST;
+  uint64_t now = utils::SteadyTime::nowMs().count();
+
   // set rtc header
-  struct rtc::data_packet_t *data_pkt =
-      (struct rtc::data_packet_t *)content_object->getPayload()->data();
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
-  data_pkt->setTimestamp(now);
-  data_pkt->setProductionRate(bytes_production_rate_);
+  if (!is_manifest) {
+    struct rtc::data_packet_t *data_pkt =
+        (struct rtc::data_packet_t *)content_object->getPayload()->data();
+    data_pkt->setTimestamp(now);
+    data_pkt->setProductionRate(bytes_production_rate_);
+  }
 
   // set hicn stuff
   Name n(content_name);
@@ -213,11 +429,6 @@ void RTCProductionProtocol::produceInternal(
   content_object->setLifetime(500);  // XXX this should be set by the APP
   content_object->setPathLabel(prod_label_);
 
-  // sign packet
-  if (signer_) {
-    signer_->signPacket(content_object.get());
-  }
-
   // update stats
   if (!fec) {
     produced_bytes_ +=
@@ -227,7 +438,7 @@ void RTCProductionProtocol::produceInternal(
     produced_fec_packets_++;
   }
 
-  if (produced_packets_ >= max_packet_production_) {
+  if (!data_aggregation_ && produced_packets_ >= max_packet_production_) {
     // in this case all the pending interests may be used to accomodate the
     // sudden increase in the production rate. calling the updateStats we will
     // notify all the clients
@@ -240,8 +451,12 @@ void RTCProductionProtocol::produceInternal(
 
   // pass packet to FEC encoder
   if (fec_encoder_ && !fec) {
-    fec_encoder_->onPacketProduced(
-        *content_object, content_object->headerSize() + rtc::DATA_HEADER_SIZE);
+    uint32_t offset =
+        is_manifest ? content_object->headerSize()
+                    : content_object->headerSize() + rtc::DATA_HEADER_SIZE;
+    uint32_t metadata = static_cast<uint32_t>(content_object->getPayloadType());
+
+    fec_encoder_->onPacketProduced(*content_object, offset, metadata);
   }
 
   output_buffer_.insert(content_object);
@@ -253,7 +468,7 @@ void RTCProductionProtocol::produceInternal(
 
   auto seq_it = seqs_map_.find(current_seg_);
   if (seq_it != seqs_map_.end()) {
-    portal_->sendContentObject(*content_object);
+    sendContentObject(content_object, false, fec);
   }
 
   if (*on_content_object_output_) {
@@ -264,6 +479,8 @@ void RTCProductionProtocol::produceInternal(
   // remove interests from the interest cache if it exists
   removeFromInterestQueue(current_seg_);
 
+  if (!fec) last_produced_data_ts_ = now;
+
   // Update current segment
   current_seg_ = (current_seg_ + 1) % rtc::MIN_PROBE_SEQ;
 
@@ -277,6 +494,55 @@ void RTCProductionProtocol::produceInternal(
   }
 }
 
+void RTCProductionProtocol::flushFecPkts(uint32_t current_seq_num) {
+  // Currently we immediately send all the pending fec packets
+  // A pacing policy may be helpful, but we do not want to delay too much
+  // the packets at this moment.
+  while (paced_fec_packets_.size() > 0) {
+    producePktInternal(std::move(paced_fec_packets_.front().second), flow_name_,
+                       true);
+    paced_fec_packets_.pop();
+  }
+  fec_pacing_timer_->cancel();
+  pending_fec_pace_ = false;
+  postponeFecPacket();
+}
+
+void RTCProductionProtocol::postponeFecPacket() {
+  if (paced_fec_packets_.size() == 0) return;
+  if (pending_fec_pace_) {
+    return;
+  }
+
+  uint64_t produced_time = paced_fec_packets_.front().first;
+  uint64_t now = utils::SteadyTime::nowMs().count();
+
+  uint64_t wait_time = 0;
+  if ((produced_time + rtc::FEC_PACING_TIME) > now)
+    wait_time = produced_time + rtc::FEC_PACING_TIME - now;
+
+  fec_pacing_timer_->expires_from_now(std::chrono::milliseconds(wait_time));
+  pending_fec_pace_ = true;
+
+  std::weak_ptr<RTCProductionProtocol> self = shared_from_this();
+  fec_pacing_timer_->async_wait([self](const std::error_code &ec) {
+    if (ec) return;
+
+    auto sp = self.lock();
+    if (sp && sp->isRunning()) {
+      if (!sp->pending_fec_pace_) return;
+
+      if (sp->paced_fec_packets_.size() > 0) {
+        sp->producePktInternal(std::move(sp->paced_fec_packets_.front().second),
+                               sp->flow_name_, true);
+        sp->paced_fec_packets_.pop();
+      }
+      sp->pending_fec_pace_ = false;
+      sp->postponeFecPacket();
+    }
+  });
+}
+
 void RTCProductionProtocol::onInterest(Interest &interest) {
   if (*on_interest_input_) {
     on_interest_input_->operator()(*socket_->getInterface(), interest);
@@ -284,7 +550,7 @@ void RTCProductionProtocol::onInterest(Interest &interest) {
 
   auto suffix = interest.firstSuffix();
   // numberOfSuffixes returns only the prefixes in the payalod
-  // we add + 1 to count anche the seq in the name
+  // we add + 1 to count also the seq in the name
   auto n_suffixes = interest.numberOfSuffixes() + 1;
   Name name = interest.getName();
   bool prev_consumer_state = consumer_in_sync_;
@@ -293,6 +559,7 @@ void RTCProductionProtocol::onInterest(Interest &interest) {
     if (i > 0) {
       name.setSuffix(*(suffix + (i - 1)));
     }
+
     DLOG_IF(INFO, VLOG_IS_ON(3)) << "Received interest " << name;
 
     const std::shared_ptr<ContentObject> content_object =
@@ -312,7 +579,7 @@ void RTCProductionProtocol::onInterest(Interest &interest) {
       DLOG_IF(INFO, VLOG_IS_ON(3))
           << "Send content %u (onInterest) " << content_object->getName();
       content_object->setPathLabel(cache_label_);
-      portal_->sendContentObject(*content_object);
+      sendContentObject(content_object);
     } else {
       if (*on_interest_process_) {
         on_interest_process_->operator()(*socket_->getInterface(), interest);
@@ -332,14 +599,19 @@ void RTCProductionProtocol::processInterest(uint32_t interest_seg,
     consumer_in_sync_ = false;
   }
 
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
+  uint64_t now = utils::SteadyTime::nowMs().count();
 
-  if (interest_seg > rtc::MIN_PROBE_SEQ) {
-    DLOG_IF(INFO, VLOG_IS_ON(3)) << "Received probe " << interest_seg;
-    sendNack(interest_seg);
-    return;
+  switch (rtc::ProbeHandler::getProbeType(interest_seg)) {
+    case rtc::ProbeType::INIT:
+      DLOG_IF(INFO, VLOG_IS_ON(3)) << "Received init probe " << interest_seg;
+      sendManifestProbe(interest_seg);
+      return;
+    case rtc::ProbeType::RTT:
+      DLOG_IF(INFO, VLOG_IS_ON(3)) << "Received RTT probe " << interest_seg;
+      sendNack(interest_seg);
+      return;
+    default:
+      break;
   }
 
   // if the production rate 0 use delayed nacks
@@ -349,7 +621,7 @@ void RTCProductionProtocol::processInterest(uint32_t interest_seg,
       next_timer = timers_map_.begin()->first;
     }
 
-    uint64_t expiration = now + rtc::SENTINEL_TIMER_INTERVAL;
+    uint64_t expiration = now + rtc::NACK_DELAY;
     addToInterestQueue(interest_seg, expiration);
 
     // here we have at least one interest in the queue, we need to start or
@@ -369,8 +641,8 @@ void RTCProductionProtocol::processInterest(uint32_t interest_seg,
   }
 
   if (queue_timer_on_) {
-    // the producer is producing. Send nacks to packets that will expire before
-    // the data production and remove the timer
+    // the producer is producing. Send nacks to packets that will expire
+    // before the data production and remove the timer
     queue_timer_on_ = false;
     interests_queue_timer_->cancel();
     sendNacksForPendingInterests();
@@ -387,8 +659,8 @@ void RTCProductionProtocol::processInterest(uint32_t interest_seg,
     sendNack(interest_seg);
   } else {
     if (!consumer_in_sync_ && on_consumer_in_sync_) {
-      // we consider the remote consumer to be in sync as soon as it covers 70%
-      // of the production window with interests
+      // we consider the remote consumer to be in sync as soon as it covers
+      // 70% of the production window with interests
       uint32_t perc = ceil((double)max_gap * 0.7);
       if (interest_seg > (perc + current_seg_)) {
         consumer_in_sync_ = true;
@@ -401,13 +673,18 @@ void RTCProductionProtocol::processInterest(uint32_t interest_seg,
   }
 }
 
-void RTCProductionProtocol::onError(std::error_code ec) {}
-
 void RTCProductionProtocol::scheduleQueueTimer(uint64_t wait) {
   interests_queue_timer_->expires_from_now(std::chrono::milliseconds(wait));
-  interests_queue_timer_->async_wait([this](std::error_code ec) {
-    if (ec) return;
-    interestQueueTimer();
+  std::weak_ptr<RTCProductionProtocol> self = shared_from_this();
+  interests_queue_timer_->async_wait([self](const std::error_code &ec) {
+    if (ec) {
+      return;
+    }
+
+    auto sp = self.lock();
+    if (sp && sp->isRunning()) {
+      sp->interestQueueTimer();
+    }
   });
 }
 
@@ -450,9 +727,7 @@ void RTCProductionProtocol::sendNacksForPendingInterests() {
   if (packets_production_rate_ != 0)
     packet_gap = ceil(rtc::MILLI_IN_A_SEC / (double)packets_production_rate_);
 
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
+  uint64_t now = utils::SteadyTime::nowMs().count();
 
   for (auto it = seqs_map_.begin(); it != seqs_map_.end(); it++) {
     if (it->first > current_seg_) {
@@ -486,9 +761,7 @@ void RTCProductionProtocol::removeFromInterestQueue(uint32_t interest_seg) {
 }
 
 void RTCProductionProtocol::interestQueueTimer() {
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
+  uint64_t now = utils::SteadyTime::nowMs().count();
 
   for (auto it_timers = timers_map_.begin(); it_timers != timers_map_.end();) {
     uint64_t expire = it_timers->first;
@@ -511,20 +784,37 @@ void RTCProductionProtocol::interestQueueTimer() {
   }
 }
 
+void RTCProductionProtocol::sendManifestProbe(uint32_t sequence) {
+  Name manifest_name(flow_name_);
+  manifest_name.setSuffix(sequence);
+
+  std::shared_ptr<core::ContentObjectManifest> manifest_probe =
+      createManifest(manifest_name);
+
+  manifest_probe->setLifetime(0);
+  manifest_probe->setPathLabel(prod_label_);
+  manifest_probe->encode();
+
+  if (*on_content_object_output_) {
+    on_content_object_output_->operator()(*socket_->getInterface(),
+                                          *manifest_probe);
+  }
+
+  DLOG_IF(INFO, VLOG_IS_ON(3)) << "Send init probe " << sequence;
+  sendContentObject(manifest_probe, true, false);
+}
+
 void RTCProductionProtocol::sendNack(uint32_t sequence) {
   auto nack = core::PacketManager<>::getInstance().getPacket<ContentObject>(
-      signer_ ? Format::HF_INET6_TCP_AH : Format::HF_INET6_TCP,
-      signer_ ? signer_->getSignatureFieldSize() : 0);
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
+      nack_header_format_.first, nack_header_format_.second);
+  uint64_t now = utils::SteadyTime::nowMs().count();
   uint32_t next_packet = current_seg_;
   uint32_t prod_rate = bytes_production_rate_;
 
   struct rtc::nack_packet_t header;
   header.setTimestamp(now);
   header.setProductionRate(prod_rate);
-  header.setProductionSegement(next_packet);
+  header.setProductionSegment(next_packet);
   nack->appendPayload((const uint8_t *)&header, rtc::NACK_HEADER_SIZE);
 
   Name n(flow_name_);
@@ -533,14 +823,16 @@ void RTCProductionProtocol::sendNack(uint32_t sequence) {
   nack->setLifetime(0);
   nack->setPathLabel(prod_label_);
 
-  if (signer_) {
-    signer_->signPacket(nack.get());
-  }
-
   if (!consumer_in_sync_ && on_consumer_in_sync_ &&
-      sequence < rtc::MIN_PROBE_SEQ && sequence > next_packet) {
+      rtc::ProbeHandler::getProbeType(sequence) == rtc::ProbeType::NOT_PROBE &&
+      sequence > next_packet) {
     consumer_in_sync_ = true;
-    auto interest = core::PacketManager<>::getInstance().getPacket<Interest>();
+    Packet::Format format;
+    socket_->getSocketOption(interface::GeneralTransportOptions::PACKET_FORMAT,
+                             format);
+
+    auto interest =
+        core::PacketManager<>::getInstance().getPacket<Interest>(format);
     interest->setName(n);
     on_consumer_in_sync_(*socket_->getInterface(), *interest);
   }
@@ -550,16 +842,37 @@ void RTCProductionProtocol::sendNack(uint32_t sequence) {
   }
 
   DLOG_IF(INFO, VLOG_IS_ON(3)) << "Send nack " << sequence;
-  portal_->sendContentObject(*nack);
+  sendContentObject(nack, true, false);
 }
 
-void RTCProductionProtocol::onFecPackets(
-    std::vector<std::pair<uint32_t, fec::buffer>> &packets) {
+void RTCProductionProtocol::sendContentObject(
+    std::shared_ptr<ContentObject> content_object, bool nack, bool fec) {
+  bool is_ah = _is_ah(content_object->getFormat());
+
+  // Compute signature
+  if (is_ah) {
+    signer_->signPacket(content_object.get());
+  }
+
+  portal_->sendContentObject(*content_object);
+
+  // Compute and save data packet digest
+  if (making_manifest_ && !is_ah) {
+    auth::CryptoHashType hash_algo;
+    socket_->getSocketOption(interface::GeneralTransportOptions::HASH_ALGORITHM,
+                             hash_algo);
+    manifest_entries_.push({content_object->getName().getSuffix(),
+                            content_object->computeDigest(hash_algo)});
+  }
+}
+
+void RTCProductionProtocol::onFecPackets(fec::BufferArray &packets) {
   DLOG_IF(INFO, VLOG_IS_ON(3))
       << "Produced " << packets.size() << " FEC packets";
+
   for (auto &packet : packets) {
     auto content_object =
-        std::static_pointer_cast<ContentObject>(packet.second);
+        std::static_pointer_cast<ContentObject>(packet.getBuffer());
     content_object->prepend(content_object->headerSize() +
                             rtc::DATA_HEADER_SIZE);
     pending_fec_packets_.push(std::move(content_object));
@@ -569,19 +882,21 @@ void RTCProductionProtocol::onFecPackets(
 fec::buffer RTCProductionProtocol::getBuffer(std::size_t size) {
   DLOG_IF(INFO, VLOG_IS_ON(3))
       << "Asked buffer for FEC symbol of size " << size;
+
   auto ret = core::PacketManager<>::getInstance().getPacket<ContentObject>(
-      signer_ ? Format::HF_INET6_TCP_AH : Format::HF_INET6_TCP,
-      signer_ ? signer_->getSignatureFieldSize() : 0);
+      fec_header_format_.first, fec_header_format_.second);
+
   ret->updateLength(rtc::DATA_HEADER_SIZE + size);
   ret->append(rtc::DATA_HEADER_SIZE + size);
   ret->trimStart(ret->headerSize() + rtc::DATA_HEADER_SIZE);
+
   DLOG_IF(INFO, VLOG_IS_ON(3))
       << "Responding with buffer of length " << ret->length();
-  assert(ret->length() >= size);
+  DCHECK(ret->length() >= size);
 
   return ret;
 }
 
 }  // namespace protocol
 
-}  // end namespace transport
+}  // namespace transport
diff --git a/libtransport/src/protocols/prod_protocol_rtc.h b/libtransport/src/protocols/prod_protocol_rtc.h
index 96ad5673d..7f50a2505 100644
--- a/libtransport/src/protocols/prod_protocol_rtc.h
+++ b/libtransport/src/protocols/prod_protocol_rtc.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -32,6 +32,7 @@ class RTCProductionProtocol : public ProductionProtocol {
 
   using ProductionProtocol::start;
   using ProductionProtocol::stop;
+  void setProducerParam() override;
 
   void produce(ContentObject &content_object) override;
   uint32_t produceStream(const Name &content_name,
@@ -49,21 +50,31 @@ class RTCProductionProtocol : public ProductionProtocol {
                                              buffer, buffer_size, buffer_size));
   }
 
-  void registerNamespaceWithNetwork(const Prefix &producer_namespace) override;
-
   void setConsumerInSyncCallback(
       interface::ProducerInterestCallback &&callback) {
     on_consumer_in_sync_ = std::move(callback);
   }
 
+  auto shared_from_this() { return utils::shared_from(this); }
+
  private:
   // packet handlers
   void onInterest(Interest &interest) override;
-  void onError(std::error_code ec) override;
+  void onError(const std::error_code &ec) override{};
   void processInterest(uint32_t interest_seg, uint32_t lifetime);
+  void producePktInternal(std::shared_ptr<ContentObject> &&content_object,
+                          const Name &content_name, bool fec = false);
   void produceInternal(std::shared_ptr<ContentObject> &&content_object,
                        const Name &content_name, bool fec = false);
   void sendNack(uint32_t sequence);
+  void sendContentObject(std::shared_ptr<ContentObject> content_object,
+                         bool nac = false, bool fec = false);
+
+  // manifests
+  void sendManifestProbe(uint32_t sequence);
+  void sendManifest(const Name &content_name);
+  std::shared_ptr<core::ContentObjectManifest> createManifest(
+      const Name &name) const;
 
   // stats
   void updateStats();
@@ -77,15 +88,25 @@ class RTCProductionProtocol : public ProductionProtocol {
   void interestQueueTimer();
 
   // FEC functions
-  void onFecPackets(std::vector<std::pair<uint32_t, fec::buffer>> &packets);
+  void onFecPackets(fec::BufferArray &packets);
   fec::buffer getBuffer(std::size_t size);
+  void postponeFecPacket();
+  void dispatchFecPacket();
+  void flushFecPkts(uint32_t current_seq_num);
+  // aggregated data functions
+  void emptyQueue();
+  void addPacketToQueue(std::unique_ptr<utils::MemBuf> &&buffer);
 
   core::Name flow_name_;
 
-  uint32_t current_seg_;       // seq id of the next packet produced
-  uint32_t prod_label_;        // path lable of the producer
-  uint32_t cache_label_;       // path lable for content from the producer cache
-  uint16_t data_header_size_;  // hicn data header size
+  std::pair<core::Packet::Format, size_t> data_header_format_;
+  std::pair<core::Packet::Format, size_t> manifest_header_format_;
+  std::pair<core::Packet::Format, size_t> fec_header_format_;
+  std::pair<core::Packet::Format, size_t> nack_header_format_;
+
+  uint32_t current_seg_;  // seq id of the next packet produced
+  uint32_t prod_label_;   // path label of the producer
+  uint32_t cache_label_;  // path label for content from the producer cache
 
   uint32_t produced_bytes_;        // bytes produced in the last round
   uint32_t produced_packets_;      // packet produed in the last round
@@ -98,7 +119,11 @@ class RTCProductionProtocol : public ProductionProtocol {
   uint32_t packets_production_rate_;      // pps
   uint32_t fec_packets_production_rate_;  // pps
 
+  uint64_t last_produced_data_ts_;  // ms
+
   std::unique_ptr<asio::steady_timer> round_timer_;
+  std::unique_ptr<asio::steady_timer> fec_pacing_timer_;
+
   uint64_t last_round_;
 
   // delayed nacks are used by the producer to avoid to send too
@@ -131,6 +156,21 @@ class RTCProductionProtocol : public ProductionProtocol {
 
   // Save FEC packets here before sending them
   std::queue<ContentObject::Ptr> pending_fec_packets_;
+  std::queue<std::pair<uint64_t, ContentObject::Ptr>> paced_fec_packets_;
+  bool pending_fec_pace_;
+
+  // Save application packets if they are small
+  std::queue<std::unique_ptr<utils::MemBuf>> waiting_app_packets_;
+  uint16_t max_len_;       // len of the largest packet
+  uint16_t queue_len_;     // total size of all packet in the queue
+  bool data_aggregation_;  // turns on/off data aggregation
+  // timer to check the queue len
+  std::unique_ptr<asio::steady_timer> app_packets_timer_;
+  bool data_aggregation_timer_switch_;  // bool to check if the timer is on
+
+  // Manifest
+  std::queue<std::pair<uint32_t, auth::CryptoHash>>
+      manifest_entries_;  // map a packet suffix to a packet hash
 };
 
 }  // namespace protocol
diff --git a/libtransport/src/protocols/production_protocol.cc b/libtransport/src/protocols/production_protocol.cc
index 6b317d47d..8b781e38a 100644
--- a/libtransport/src/protocols/production_protocol.cc
+++ b/libtransport/src/protocols/production_protocol.cc
@@ -24,8 +24,8 @@ using namespace interface;
 
 ProductionProtocol::ProductionProtocol(
     implementation::ProducerSocket *icn_socket)
-    : socket_(icn_socket),
-      is_running_(false),
+    : Protocol(),
+      socket_(icn_socket),
       fec_encoder_(nullptr),
       on_interest_input_(VOID_HANDLER),
       on_interest_dropped_input_buffer_(VOID_HANDLER),
@@ -38,101 +38,92 @@ ProductionProtocol::ProductionProtocol(
       on_content_object_output_(VOID_HANDLER),
       on_content_object_evicted_from_output_buffer_(VOID_HANDLER),
       on_content_produced_(VOID_HANDLER),
+      producer_callback_(VOID_HANDLER),
       fec_type_(fec::FECType::UNKNOWN) {
   socket_->getSocketOption(GeneralTransportOptions::PORTAL, portal_);
   // TODO add statistics for producer
   //   socket_->getSocketOption(OtherOptions::STATISTICS, &stats_);
 }
 
-ProductionProtocol::~ProductionProtocol() {
-  if (!is_async_ && is_running_) {
-    stop();
-  }
+ProductionProtocol::~ProductionProtocol() {}
 
-  if (listening_thread_.joinable()) {
-    listening_thread_.join();
+int ProductionProtocol::start() {
+  if (isRunning()) {
+    return -1;
   }
-}
 
-int ProductionProtocol::start() {
-  socket_->getSocketOption(ProducerCallbacksOptions::INTEREST_INPUT,
-                           &on_interest_input_);
-  socket_->getSocketOption(ProducerCallbacksOptions::INTEREST_DROP,
-                           &on_interest_dropped_input_buffer_);
-  socket_->getSocketOption(ProducerCallbacksOptions::INTEREST_PASS,
-                           &on_interest_inserted_input_buffer_);
-  socket_->getSocketOption(ProducerCallbacksOptions::CACHE_HIT,
-                           &on_interest_satisfied_output_buffer_);
-  socket_->getSocketOption(ProducerCallbacksOptions::CACHE_MISS,
-                           &on_interest_process_);
-  socket_->getSocketOption(ProducerCallbacksOptions::NEW_CONTENT_OBJECT,
-                           &on_new_segment_);
-  socket_->getSocketOption(ProducerCallbacksOptions::CONTENT_OBJECT_READY,
-                           &on_content_object_in_output_buffer_);
-  socket_->getSocketOption(ProducerCallbacksOptions::CONTENT_OBJECT_OUTPUT,
-                           &on_content_object_output_);
-  socket_->getSocketOption(ProducerCallbacksOptions::CONTENT_OBJECT_TO_SIGN,
-                           &on_content_object_to_sign_);
-  socket_->getSocketOption(ProducerCallbacksOptions::CONTENT_PRODUCED,
-                           &on_content_produced_);
-
-  socket_->getSocketOption(GeneralTransportOptions::ASYNC_MODE, is_async_);
-  socket_->getSocketOption(GeneralTransportOptions::SIGNER, signer_);
-  socket_->getSocketOption(GeneralTransportOptions::MAKE_MANIFEST,
-                           making_manifest_);
-
-  bool first = true;
-
-  for (core::Prefix &producer_namespace : served_namespaces_) {
-    if (first) {
-      core::BindConfig bind_config(producer_namespace, 1000);
-      portal_->bind(bind_config);
-      portal_->setProducerCallback(this);
-      first = !first;
-    } else {
-      portal_->registerRoute(producer_namespace);
+  portal_->getThread().addAndWaitForExecution([this]() {
+    socket_->getSocketOption(ProducerCallbacksOptions::INTEREST_INPUT,
+                             &on_interest_input_);
+    socket_->getSocketOption(ProducerCallbacksOptions::INTEREST_DROP,
+                             &on_interest_dropped_input_buffer_);
+    socket_->getSocketOption(ProducerCallbacksOptions::INTEREST_PASS,
+                             &on_interest_inserted_input_buffer_);
+    socket_->getSocketOption(ProducerCallbacksOptions::CACHE_HIT,
+                             &on_interest_satisfied_output_buffer_);
+    socket_->getSocketOption(ProducerCallbacksOptions::CACHE_MISS,
+                             &on_interest_process_);
+    socket_->getSocketOption(ProducerCallbacksOptions::NEW_CONTENT_OBJECT,
+                             &on_new_segment_);
+    socket_->getSocketOption(ProducerCallbacksOptions::CONTENT_OBJECT_READY,
+                             &on_content_object_in_output_buffer_);
+    socket_->getSocketOption(ProducerCallbacksOptions::CONTENT_OBJECT_OUTPUT,
+                             &on_content_object_output_);
+    socket_->getSocketOption(ProducerCallbacksOptions::CONTENT_OBJECT_TO_SIGN,
+                             &on_content_object_to_sign_);
+    socket_->getSocketOption(ProducerCallbacksOptions::CONTENT_PRODUCED,
+                             &on_content_produced_);
+    socket_->getSocketOption(ProducerCallbacksOptions::PRODUCER_CALLBACK,
+                             &producer_callback_);
+
+    socket_->getSocketOption(GeneralTransportOptions::ASYNC_MODE, is_async_);
+    socket_->getSocketOption(GeneralTransportOptions::SIGNER, signer_);
+    socket_->getSocketOption(GeneralTransportOptions::MAKE_MANIFEST,
+                             making_manifest_);
+
+    std::string fec_type_str = "";
+    socket_->getSocketOption(GeneralTransportOptions::FEC_TYPE, fec_type_str);
+    if (fec_type_str != "") {
+      fec_type_ = fec::FECUtils::fecTypeFromString(fec_type_str.c_str());
     }
-  }
 
-  is_running_ = true;
+    portal_->registerTransportCallback(this);
+    setProducerParam();
 
-  if (!is_async_) {
-    listening_thread_ = std::thread([this]() { portal_->runEventsLoop(); });
-  }
+    setRunning();
+  });
 
   return 0;
 }
 
-void ProductionProtocol::stop() {
-  is_running_ = false;
-
-  if (!is_async_) {
-    portal_->stopEventsLoop();
-  } else {
-    portal_->clear();
-  }
-}
-
 void ProductionProtocol::produce(ContentObject &content_object) {
-  if (*on_content_object_in_output_buffer_) {
-    on_content_object_in_output_buffer_->operator()(*socket_->getInterface(),
-                                                    content_object);
-  }
+  auto content_object_ptr = content_object.shared_from_this();
+  portal_->getThread().add([this, co = std::move(content_object_ptr)]() {
+    if (*on_content_object_in_output_buffer_) {
+      on_content_object_in_output_buffer_->operator()(*socket_->getInterface(),
+                                                      *co);
+    }
 
-  output_buffer_.insert(std::static_pointer_cast<ContentObject>(
-      content_object.shared_from_this()));
+    output_buffer_.insert(co);
 
-  if (*on_content_object_output_) {
-    on_content_object_output_->operator()(*socket_->getInterface(),
-                                          content_object);
-  }
+    if (*on_content_object_output_) {
+      on_content_object_output_->operator()(*socket_->getInterface(), *co);
+    }
 
-  portal_->sendContentObject(content_object);
+    portal_->sendContentObject(*co);
+  });
 }
 
-void ProductionProtocol::registerNamespaceWithNetwork(
-    const Prefix &producer_namespace) {
-  served_namespaces_.push_back(producer_namespace);
+void ProductionProtocol::sendMapme() { portal_->sendMapme(); }
+
+void ProductionProtocol::onError(const std::error_code &ec) {
+  // Stop production protocol
+  stop();
+
+  // Call error callback
+  if (producer_callback_) {
+    producer_callback_->produceError(ec);
+  }
 }
 
 }  // namespace protocol
diff --git a/libtransport/src/protocols/production_protocol.h b/libtransport/src/protocols/production_protocol.h
index 7366311eb..8e10d2f40 100644
--- a/libtransport/src/protocols/production_protocol.h
+++ b/libtransport/src/protocols/production_protocol.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -22,6 +22,7 @@
 #include <implementation/socket.h>
 #include <protocols/fec_base.h>
 #include <protocols/fec_utils.h>
+#include <protocols/protocol.h>
 #include <utils/content_store.h>
 
 #include <atomic>
@@ -33,17 +34,20 @@ namespace protocol {
 
 using namespace core;
 
-class ProductionProtocol : public Portal::ProducerCallback {
+class ProductionProtocol
+    : public Protocol,
+      public std::enable_shared_from_this<ProductionProtocol> {
  public:
   ProductionProtocol(implementation::ProducerSocket *icn_socket);
   virtual ~ProductionProtocol();
 
-  bool isRunning() { return is_running_; }
-
   virtual int start();
-  virtual void stop();
+  using Protocol::stop;
+
+  virtual void setProducerParam(){};
 
   virtual void produce(ContentObject &content_object);
+  virtual void sendMapme();
   virtual uint32_t produceStream(const Name &content_name,
                                  std::unique_ptr<utils::MemBuf> &&buffer,
                                  bool is_last = true,
@@ -61,20 +65,18 @@ class ProductionProtocol : public Portal::ProducerCallback {
   void setOutputBufferSize(std::size_t size) { output_buffer_.setLimit(size); }
   std::size_t getOutputBufferSize() { return output_buffer_.getLimit(); }
 
-  virtual void registerNamespaceWithNetwork(const Prefix &producer_namespace);
-  const std::list<Prefix> &getNamespaces() const { return served_namespaces_; }
-
  protected:
   // Producer callback
   virtual void onInterest(core::Interest &i) override = 0;
-  virtual void onError(std::error_code ec) override{};
+  virtual void onError(const std::error_code &ec) override;
 
   template <typename FECHandler, typename AllocatorHandler>
   void enableFEC(FECHandler &&fec_handler,
                  AllocatorHandler &&allocator_handler) {
     if (!fec_encoder_) {
       // Try to get FEC from environment
-      if (const char *fec_str = std::getenv("TRANSPORT_FEC_TYPE")) {
+      const char *fec_str = std::getenv("TRANSPORT_FEC_TYPE");
+      if (fec_str && (fec_type_ == fec::FECType::UNKNOWN)) {
         LOG(INFO) << "Using FEC " << fec_str;
         fec_type_ = fec::FECUtils::fecTypeFromString(fec_str);
       }
@@ -95,11 +97,6 @@ class ProductionProtocol : public Portal::ProducerCallback {
 
   // Thread pool responsible for IO operations (send data / receive interests)
   std::vector<utils::EventThread> io_threads_;
-
-  // TODO remove this thread
-  std::thread listening_thread_;
-  std::shared_ptr<Portal> portal_;
-  std::atomic<bool> is_running_;
   interface::ProductionStatistics *stats_;
   std::unique_ptr<fec::ProducerFEC> fec_encoder_;
 
@@ -119,15 +116,14 @@ class ProductionProtocol : public Portal::ProducerCallback {
 
   interface::ProducerContentCallback *on_content_produced_;
 
+  interface::ProducerSocket::Callback *producer_callback_;
+
   // Output buffer
   utils::ContentStore output_buffer_;
 
-  // List ot routes served by current producer protocol
-  std::list<Prefix> served_namespaces_;
-
   // Signature and manifest
   std::shared_ptr<auth::Signer> signer_;
-  bool making_manifest_;
+  uint32_t making_manifest_;
 
   bool is_async_;
   fec::FECType fec_type_;
diff --git a/libtransport/src/protocols/protocol.h b/libtransport/src/protocols/protocol.h
new file mode 100644
index 000000000..a9f929db9
--- /dev/null
+++ b/libtransport/src/protocols/protocol.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <core/portal.h>
+#include <hicn/transport/errors/runtime_exception.h>
+#include <hicn/transport/utils/noncopyable.h>
+
+#include <random>
+
+namespace transport {
+
+namespace protocol {
+
+class Protocol : public core::Portal::TransportCallback, utils::NonCopyable {
+ public:
+  virtual void stop() {
+    portal_->getThread().addAndWaitForExecution([this]() {
+      unSetRunning();
+      portal_->unregisterTransportCallback();
+      portal_->clear();
+    });
+  }
+
+  virtual void onInterest(core::Interest &i) {
+    throw errors::RuntimeException("Not implemented");
+  }
+
+  virtual void onContentObject(core::Interest &i, core::ContentObject &c) {
+    throw errors::RuntimeException("Not implemented");
+  }
+
+  virtual void onTimeout(core::Interest::Ptr &i, const core::Name &n) {
+    throw errors::RuntimeException("Not implemented");
+  }
+
+  virtual void onError(const std::error_code &ec) {
+    throw errors::RuntimeException("Not implemented");
+  }
+
+  bool isRunning() { return is_running_; }
+  void setRunning() { is_running_ = true; }
+  void unSetRunning() { is_running_ = false; }
+
+ protected:
+  Protocol() : portal_(nullptr), is_running_(false), gen_(rd_()) {}
+  virtual ~Protocol() {}
+
+ protected:
+  std::shared_ptr<core::Portal> portal_;
+  std::atomic_bool is_running_;
+
+  // Random engine
+  std::random_device rd_;
+  std::mt19937 gen_;
+};
+
+}  // namespace protocol
+
+}  // namespace transport
\ No newline at end of file
diff --git a/libtransport/src/protocols/raaqm.cc b/libtransport/src/protocols/raaqm.cc
index 1247af400..131367d78 100644
--- a/libtransport/src/protocols/raaqm.cc
+++ b/libtransport/src/protocols/raaqm.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -36,8 +36,9 @@ RaaqmTransportProtocol::RaaqmTransportProtocol(
       current_window_size_(1),
       interests_in_flight_(0),
       cur_path_(nullptr),
-      t0_(utils::SteadyClock::now()),
+      t0_(utils::SteadyTime::Clock::now()),
       rate_estimator_(nullptr),
+      dis_(0, 1.0),
       schedule_interests_(true) {
   init();
 }
@@ -60,7 +61,7 @@ void RaaqmTransportProtocol::reset() {
 
   // Reset protocol variables
   interests_in_flight_ = 0;
-  t0_ = utils::SteadyClock::now();
+  t0_ = utils::SteadyTime::Clock::now();
 
   // Optionally reset congestion window
   bool reset_window;
@@ -389,6 +390,8 @@ void RaaqmTransportProtocol::sendInterest(
     uint32_t len) {
   interests_in_flight_++;
   interest_retransmissions_[interest_name.getSuffix() & mask]++;
+  interest_timepoints_[interest_name.getSuffix() & mask] =
+      utils::SteadyTime::Clock::now();
   TransportProtocol::sendInterest(interest_name, additional_suffixes, len);
 }
 
@@ -477,7 +480,7 @@ void RaaqmTransportProtocol::scheduleNextInterests() {
   }
 }
 
-void RaaqmTransportProtocol::onContentReassembled(std::error_code ec) {
+void RaaqmTransportProtocol::onContentReassembled(const std::error_code &ec) {
   rate_estimator_->onDownloadFinished();
   TransportProtocol::onContentReassembled(ec);
   schedule_interests_ = false;
@@ -487,18 +490,18 @@ void RaaqmTransportProtocol::updateRtt(uint64_t segment) {
   if (TRANSPORT_EXPECT_FALSE(!cur_path_)) {
     throw std::runtime_error("RAAQM ERROR: no current path found, exit");
   } else {
-    auto now = utils::SteadyClock::now();
-    utils::Microseconds rtt = std::chrono::duration_cast<utils::Microseconds>(
-        now - interest_timepoints_[segment & mask]);
+    auto now = utils::SteadyTime::Clock::now();
+    utils::SteadyTime::Milliseconds rtt = utils::SteadyTime::getDurationMs(
+        interest_timepoints_[segment & mask], now);
 
     // Update stats
-    updateStats((uint32_t)segment, rtt.count(), now);
+    updateStats((uint32_t)segment, rtt, now);
 
     if (rate_estimator_) {
-      rate_estimator_->onRttUpdate((double)rtt.count());
+      rate_estimator_->onRttUpdate(rtt);
     }
 
-    cur_path_->insertNewRtt(rtt.count(), now);
+    cur_path_->insertNewRtt(rtt, now);
     cur_path_->smoothTimer();
 
     if (cur_path_->newPropagationDelayAvailable()) {
@@ -510,27 +513,27 @@ void RaaqmTransportProtocol::updateRtt(uint64_t segment) {
 void RaaqmTransportProtocol::RAAQM() {
   if (!cur_path_) {
     throw errors::RuntimeException("ERROR: no current path found, exit");
-    exit(EXIT_FAILURE);
   } else {
     // Change drop probability according to RTT statistics
     cur_path_->updateDropProb();
 
-    double coin = ((double)rand() / (RAND_MAX));
+    double coin = dis_(gen_);
     if (coin <= cur_path_->getDropProb()) {
       decreaseWindow();
     }
   }
 }
 
-void RaaqmTransportProtocol::updateStats(uint32_t suffix, uint64_t rtt,
-                                         utils::TimePoint &now) {
+void RaaqmTransportProtocol::updateStats(
+    uint32_t suffix, const utils::SteadyTime::Milliseconds &rtt,
+    utils::SteadyTime::TimePoint &now) {
   // Update RTT statistics
   stats_->updateAverageRtt(rtt);
   stats_->updateAverageWindowSize(current_window_size_);
 
   // Call statistics callback
   if (*stats_summary_) {
-    auto dt = std::chrono::duration_cast<utils::Milliseconds>(now - t0_);
+    auto dt = utils::SteadyTime::getDurationMs(t0_, now);
 
     uint32_t timer_interval_milliseconds = 0;
     socket_->getSocketOption(GeneralTransportOptions::STATS_INTERVAL,
diff --git a/libtransport/src/protocols/raaqm.h b/libtransport/src/protocols/raaqm.h
index ffbb30d3a..ec344c23a 100644
--- a/libtransport/src/protocols/raaqm.h
+++ b/libtransport/src/protocols/raaqm.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -23,6 +23,7 @@
 #include <protocols/transport_protocol.h>
 
 #include <queue>
+#include <random>
 #include <vector>
 
 namespace transport {
@@ -55,8 +56,9 @@ class RaaqmTransportProtocol : public TransportProtocol,
                                      const ContentObject &content_object);
   virtual void afterDataUnsatisfied(uint64_t segment);
 
-  virtual void updateStats(uint32_t suffix, uint64_t rtt,
-                           utils::TimePoint &now);
+  virtual void updateStats(uint32_t suffix,
+                           const utils::SteadyTime::Milliseconds &rtt,
+                           utils::SteadyTime::TimePoint &now);
 
  private:
   void init();
@@ -73,7 +75,7 @@ class RaaqmTransportProtocol : public TransportProtocol,
                         *additional_suffixes = nullptr,
                     uint32_t len = 0) override;
 
-  void onContentReassembled(std::error_code ec) override;
+  void onContentReassembled(const std::error_code &ec) override;
   void updateRtt(uint64_t segment);
   void RAAQM();
   void updatePathTable(const ContentObject &content_object);
@@ -81,13 +83,15 @@ class RaaqmTransportProtocol : public TransportProtocol,
   void checkForStalePaths();
   void printRtt();
 
+  auto shared_from_this() { return utils::shared_from(this); }
+
  protected:
   // Congestion window management
   double current_window_size_;
   // Protocol management
   uint64_t interests_in_flight_;
   std::array<std::uint32_t, buffer_size> interest_retransmissions_;
-  std::array<utils::TimePoint, buffer_size> interest_timepoints_;
+  std::array<utils::SteadyTime::TimePoint, buffer_size> interest_timepoints_;
   std::queue<uint32_t> interest_to_retransmit_;
 
  private:
@@ -102,13 +106,16 @@ class RaaqmTransportProtocol : public TransportProtocol,
   PathTable path_table_;
 
   // TimePoints for statistic
-  utils::TimePoint t0_;
+  utils::SteadyTime::TimePoint t0_;
 
   bool set_interest_filter_;
 
   // for rate-estimation at packet level
   IcnRateEstimator *rate_estimator_;
 
+  // Real distribution
+  std::uniform_real_distribution<> dis_;
+
   // params for autotuning
   bool raaqm_autotune_;
   double default_beta_;
diff --git a/libtransport/src/protocols/raaqm_data_path.cc b/libtransport/src/protocols/raaqm_data_path.cc
index f2c21b9ef..d06fee918 100644
--- a/libtransport/src/protocols/raaqm_data_path.cc
+++ b/libtransport/src/protocols/raaqm_data_path.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -23,16 +23,18 @@ namespace protocol {
 RaaqmDataPath::RaaqmDataPath(double drop_factor,
                              double minimum_drop_probability,
                              unsigned new_timer, unsigned int samples,
-                             uint64_t new_rtt, uint64_t new_rtt_min,
-                             uint64_t new_rtt_max, unsigned new_pd)
+                             const utils::SteadyTime::Milliseconds &new_rtt,
+                             const utils::SteadyTime::Milliseconds &new_rtt_min,
+                             const utils::SteadyTime::Milliseconds &new_rtt_max,
+                             unsigned new_pd)
 
     : drop_factor_(drop_factor),
       minimum_drop_probability_(minimum_drop_probability),
       timer_(new_timer),
       samples_(samples),
-      rtt_(new_rtt),
-      rtt_min_(new_rtt_min),
-      rtt_max_(new_rtt_max),
+      rtt_(new_rtt.count()),
+      rtt_min_(new_rtt_min.count()),
+      rtt_max_(new_rtt_max.count()),
       prop_delay_(new_pd),
       new_prop_delay_(false),
       drop_prob_(0),
@@ -43,14 +45,15 @@ RaaqmDataPath::RaaqmDataPath(double drop_factor,
       raw_data_bytes_received_(0),
       last_raw_data_bytes_received_(0),
       rtt_samples_(samples_),
-      last_received_pkt_(utils::SteadyClock::now()),
+      last_received_pkt_(utils::SteadyTime::Clock::now()),
       average_rtt_(0),
       alpha_(ALPHA) {}
 
-RaaqmDataPath &RaaqmDataPath::insertNewRtt(uint64_t new_rtt,
-                                           const utils::TimePoint &now) {
-  rtt_ = new_rtt;
-  rtt_samples_.pushBack(new_rtt);
+RaaqmDataPath &RaaqmDataPath::insertNewRtt(
+    const utils::SteadyTime::Milliseconds &new_rtt,
+    const utils::SteadyTime::TimePoint &now) {
+  rtt_ = new_rtt.count();
+  rtt_samples_.pushBack(rtt_);
 
   rtt_max_ = rtt_samples_.rBegin();
   rtt_min_ = rtt_samples_.begin();
@@ -143,10 +146,8 @@ unsigned int RaaqmDataPath::getPropagationDelay() {
 }
 
 bool RaaqmDataPath::isStale() {
-  utils::TimePoint now = utils::SteadyClock::now();
-  auto time =
-      std::chrono::duration_cast<utils::Microseconds>(now - last_received_pkt_)
-          .count();
+  utils::SteadyTime::TimePoint now = utils::SteadyTime::Clock::now();
+  auto time = utils::SteadyTime::getDurationUs(last_received_pkt_, now).count();
   if (time > 2000000) {
     return true;
   }
diff --git a/libtransport/src/protocols/raaqm_data_path.h b/libtransport/src/protocols/raaqm_data_path.h
index c0b53a690..b6f7c5ac1 100644
--- a/libtransport/src/protocols/raaqm_data_path.h
+++ b/libtransport/src/protocols/raaqm_data_path.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -34,8 +34,13 @@ class RaaqmDataPath {
  public:
   RaaqmDataPath(double drop_factor, double minimum_drop_probability,
                 unsigned new_timer, unsigned int samples,
-                uint64_t new_rtt = 1000, uint64_t new_rtt_min = 1000,
-                uint64_t new_rtt_max = 1000, unsigned new_pd = UINT_MAX);
+                const utils::SteadyTime::Milliseconds &new_rtt =
+                    utils::SteadyTime::Milliseconds(1000),
+                const utils::SteadyTime::Milliseconds &new_rtt_min =
+                    utils::SteadyTime::Milliseconds(1000),
+                const utils::SteadyTime::Milliseconds &new_rtt_max =
+                    utils::SteadyTime::Milliseconds(1000),
+                unsigned new_pd = UINT_MAX);
 
  public:
   /*
@@ -44,7 +49,8 @@ class RaaqmDataPath {
    * max of RTT.
    * @param new_rtt is the value of the new RTT
    */
-  RaaqmDataPath &insertNewRtt(uint64_t new_rtt, const utils::TimePoint &now);
+  RaaqmDataPath &insertNewRtt(const utils::SteadyTime::Milliseconds &new_rtt,
+                              const utils::SteadyTime::TimePoint &now);
 
   /**
    * @brief Update the path statistics
@@ -214,7 +220,7 @@ class RaaqmDataPath {
   /**
    * Time of the last call to the path reporter method
    */
-  utils::TimePoint last_received_pkt_;
+  utils::SteadyTime::TimePoint last_received_pkt_;
 
   double average_rtt_;
   double alpha_;
diff --git a/libtransport/src/protocols/rate_estimation.cc b/libtransport/src/protocols/rate_estimation.cc
index 2337e18be..d834b53e6 100644
--- a/libtransport/src/protocols/rate_estimation.cc
+++ b/libtransport/src/protocols/rate_estimation.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,6 +14,7 @@
  */
 
 #include <glog/logging.h>
+#include <hicn/transport/errors/runtime_exception.h>
 #include <hicn/transport/interfaces/socket_options_default_values.h>
 #include <protocols/rate_estimation.h>
 
@@ -92,8 +93,8 @@ InterRttEstimator::InterRttEstimator(double alpha_arg) {
   this->win_current_ = 1.0;
 
   pthread_mutex_init(&(this->mutex_), NULL);
-  this->start_time_ = std::chrono::steady_clock::now();
-  this->begin_batch_ = std::chrono::steady_clock::now();
+  this->start_time_ = utils::SteadyTime::now();
+  this->begin_batch_ = utils::SteadyTime::now();
 }
 
 InterRttEstimator::~InterRttEstimator() {
@@ -105,33 +106,35 @@ InterRttEstimator::~InterRttEstimator() {
   pthread_mutex_destroy(&(this->mutex_));
 }
 
-void InterRttEstimator::onRttUpdate(double rtt) {
+void InterRttEstimator::onRttUpdate(
+    const utils::SteadyTime::Milliseconds &rtt) {
   pthread_mutex_lock(&(this->mutex_));
-  this->rtt_ = rtt;
+  this->rtt_ = rtt.count();
   this->number_of_packets_++;
-  this->avg_rtt_ += rtt;
+  this->avg_rtt_ += this->rtt_;
   pthread_mutex_unlock(&(this->mutex_));
 
   if (!thread_is_running_) {
     my_th_ = (pthread_t *)malloc(sizeof(pthread_t));
     if (!my_th_) {
-      LOG(ERROR) << "Error allocating thread.";
-      my_th_ = NULL;
+      throw errors::RuntimeException("Error allocating thread.");
     }
-    if (/*int err = */ pthread_create(my_th_, NULL, transport::protocol::Timer,
-                                      (void *)this)) {
-      LOG(ERROR) << "Error creating the thread";
+
+    if (pthread_create(my_th_, NULL, transport::protocol::Timer,
+                       (void *)this)) {
+      free(my_th_);
       my_th_ = NULL;
+      throw errors::RuntimeException("Error allocating thread.");
     }
+
     thread_is_running_ = true;
   }
 }
 
 void InterRttEstimator::onWindowIncrease(double win_current) {
-  TimePoint end = std::chrono::steady_clock::now();
+  auto end = utils::SteadyTime::now();
   auto delay =
-      std::chrono::duration_cast<Microseconds>(end - this->begin_batch_)
-          .count();
+      utils::SteadyTime::getDurationUs(this->begin_batch_, end).count();
 
   pthread_mutex_lock(&(this->mutex_));
   this->avg_win_ += this->win_current_ * delay;
@@ -139,14 +142,13 @@ void InterRttEstimator::onWindowIncrease(double win_current) {
   this->win_change_ += delay;
   pthread_mutex_unlock(&(this->mutex_));
 
-  this->begin_batch_ = std::chrono::steady_clock::now();
+  this->begin_batch_ = utils::SteadyTime::now();
 }
 
 void InterRttEstimator::onWindowDecrease(double win_current) {
-  TimePoint end = std::chrono::steady_clock::now();
+  auto end = utils::SteadyTime::now();
   auto delay =
-      std::chrono::duration_cast<Microseconds>(end - this->begin_batch_)
-          .count();
+      utils::SteadyTime::getDurationUs(this->begin_batch_, end).count();
 
   pthread_mutex_lock(&(this->mutex_));
   this->avg_win_ += this->win_current_ * delay;
@@ -154,25 +156,24 @@ void InterRttEstimator::onWindowDecrease(double win_current) {
   this->win_change_ += delay;
   pthread_mutex_unlock(&(this->mutex_));
 
-  this->begin_batch_ = std::chrono::steady_clock::now();
+  this->begin_batch_ = utils::SteadyTime::now();
 }
 
 ALaTcpEstimator::ALaTcpEstimator() {
   this->estimation_ = 0.0;
   this->observer_ = NULL;
-  this->start_time_ = std::chrono::steady_clock::now();
+  this->start_time_ = utils::SteadyTime::now();
   this->totalSize_ = 0.0;
 }
 
 void ALaTcpEstimator::onStart() {
   this->totalSize_ = 0.0;
-  this->start_time_ = std::chrono::steady_clock::now();
+  this->start_time_ = utils::SteadyTime::now();
 }
 
 void ALaTcpEstimator::onDownloadFinished() {
-  TimePoint end = std::chrono::steady_clock::now();
-  auto delay =
-      std::chrono::duration_cast<Microseconds>(end - this->start_time_).count();
+  auto end = utils::SteadyTime::now();
+  auto delay = utils::SteadyTime::getDurationUs(this->start_time_, end).count();
   this->estimation_ = this->totalSize_ * 8 * 1000000 / delay;
   if (observer_) {
     observer_->notifyStats(this->estimation_);
@@ -192,22 +193,21 @@ SimpleEstimator::SimpleEstimator(double alphaArg, int batching_param) {
   this->number_of_packets_ = 0;
   this->base_alpha_ = alphaArg;
   this->alpha_ = alphaArg;
-  this->start_time_ = std::chrono::steady_clock::now();
-  this->begin_batch_ = std::chrono::steady_clock::now();
+  this->start_time_ = utils::SteadyTime::now();
+  this->begin_batch_ = utils::SteadyTime::now();
 }
 
 void SimpleEstimator::onStart() {
   this->estimated_ = false;
   this->number_of_packets_ = 0;
   this->total_size_ = 0.0;
-  this->start_time_ = std::chrono::steady_clock::now();
-  this->begin_batch_ = std::chrono::steady_clock::now();
+  this->start_time_ = utils::SteadyTime::now();
+  this->begin_batch_ = utils::SteadyTime::now();
 }
 
 void SimpleEstimator::onDownloadFinished() {
-  TimePoint end = std::chrono::steady_clock::now();
-  auto delay =
-      std::chrono::duration_cast<Microseconds>(end - this->start_time_).count();
+  auto end = utils::SteadyTime::now();
+  auto delay = utils::SteadyTime::getDurationUs(this->start_time_, end).count();
   if (observer_) {
     observer_->notifyDownloadTime((double)delay);
   }
@@ -229,8 +229,7 @@ void SimpleEstimator::onDownloadFinished() {
   } else {
     if (this->number_of_packets_ >=
         (int)(75.0 * (double)this->batching_param_ / 100.0)) {
-      delay = std::chrono::duration_cast<Microseconds>(end - this->begin_batch_)
-                  .count();
+      delay = utils::SteadyTime::getDurationUs(this->begin_batch_, end).count();
       // Assuming all packets carry max_packet_size_ bytes of data
       // (8*max_packet_size_ bits); 1000000 factor to convert us to seconds
       if (this->estimation_) {
@@ -249,22 +248,21 @@ void SimpleEstimator::onDownloadFinished() {
   }
   this->number_of_packets_ = 0;
   this->total_size_ = 0.0;
-  this->start_time_ = std::chrono::steady_clock::now();
-  this->begin_batch_ = std::chrono::steady_clock::now();
+  this->start_time_ = utils::SteadyTime::now();
+  this->begin_batch_ = utils::SteadyTime::now();
 }
 
 void SimpleEstimator::onDataReceived(int packet_size) {
   this->total_size_ += packet_size;
 }
 
-void SimpleEstimator::onRttUpdate(double rtt) {
+void SimpleEstimator::onRttUpdate(const utils::SteadyTime::Milliseconds &rtt) {
   this->number_of_packets_++;
 
   if (this->number_of_packets_ == this->batching_param_) {
-    TimePoint end = std::chrono::steady_clock::now();
+    auto end = utils::SteadyTime::now();
     auto delay =
-        std::chrono::duration_cast<Microseconds>(end - this->begin_batch_)
-            .count();
+        utils::SteadyTime::getDurationUs(this->begin_batch_, end).count();
     // Assuming all packets carry max_packet_size_ bytes of data
     // (8*max_packet_size_ bits); 1000000 factor to convert us to seconds
     if (this->estimation_) {
@@ -280,7 +278,7 @@ void SimpleEstimator::onRttUpdate(double rtt) {
     this->alpha_ = this->base_alpha_;
     this->number_of_packets_ = 0;
     this->total_size_ = 0.0;
-    this->begin_batch_ = std::chrono::steady_clock::now();
+    this->begin_batch_ = utils::SteadyTime::now();
   }
 }
 
@@ -297,13 +295,14 @@ BatchingPacketsEstimator::BatchingPacketsEstimator(double alpha_arg,
   this->max_packet_size_ = 0;
   this->estimation_ = 0.0;
   this->win_current_ = 1.0;
-  this->begin_batch_ = std::chrono::steady_clock::now();
-  this->start_time_ = std::chrono::steady_clock::now();
+  this->begin_batch_ = utils::SteadyTime::now();
+  this->start_time_ = utils::SteadyTime::now();
 }
 
-void BatchingPacketsEstimator::onRttUpdate(double rtt) {
+void BatchingPacketsEstimator::onRttUpdate(
+    const utils::SteadyTime::Milliseconds &rtt) {
   this->number_of_packets_++;
-  this->avg_rtt_ += rtt;
+  this->avg_rtt_ += rtt.count();
 
   if (number_of_packets_ == this->batching_param_) {
     if (estimation_ == 0) {
@@ -329,25 +328,23 @@ void BatchingPacketsEstimator::onRttUpdate(double rtt) {
 }
 
 void BatchingPacketsEstimator::onWindowIncrease(double win_current) {
-  TimePoint end = std::chrono::steady_clock::now();
+  auto end = utils::SteadyTime::now();
   auto delay =
-      std::chrono::duration_cast<Microseconds>(end - this->begin_batch_)
-          .count();
+      utils::SteadyTime::getDurationUs(this->begin_batch_, end).count();
   this->avg_win_ += this->win_current_ * delay;
   this->win_current_ = win_current;
   this->win_change_ += delay;
-  this->begin_batch_ = std::chrono::steady_clock::now();
+  this->begin_batch_ = utils::SteadyTime::now();
 }
 
 void BatchingPacketsEstimator::onWindowDecrease(double win_current) {
-  TimePoint end = std::chrono::steady_clock::now();
+  auto end = utils::SteadyTime::now();
   auto delay =
-      std::chrono::duration_cast<Microseconds>(end - this->begin_batch_)
-          .count();
+      utils::SteadyTime::getDurationUs(this->begin_batch_, end).count();
   this->avg_win_ += this->win_current_ * delay;
   this->win_current_ = win_current;
   this->win_change_ += delay;
-  this->begin_batch_ = std::chrono::steady_clock::now();
+  this->begin_batch_ = utils::SteadyTime::now();
 }
 
 }  // end namespace protocol
diff --git a/libtransport/src/protocols/rate_estimation.h b/libtransport/src/protocols/rate_estimation.h
index 42ae74194..b71de12e4 100644
--- a/libtransport/src/protocols/rate_estimation.h
+++ b/libtransport/src/protocols/rate_estimation.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,6 +16,7 @@
 #pragma once
 
 #include <hicn/transport/interfaces/statistics.h>
+#include <hicn/transport/utils/noncopyable.h>
 #include <protocols/raaqm_data_path.h>
 
 #include <chrono>
@@ -24,16 +25,13 @@ namespace transport {
 
 namespace protocol {
 
-class IcnRateEstimator {
+class IcnRateEstimator : utils::NonCopyable {
  public:
-  using TimePoint = std::chrono::steady_clock::time_point;
-  using Microseconds = std::chrono::microseconds;
-
   IcnRateEstimator(){};
 
   virtual ~IcnRateEstimator(){};
 
-  virtual void onRttUpdate(double rtt){};
+  virtual void onRttUpdate(const utils::SteadyTime::Milliseconds &rtt){};
 
   virtual void onDataReceived(int packetSize){};
 
@@ -48,9 +46,10 @@ class IcnRateEstimator {
   virtual void setObserver(interface::IcnObserver *observer) {
     this->observer_ = observer;
   };
+
   interface::IcnObserver *observer_;
-  TimePoint start_time_;
-  TimePoint begin_batch_;
+  utils::SteadyTime::TimePoint start_time_;
+  utils::SteadyTime::TimePoint begin_batch_;
   double base_alpha_;
   double alpha_;
   double estimation_;
@@ -67,7 +66,7 @@ class InterRttEstimator : public IcnRateEstimator {
 
   ~InterRttEstimator();
 
-  void onRttUpdate(double rtt);
+  void onRttUpdate(const utils::SteadyTime::Milliseconds &rtt);
 
   void onDataReceived(int packet_size) {
     if (packet_size > this->max_packet_size_) {
@@ -102,7 +101,7 @@ class BatchingPacketsEstimator : public IcnRateEstimator {
  public:
   BatchingPacketsEstimator(double alpha_arg, int batchingParam);
 
-  void onRttUpdate(double rtt);
+  void onRttUpdate(const utils::SteadyTime::Milliseconds &rtt);
 
   void onDataReceived(int packet_size) {
     if (packet_size > this->max_packet_size_) {
@@ -149,7 +148,7 @@ class SimpleEstimator : public IcnRateEstimator {
  public:
   SimpleEstimator(double alpha, int batching_param);
 
-  void onRttUpdate(double rtt);
+  void onRttUpdate(const utils::SteadyTime::Milliseconds &rtt);
 
   void onDataReceived(int packet_size);
 
diff --git a/libtransport/src/protocols/reassembly.cc b/libtransport/src/protocols/reassembly.cc
index ce24fce1b..065458f7e 100644
--- a/libtransport/src/protocols/reassembly.cc
+++ b/libtransport/src/protocols/reassembly.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/protocols/reassembly.h b/libtransport/src/protocols/reassembly.h
index e072ad123..b0879201d 100644
--- a/libtransport/src/protocols/reassembly.h
+++ b/libtransport/src/protocols/reassembly.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -36,7 +36,7 @@ class Reassembly {
  public:
   class ContentReassembledCallback {
    public:
-    virtual void onContentReassembled(std::error_code ec) = 0;
+    virtual void onContentReassembled(const std::error_code &ec) = 0;
   };
 
   Reassembly(implementation::ConsumerSocket *icn_socket,
@@ -47,12 +47,12 @@ class Reassembly {
   virtual ~Reassembly() = default;
 
   /**
-   * Hanle reassembly of content object.
+   * Handle reassembly of content object.
    */
   virtual void reassemble(core::ContentObject &content_object) = 0;
 
   /**
-   * Hanle reassembly of content object.
+   * Handle reassembly of content object.
    */
   virtual void reassemble(utils::MemBuf &buffer, uint32_t suffix) = 0;
 
diff --git a/libtransport/src/protocols/rtc/CMakeLists.txt b/libtransport/src/protocols/rtc/CMakeLists.txt
index 873b345d0..be8e0189c 100644
--- a/libtransport/src/protocols/rtc/CMakeLists.txt
+++ b/libtransport/src/protocols/rtc/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -16,22 +16,43 @@ list(APPEND HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc.h
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc_consts.h
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc_data_path.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_forwarding_strategy.h
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc_indexer.h
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc_ldr.h
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc_packet.h
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rc.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rc_congestion_detection.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rc_iat.h
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rc_queue.h
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc_reassembly.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_recovery_strategy.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rs_delay.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rs_fec_only.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rs_low_rate.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rs_recovery_off.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rs_rtx_only.h
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc_state.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_verifier.h
 )
 
 list(APPEND SOURCE_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/probe_handler.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc_data_path.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_forwarding_strategy.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc_ldr.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rc_congestion_detection.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rc_iat.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rc_queue.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_reassembly.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_recovery_strategy.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rs_delay.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rs_fec_only.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rs_low_rate.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rs_recovery_off.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_rs_rtx_only.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/rtc_state.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rtc_verifier.cc
 )
 
 set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE)
diff --git a/libtransport/src/protocols/rtc/probe_handler.cc b/libtransport/src/protocols/rtc/probe_handler.cc
index abaca6ad9..abb234757 100644
--- a/libtransport/src/protocols/rtc/probe_handler.cc
+++ b/libtransport/src/protocols/rtc/probe_handler.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+#include <hicn/transport/utils/chrono_typedefs.h>
 #include <protocols/rtc/probe_handler.h>
 #include <protocols/rtc/rtc_consts.h>
 
@@ -27,6 +28,7 @@ ProbeHandler::ProbeHandler(SendProbeCallback &&send_callback,
     : probe_interval_(0),
       max_probes_(0),
       sent_probes_(0),
+      recv_probes_(0),
       probe_timer_(std::make_unique<asio::steady_timer>(io_service)),
       rand_eng_((std::random_device())()),
       distr_(MIN_RTT_PROBE_SEQ, MAX_RTT_PROBE_SEQ),
@@ -39,17 +41,25 @@ uint64_t ProbeHandler::getRtt(uint32_t seq) {
 
   if (it == pending_probes_.end()) return 0;
 
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
+  uint64_t now = utils::SteadyTime::nowMs().count();
   uint64_t rtt = now - it->second;
   if (rtt < 1) rtt = 1;
 
   pending_probes_.erase(it);
+  recv_probes_++;
 
   return rtt;
 }
 
+double ProbeHandler::getProbeLossRate() {
+  return 1.0 - ((double)recv_probes_ / (double)sent_probes_);
+}
+
+void ProbeHandler::setSuffixRange(uint32_t min, uint32_t max) {
+  assert(min <= max && min >= MIN_PROBE_SEQ);
+  distr_ = std::uniform_int_distribution<uint32_t>(min, max);
+}
+
 void ProbeHandler::setProbes(uint32_t probe_interval, uint32_t max_probes) {
   stopProbes();
   probe_interval_ = probe_interval;
@@ -60,6 +70,7 @@ void ProbeHandler::stopProbes() {
   probe_interval_ = 0;
   max_probes_ = 0;
   sent_probes_ = 0;
+  recv_probes_ = 0;
   probe_timer_->cancel();
 }
 
@@ -67,9 +78,7 @@ void ProbeHandler::sendProbes() {
   if (probe_interval_ == 0) return;
   if (max_probes_ != 0 && sent_probes_ >= max_probes_) return;
 
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
+  uint64_t now = utils::SteadyTime::nowMs().count();
 
   uint32_t seq = distr_(rand_eng_);
   pending_probes_.insert(std::pair<uint32_t, uint64_t>(seq, now));
@@ -92,14 +101,25 @@ void ProbeHandler::sendProbes() {
 
   std::weak_ptr<ProbeHandler> self(shared_from_this());
   probe_timer_->expires_from_now(std::chrono::microseconds(probe_interval_));
-  probe_timer_->async_wait([self](std::error_code ec) {
+  probe_timer_->async_wait([self](const std::error_code &ec) {
     if (ec) return;
-    if (auto s = self.lock()) {
+    auto s = self.lock();
+    if (s) {
       s->sendProbes();
     }
   });
 }
 
+ProbeType ProbeHandler::getProbeType(uint32_t seq) {
+  if (MIN_INIT_PROBE_SEQ <= seq && seq <= MAX_INIT_PROBE_SEQ) {
+    return ProbeType::INIT;
+  }
+  if (MIN_RTT_PROBE_SEQ <= seq && seq <= MAX_RTT_PROBE_SEQ) {
+    return ProbeType::RTT;
+  }
+  return ProbeType::NOT_PROBE;
+}
+
 }  // namespace rtc
 
 }  // namespace protocol
diff --git a/libtransport/src/protocols/rtc/probe_handler.h b/libtransport/src/protocols/rtc/probe_handler.h
index e34b23df0..2de908176 100644
--- a/libtransport/src/protocols/rtc/probe_handler.h
+++ b/libtransport/src/protocols/rtc/probe_handler.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -26,6 +26,12 @@ namespace protocol {
 
 namespace rtc {
 
+enum class ProbeType {
+  NOT_PROBE,
+  INIT,
+  RTT,
+};
+
 class ProbeHandler : public std::enable_shared_from_this<ProbeHandler> {
  public:
   using SendProbeCallback = std::function<void(uint32_t)>;
@@ -35,31 +41,39 @@ class ProbeHandler : public std::enable_shared_from_this<ProbeHandler> {
 
   ~ProbeHandler();
 
-  // if the function returns 0 the probe is not valaid
+  // If the function returns 0 the probe is not valid.
   uint64_t getRtt(uint32_t seq);
 
-  // reset the probes parameters. it stop the current probing.
-  // to restar call sendProbes.
-  // probe_interval = 0 means that no event will be scheduled
-  // max_probe = 0 means no limit to the number of probe to send
+  // this function may return a residual loss rate higher than the real one if
+  // we don't wait enough time for the probes to come back
+  double getProbeLossRate();
+
+  // Set the probe suffix range [min, max]
+  void setSuffixRange(uint32_t min, uint32_t max);
+
+  // Reset the probes parameters and stops the current probing.
+  // probe_interval = 0 means that no event will be scheduled.
+  // max_probe = 0 means no limit to the number of probe to send.
   void setProbes(uint32_t probe_interval, uint32_t max_probes);
 
-  // stop to schedule probes
   void stopProbes();
 
   void sendProbes();
 
+  static ProbeType getProbeType(uint32_t seq);
+
  private:
   uint32_t probe_interval_;  // us
   uint32_t max_probes_;      // packets
   uint32_t sent_probes_;     // packets
+  uint32_t recv_probes_;     // packets
 
   std::unique_ptr<asio::steady_timer> probe_timer_;
 
-  // map from seqnumber to timestamp
+  // Map from packet suffixes to timestamp
   std::unordered_map<uint32_t, uint64_t> pending_probes_;
 
-  // random generator
+  // Random generator
   std::default_random_engine rand_eng_;
   std::uniform_int_distribution<uint32_t> distr_;
 
diff --git a/libtransport/src/protocols/rtc/rtc.cc b/libtransport/src/protocols/rtc/rtc.cc
index 0cb4cda1d..df6522471 100644
--- a/libtransport/src/protocols/rtc/rtc.cc
+++ b/libtransport/src/protocols/rtc/rtc.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -22,7 +22,7 @@
 #include <protocols/rtc/rtc.h>
 #include <protocols/rtc/rtc_consts.h>
 #include <protocols/rtc/rtc_indexer.h>
-#include <protocols/rtc/rtc_rc_queue.h>
+#include <protocols/rtc/rtc_rc_congestion_detection.h>
 
 #include <algorithm>
 
@@ -37,13 +37,15 @@ using namespace interface;
 RTCTransportProtocol::RTCTransportProtocol(
     implementation::ConsumerSocket *icn_socket)
     : TransportProtocol(icn_socket, new RtcIndexer<>(icn_socket, this),
-                        new DatagramReassembly(icn_socket, this)),
+                        new RtcReassembly(icn_socket, this)),
       number_(0) {
   icn_socket->getSocketOption(PORTAL, portal_);
-  round_timer_ = std::make_unique<asio::steady_timer>(portal_->getIoService());
+  round_timer_ =
+      std::make_unique<asio::steady_timer>(portal_->getThread().getIoService());
   scheduler_timer_ =
-      std::make_unique<asio::steady_timer>(portal_->getIoService());
-  pacing_timer_ = std::make_unique<asio::steady_timer>(portal_->getIoService());
+      std::make_unique<asio::steady_timer>(portal_->getThread().getIoService());
+  pacing_timer_ =
+      std::make_unique<asio::steady_timer>(portal_->getThread().getIoService());
 }
 
 RTCTransportProtocol::~RTCTransportProtocol() {}
@@ -61,25 +63,52 @@ std::size_t RTCTransportProtocol::transportHeaderLength() {
 // private
 void RTCTransportProtocol::initParams() {
   TransportProtocol::reset();
+  fwd_strategy_.setCallback(on_fwd_strategy_);
 
-  rc_ = std::make_shared<RTCRateControlQueue>();
+  std::weak_ptr<RTCTransportProtocol> self = shared_from_this();
+
+  std::shared_ptr<auth::Verifier> verifier;
+  socket_->getSocketOption(GeneralTransportOptions::VERIFIER, verifier);
+
+  uint32_t max_unverified_delay;
+  socket_->getSocketOption(GeneralTransportOptions::MAX_UNVERIFIED_TIME,
+                           max_unverified_delay);
+
+  rc_ = std::make_shared<RTCRateControlCongestionDetection>();
   ldr_ = std::make_shared<RTCLossDetectionAndRecovery>(
-      indexer_verifier_.get(),
-      std::bind(&RTCTransportProtocol::sendRtxInterest, this,
-                std::placeholders::_1),
-      portal_->getIoService());
+      indexer_verifier_.get(), portal_->getThread().getIoService(),
+      interface::RtcTransportRecoveryStrategies::RTX_ONLY,
+      [self](uint32_t seq) {
+        auto ptr = self.lock();
+        if (ptr && ptr->isRunning()) {
+          ptr->sendRtxInterest(seq);
+        }
+      },
+      on_rec_strategy_);
+  verifier_ = std::make_shared<RTCVerifier>(verifier, max_unverified_delay);
 
   state_ = std::make_shared<RTCState>(
       indexer_verifier_.get(),
-      std::bind(&RTCTransportProtocol::sendProbeInterest, this,
-                std::placeholders::_1),
-      std::bind(&RTCTransportProtocol::discoveredRtt, this),
-      portal_->getIoService());
+      [self](uint32_t seq) {
+        auto ptr = self.lock();
+        if (ptr && ptr->isRunning()) {
+          ptr->sendProbeInterest(seq);
+        }
+      },
+      [self]() {
+        auto ptr = self.lock();
+        if (ptr && ptr->isRunning()) {
+          ptr->discoveredRtt();
+        }
+      },
+      portal_->getThread().getIoService());
+  state_->initParams();
 
   rc_->setState(state_);
-  // TODO: for the moment we keep the congestion control disabled
-  // rc_->tunrOnRateControl();
-  ldr_->setState(state_);
+  rc_->turnOnRateControl();
+  ldr_->setState(state_.get());
+  ldr_->setRateControl(rc_.get());
+  verifier_->setState(state_);
 
   // protocol state
   start_send_interest_ = false;
@@ -102,6 +131,10 @@ void RTCTransportProtocol::initParams() {
   }
 #else
   max_aggregated_interest_ = 1;
+  if (const char *max_aggr = std::getenv("MAX_AGGREGATED_INTERESTS")) {
+    LOG(INFO) << "Max Aggregated: " << max_aggr;
+    max_aggregated_interest_ = std::stoul(std::string(max_aggr));
+  }
 #endif
 
   max_sent_int_ =
@@ -131,6 +164,7 @@ void RTCTransportProtocol::initParams() {
     indexer_verifier_->setNFec(0);
     ldr_->setFecParams(fec::FECUtils::getBlockSymbols(fec_type_),
                        fec::FECUtils::getSourceSymbols(fec_type_));
+    fec_decoder_->setIOService(portal_->getThread().getIoService());
   } else {
     indexer_verifier_->disableFec();
   }
@@ -162,61 +196,97 @@ void RTCTransportProtocol::inactiveProducer() {
 
 void RTCTransportProtocol::newRound() {
   round_timer_->expires_from_now(std::chrono::milliseconds(ROUND_LEN));
-  // TODO pass weak_ptr here
-  round_timer_->async_wait([this, n{number_}](std::error_code ec) {
-    if (ec) return;
 
-    if (n != number_) {
+  std::weak_ptr<RTCTransportProtocol> self = shared_from_this();
+  round_timer_->async_wait([self](const std::error_code &ec) {
+    if (ec) {
       return;
     }
 
+    auto ptr = self.lock();
+
+    if (!ptr || !ptr->isRunning()) {
+      return;
+    }
+
+    auto &state = ptr->state_;
+
     // saving counters that will be reset on new round
-    uint32_t sent_retx = state_->getSentRtxInRound();
-    uint32_t received_bytes = state_->getReceivedBytesInRound();
-    uint32_t sent_interest = state_->getSentInterestInRound();
-    uint32_t lost_data = state_->getLostData();
-    uint32_t definitely_lost = state_->getDefinitelyLostPackets();
-    uint32_t recovered_losses = state_->getRecoveredLosses();
-    uint32_t received_nacks = state_->getReceivedNacksInRound();
-    uint32_t received_fec = state_->getReceivedFecPackets();
-
-    bool in_sync = (current_state_ == SyncState::in_sync);
-    ldr_->onNewRound(in_sync);
-    state_->onNewRound((double)ROUND_LEN, in_sync);
-    rc_->onNewRound((double)ROUND_LEN);
+    uint32_t sent_retx = state->getSentRtxInRound();
+    uint32_t received_bytes =
+        (state->getReceivedBytesInRound() +     // data packets received
+         state->getReceivedFecBytesInRound());  // fec packets received
+    uint32_t sent_interest = state->getSentInterestInRound();
+    uint32_t lost_data = state->getLostData();
+    uint32_t definitely_lost = state->getDefinitelyLostPackets();
+    uint32_t recovered_losses = state->getRecoveredLosses();
+    uint32_t received_nacks = state->getReceivedNacksInRound();
+    uint32_t received_fec = state->getReceivedFecPackets();
+
+    bool in_sync = (ptr->current_state_ == SyncState::in_sync);
+    ptr->ldr_->onNewRound(in_sync);
+    ptr->state_->onNewRound((double)ROUND_LEN, in_sync);
+    ptr->rc_->onNewRound((double)ROUND_LEN);
 
     // update sync state if needed
-    if (current_state_ == SyncState::in_sync) {
-      double cache_rate = state_->getPacketFromCacheRatio();
+    if (ptr->current_state_ == SyncState::in_sync) {
+      double cache_rate = state->getPacketFromCacheRatio();
       if (cache_rate > MAX_DATA_FROM_CACHE) {
-        current_state_ = SyncState::catch_up;
+        ptr->current_state_ = SyncState::catch_up;
       }
     } else {
-      double target_rate = state_->getProducerRate() * PRODUCTION_RATE_FRACTION;
-      double received_rate = state_->getReceivedRate();
-      uint32_t round_without_nacks = state_->getRoundsWithoutNacks();
-      double cache_ratio = state_->getPacketFromCacheRatio();
+      double target_rate = state->getProducerRate() * PRODUCTION_RATE_FRACTION;
+      double received_rate =
+          state->getReceivedRate() + state->getRecoveredFecRate();
+      uint32_t round_without_nacks = state->getRoundsWithoutNacks();
+      double cache_ratio = state->getPacketFromCacheRatio();
       if (round_without_nacks >= ROUNDS_IN_SYNC_BEFORE_SWITCH &&
           received_rate >= target_rate && cache_ratio < MAX_DATA_FROM_CACHE) {
-        current_state_ = SyncState::in_sync;
+        ptr->current_state_ = SyncState::in_sync;
       }
     }
 
     DLOG_IF(INFO, VLOG_IS_ON(3))
         << "Calling updateSyncWindow in newRound function";
-    updateSyncWindow();
+    ptr->updateSyncWindow();
 
-    sendStatsToApp(sent_retx, received_bytes, sent_interest, lost_data,
-                   definitely_lost, recovered_losses, received_nacks,
-                   received_fec);
-    newRound();
+    ptr->sendStatsToApp(sent_retx, received_bytes, sent_interest, lost_data,
+                        definitely_lost, recovered_losses, received_nacks,
+                        received_fec);
+    ptr->fwd_strategy_.checkStrategy();
+    ptr->newRound();
   });
 }
 
 void RTCTransportProtocol::discoveredRtt() {
   start_send_interest_ = true;
-  ldr_->turnOnRTX();
+  uint32_t strategy;
+  socket_->getSocketOption(RtcTransportOptions::RECOVERY_STRATEGY, strategy);
+  ldr_->changeRecoveryStrategy(
+      (interface::RtcTransportRecoveryStrategies)strategy);
+  ldr_->turnOnRecovery();
   ldr_->onNewRound(false);
+
+  // set forwarding strategy switch if selected
+  Name *name = nullptr;
+  socket_->getSocketOption(GeneralTransportOptions::NETWORK_NAME, &name);
+  Prefix prefix(*name, 128);
+  if ((interface::RtcTransportRecoveryStrategies)strategy ==
+      interface::RtcTransportRecoveryStrategies::LOW_RATE_AND_BESTPATH) {
+    fwd_strategy_.initFwdStrategy(portal_, prefix, state_.get(),
+                                  RTCForwardingStrategy::BEST_PATH);
+  } else if ((interface::RtcTransportRecoveryStrategies)strategy ==
+             interface::RtcTransportRecoveryStrategies::
+                 LOW_RATE_AND_REPLICATION) {
+    fwd_strategy_.initFwdStrategy(portal_, prefix, state_.get(),
+                                  RTCForwardingStrategy::REPLICATION);
+  } else if ((interface::RtcTransportRecoveryStrategies)strategy ==
+             interface::RtcTransportRecoveryStrategies::
+                 LOW_RATE_AND_ALL_FWD_STRATEGIES) {
+    fwd_strategy_.initFwdStrategy(portal_, prefix, state_.get(),
+                                  RTCForwardingStrategy::BOTH);
+  }
+
   updateSyncWindow();
 }
 
@@ -244,7 +314,7 @@ void RTCTransportProtocol::computeMaxSyncWindow() {
       (production_rate * lifetime_ms * INTEREST_LIFETIME_REDUCTION_FACTOR) /
       packet_size);
 
-  max_sync_win_ = std::min(max_sync_win_, rc_->getCongesionWindow());
+  max_sync_win_ = std::min(max_sync_win_, rc_->getCongestionWindow());
 }
 
 void RTCTransportProtocol::updateSyncWindow() {
@@ -259,25 +329,14 @@ void RTCTransportProtocol::updateSyncWindow() {
   }
 
   double prod_rate = state_->getProducerRate();
-  double rtt = (double)state_->getRTT() / MILLI_IN_A_SEC;
+  double rtt = (double)state_->getMinRTT() / MILLI_IN_A_SEC;
   double packet_size = state_->getAveragePacketSize();
 
   // if some of the info are not available do not update the current win
   if (prod_rate != 0.0 && rtt != 0.0 && packet_size != 0.0) {
-    double fec_interest_overhead = (double)state_->getPendingFecPackets() /
-                                   (double)(state_->getPendingInterestNumber() -
-                                            state_->getPendingFecPackets());
-
-    double fec_overhead =
-        std::max(indexer_verifier_->getFecOverhead(), fec_interest_overhead);
-
-    prod_rate += (prod_rate * fec_overhead);
-
     current_sync_win_ = (uint32_t)ceil(prod_rate * rtt / packet_size);
     uint32_t buffer = PRODUCER_BUFFER_MS;
-    if (rtt > 150)
-      buffer = buffer * 2;  // if the RTT is too large we increase the
-                            // the size of the buffer
+
     current_sync_win_ +=
         ceil(prod_rate * (buffer / MILLI_IN_A_SEC) / packet_size);
 
@@ -285,8 +344,17 @@ void RTCTransportProtocol::updateSyncWindow() {
       current_sync_win_ = current_sync_win_ * CATCH_UP_WIN_INCREMENT;
     }
 
+    uint32_t min_win = WIN_MIN;
+    bool aggregated_data_on;
+    socket_->getSocketOption(RtcTransportOptions::AGGREGATED_DATA,
+                             aggregated_data_on);
+    if (aggregated_data_on) {
+      min_win = WIN_MIN_WITH_AGGREGARED_DATA;
+      min_win += (min_win * (1 - (std::max(0.3, rtt) - rtt) / 0.3));
+    }
+
     current_sync_win_ = std::min(current_sync_win_, max_sync_win_);
-    current_sync_win_ = std::max(current_sync_win_, WIN_MIN);
+    current_sync_win_ = std::max(current_sync_win_, min_win);
   }
 
   scheduleNextInterests();
@@ -322,7 +390,7 @@ void RTCTransportProtocol::sendProbeInterest(uint32_t seq) {
   socket_->getSocketOption(GeneralTransportOptions::NETWORK_NAME,
                            &interest_name);
 
-  DLOG_IF(INFO, VLOG_IS_ON(3)) << "send probe " << seq;
+  DLOG_IF(INFO, VLOG_IS_ON(3)) << "Send probe " << seq;
   interest_name->setSuffix(seq);
   sendInterest(*interest_name);
 }
@@ -330,13 +398,18 @@ void RTCTransportProtocol::sendProbeInterest(uint32_t seq) {
 void RTCTransportProtocol::scheduleNextInterests() {
   DLOG_IF(INFO, VLOG_IS_ON(3)) << "Schedule next interests";
 
-  if (!isRunning() && !is_first_) return;
+  if (!isRunning() && !is_first_) {
+    return;
+  }
 
-  if (pacing_timer_on_) return;  // wait pacing timer for the next send
+  if (pacing_timer_on_) {
+    return;  // wait pacing timer for the next send
+  }
 
-  if (!start_send_interest_)
+  if (!start_send_interest_) {
     return;  // RTT discovering phase is not finished so
              // do not start to send interests
+  }
 
   if (TRANSPORT_EXPECT_FALSE(!state_->isProducerActive())) {
     DLOG_IF(INFO, VLOG_IS_ON(3)) << "Inactive producer.";
@@ -352,7 +425,7 @@ void RTCTransportProtocol::scheduleNextInterests() {
                              &interest_name);
 
     uint32_t next_seg = 0;
-    DLOG_IF(INFO, VLOG_IS_ON(3)) << "send interest " << next_seg;
+    DLOG_IF(INFO, VLOG_IS_ON(3)) << "Send interest " << next_seg;
     interest_name->setSuffix(next_seg);
 
     if (portal_->interestIsPending(*interest_name)) {
@@ -370,28 +443,37 @@ void RTCTransportProtocol::scheduleNextInterests() {
       << " -- current_sync_win_: " << current_sync_win_;
 
   uint32_t pending = state_->getPendingInterestNumber();
-  if (pending >= current_sync_win_) return;  // no space in the window
+  uint32_t pending_fec = state_->getPendingFecPackets();
+
+  if ((pending - pending_fec) >= current_sync_win_)
+    return;  // no space in the window
 
-  if ((current_sync_win_ - pending) < max_aggregated_interest_) {
+  // XXX double check if aggregated interests are still working here
+  if ((current_sync_win_ - (pending - pending_fec)) <
+      max_aggregated_interest_) {
     if (scheduler_timer_on_) return;  // timer already scheduled
 
-    uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                       std::chrono::steady_clock::now().time_since_epoch())
-                       .count();
+    uint64_t now = utils::SteadyTime::nowMs().count();
 
     uint64_t time = now - last_interest_sent_time_;
     if (time < WAIT_FOR_INTEREST_BATCH) {
       uint64_t next = WAIT_FOR_INTEREST_BATCH - time;
       scheduler_timer_on_ = true;
       scheduler_timer_->expires_from_now(std::chrono::milliseconds(next));
-      scheduler_timer_->async_wait([this](std::error_code ec) {
+
+      std::weak_ptr<RTCTransportProtocol> self = shared_from_this();
+      scheduler_timer_->async_wait([self](const std::error_code &ec) {
         if (ec) return;
-        if (!scheduler_timer_on_) return;
 
-        scheduler_timer_on_ = false;
-        scheduleNextInterests();
+        auto ptr = self.lock();
+        if (ptr && ptr->isRunning()) {
+          if (!ptr->scheduler_timer_on_) return;
+
+          ptr->scheduler_timer_on_ = false;
+          ptr->scheduleNextInterests();
+        }
       });
-      return;  // whait for the timer
+      return;  // wait for the timer
     }
   }
 
@@ -403,7 +485,7 @@ void RTCTransportProtocol::scheduleNextInterests() {
     indexer_verifier_->jumpToIndex(state_->getLastSeqNacked() + 1);
   }
 
-  // skipe received packets
+  // skip received packets
   if (indexer_verifier_->checkNextSuffix() <=
       state_->getHighestSeqReceivedInOrder()) {
     indexer_verifier_->jumpToIndex(state_->getHighestSeqReceivedInOrder() + 1);
@@ -417,7 +499,8 @@ void RTCTransportProtocol::scheduleNextInterests() {
   socket_->getSocketOption(GeneralTransportOptions::NETWORK_NAME, &name);
   std::array<uint32_t, MAX_AGGREGATED_INTEREST> additional_suffixes;
 
-  while ((state_->getPendingInterestNumber() < current_sync_win_) &&
+  while (((state_->getPendingInterestNumber() -
+           state_->getPendingFecPackets()) < current_sync_win_) &&
          (sent_interests < max_sent_int_)) {
     DLOG_IF(INFO, VLOG_IS_ON(3))
         << "In while loop. Window size: " << current_sync_win_;
@@ -428,19 +511,20 @@ void RTCTransportProtocol::scheduleNextInterests() {
 
     // send the packet only if:
     // 1) it is not pending yet (not true for rtx)
-    // 2) the packet is not received or lost
+    // 2) the packet is not received or def lost
     // 3) is not in the rtx list
     // 4) is fec and is not in order (!= last sent + 1)
+    PacketState packet_state = state_->getPacketState(next_seg);
     if (portal_->interestIsPending(*name) ||
-        state_->isReceivedOrLost(next_seg) != PacketState::UNKNOWN ||
-        ldr_->isRtx(next_seg) ||
+        packet_state == PacketState::RECEIVED ||
+        packet_state == PacketState::DEFINITELY_LOST || ldr_->isRtx(next_seg) ||
         (indexer_verifier_->isFec(next_seg) &&
          next_seg != last_interest_sent_seq_ + 1)) {
       DLOG_IF(INFO, VLOG_IS_ON(3))
           << "skip interest " << next_seg << " because: pending "
-          << portal_->interestIsPending(*name) << ", recv "
-          << (state_->isReceivedOrLost(next_seg) != PacketState::UNKNOWN)
-          << ", rtx " << (ldr_->isRtx(next_seg)) << ", is old fec "
+          << portal_->interestIsPending(*name) << ", recv or lost"
+          << (int)packet_state << ", rtx " << (ldr_->isRtx(next_seg))
+          << ", is old fec "
           << ((indexer_verifier_->isFec(next_seg) &&
                next_seg != last_interest_sent_seq_ + 1));
       continue;
@@ -462,10 +546,7 @@ void RTCTransportProtocol::scheduleNextInterests() {
       sent_packets++;
       sent_interests++;
       sendInterest(interest_name, &additional_suffixes, aggregated_counter - 1);
-      last_interest_sent_time_ =
-          std::chrono::duration_cast<std::chrono::milliseconds>(
-              std::chrono::steady_clock::now().time_since_epoch())
-              .count();
+      last_interest_sent_time_ = utils::SteadyTime::nowMs().count();
       aggregated_counter = 0;
     }
   }
@@ -473,25 +554,29 @@ void RTCTransportProtocol::scheduleNextInterests() {
   // exiting the while we may have some pending interest to send
   if (aggregated_counter != 0) {
     sent_packets++;
-    last_interest_sent_time_ =
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now().time_since_epoch())
-            .count();
+    last_interest_sent_time_ = utils::SteadyTime::nowMs().count();
     sendInterest(interest_name, &additional_suffixes, aggregated_counter - 1);
   }
 
-  if (state_->getPendingInterestNumber() < current_sync_win_) {
+  if ((state_->getPendingInterestNumber() - state_->getPendingFecPackets()) <
+      current_sync_win_) {
     // we still have space in the window but we already sent too many packets
     // wait PACING_WAIT to avoid drops in the kernel
 
     pacing_timer_on_ = true;
     pacing_timer_->expires_from_now(std::chrono::microseconds(PACING_WAIT));
-    scheduler_timer_->async_wait([this](std::error_code ec) {
+
+    std::weak_ptr<RTCTransportProtocol> self = shared_from_this();
+    scheduler_timer_->async_wait([self](const std::error_code &ec) {
       if (ec) return;
-      if (!pacing_timer_on_) return;
 
-      pacing_timer_on_ = false;
-      scheduleNextInterests();
+      auto ptr = self.lock();
+      if (ptr && ptr->isRunning()) {
+        if (!ptr->pacing_timer_on_) return;
+
+        ptr->pacing_timer_on_ = false;
+        ptr->scheduleNextInterests();
+      }
     });
   }
 }
@@ -500,13 +585,13 @@ void RTCTransportProtocol::onInterestTimeout(Interest::Ptr &interest,
                                              const Name &name) {
   uint32_t segment_number = name.getSuffix();
 
-  if (segment_number >= MIN_PROBE_SEQ) {
+  if (ProbeHandler::getProbeType(segment_number) != ProbeType::NOT_PROBE) {
     // this is a timeout on a probe, do nothing
     return;
   }
 
-  PacketState state = state_->isReceivedOrLost(segment_number);
-  if (state != PacketState::UNKNOWN) {
+  PacketState state = state_->getPacketState(segment_number);
+  if (state == PacketState::RECEIVED || state == PacketState::DEFINITELY_LOST) {
     // we may recover a packets using fec, ignore this timer
     return;
   }
@@ -524,13 +609,18 @@ void RTCTransportProtocol::onInterestTimeout(Interest::Ptr &interest,
     DLOG_IF(INFO, VLOG_IS_ON(3))
         << "handle timeout for packet  " << segment_number << " using rtx";
     if (ldr_->isRtxOn()) {
-      ldr_->onTimeout(segment_number);
-      if (indexer_verifier_->isFec(segment_number))
+      if (indexer_verifier_->isFec(segment_number)) {
+        // if this is a fec packet we do not recover it with rtx so we consider
+        // the packet to be lost
+        ldr_->onTimeout(segment_number, true);
         state_->onTimeout(segment_number, true);
-      else
+      } else {
+        ldr_->onTimeout(segment_number, false);
         state_->onTimeout(segment_number, false);
+      }
     } else {
       // in this case we wil never recover the timeout
+      ldr_->onTimeout(segment_number, true);
       state_->onTimeout(segment_number, true);
     }
     scheduleNextInterests();
@@ -559,7 +649,7 @@ void RTCTransportProtocol::onInterestTimeout(Interest::Ptr &interest,
 void RTCTransportProtocol::onNack(const ContentObject &content_object) {
   struct nack_packet_t *nack =
       (struct nack_packet_t *)content_object.getPayload()->data();
-  uint32_t production_seg = nack->getProductionSegement();
+  uint32_t production_seg = nack->getProductionSegment();
   uint32_t nack_segment = content_object.getName().getSuffix();
   bool is_rtx = ldr_->isRtx(nack_segment);
 
@@ -592,6 +682,8 @@ void RTCTransportProtocol::onNack(const ContentObject &content_object) {
     // remove the nack is it exists
     if (tn_it != timeouts_or_nacks_.end()) timeouts_or_nacks_.erase(tn_it);
 
+    state_->onJumpForward(production_seg);
+    verifier_->onJumpForward(production_seg);
     // the client is asking for content in the past
     // switch to catch up state and increase the window
     // this is true only if the packet is not an RTX
@@ -618,11 +710,9 @@ void RTCTransportProtocol::onProbe(const ContentObject &content_object) {
   bool valid = state_->onProbePacketReceived(content_object);
   if (!valid) return;
 
-  struct nack_packet_t *probe =
-      (struct nack_packet_t *)content_object.getPayload()->data();
-  uint32_t production_seg = probe->getProductionSegement();
+  uint32_t production_seg = RTCState::getProbeParams(content_object).prod_seg;
 
-  // as for the nacks set next_segment
+  // As for the nacks set next_segment
   DLOG_IF(INFO, VLOG_IS_ON(3))
       << "on probe next seg = " << indexer_verifier_->checkNextSuffix()
       << ", jump to " << production_seg;
@@ -636,12 +726,39 @@ void RTCTransportProtocol::onContentObjectReceived(
     Interest &interest, ContentObject &content_object, std::error_code &ec) {
   DLOG_IF(INFO, VLOG_IS_ON(3))
       << "Received content object of size: " << content_object.payloadSize();
-  uint32_t payload_size = content_object.payloadSize();
+
   uint32_t segment_number = content_object.getName().getSuffix();
+  PayloadType payload_type = content_object.getPayloadType();
+  PacketState state;
+
+  ContentObject *content_ptr = &content_object;
+  ContentObject::Ptr manifest_ptr = nullptr;
+
+  bool is_probe =
+      ProbeHandler::getProbeType(segment_number) != ProbeType::NOT_PROBE;
+  bool is_nack = !is_probe && content_object.payloadSize() == NACK_HEADER_SIZE;
+  bool is_fec = indexer_verifier_->isFec(segment_number);
+  bool is_manifest =
+      !is_probe && !is_nack && !is_fec && payload_type == PayloadType::MANIFEST;
+  bool is_data =
+      !is_probe && !is_nack && !is_fec && payload_type == PayloadType::DATA;
+  bool compute_stats = is_data || is_manifest;
 
   ec = make_error_code(protocol_error::not_reassemblable);
 
-  if (segment_number >= MIN_PROBE_SEQ) {
+  // A helper function to process manifests or data packets received
+  auto onDataPacketReceived = [this](ContentObject &content_object,
+                                     bool compute_stats) {
+    ldr_->onDataPacketReceived(content_object);
+    rc_->onDataPacketReceived(content_object, compute_stats);
+    updateSyncWindow();
+  };
+
+  // First verify the packet signature and apply the corresponding policy
+  auth::VerificationPolicy policy = verifier_->verify(content_object, is_fec);
+  indexer_verifier_->applyPolicy(interest, content_object, false, policy);
+
+  if (is_probe) {
     DLOG_IF(INFO, VLOG_IS_ON(3)) << "Received probe " << segment_number;
     if (*on_content_object_input_) {
       (*on_content_object_input_)(*socket_->getInterface(), content_object);
@@ -650,7 +767,7 @@ void RTCTransportProtocol::onContentObjectReceived(
     return;
   }
 
-  if (payload_size == NACK_HEADER_SIZE) {
+  if (is_nack) {
     DLOG_IF(INFO, VLOG_IS_ON(3)) << "Received nack " << segment_number;
     if (*on_content_object_input_) {
       (*on_content_object_input_)(*socket_->getInterface(), content_object);
@@ -659,57 +776,122 @@ void RTCTransportProtocol::onContentObjectReceived(
     return;
   }
 
+  // content_ptr will point either to the input data packet or to a manifest
+  // whose FEC header has been removed
+  if (is_manifest) {
+    manifest_ptr = removeFecHeader(content_object);
+    if (manifest_ptr) {
+      content_ptr = manifest_ptr.get();
+    }
+  }
+
+  // From there, the packet is either a FEC, a manifest or a data packet.
   DLOG_IF(INFO, VLOG_IS_ON(3)) << "Received content " << segment_number;
 
-  bool compute_stats = true;
+  // Do not count timed out packets in stats
   auto tn_it = timeouts_or_nacks_.find(segment_number);
   if (tn_it != timeouts_or_nacks_.end()) {
     compute_stats = false;
     timeouts_or_nacks_.erase(tn_it);
   }
-  if (ldr_->isRtx(segment_number)) {
+
+  // Do not count retransmissions or losses in stats
+  if (ldr_->isRtx(segment_number) ||
+      ldr_->isPossibleLossWithNoRtx(segment_number)) {
     compute_stats = false;
   }
 
-  // check if the packet was already received
-  PacketState state = state_->isReceivedOrLost(segment_number);
+  // Fetch packet state
+  state = state_->getPacketState(segment_number);
 
-  if (state != PacketState::RECEIVED) {
-    // send packet to decoder
-    if (fec_decoder_) {
-      DLOG_IF(INFO, VLOG_IS_ON(4))
-          << "send packet " << segment_number << " to FEC decoder";
-      fec_decoder_->onDataPacket(
-          content_object, content_object.headerSize() + rtc::DATA_HEADER_SIZE);
-    }
-    if (!indexer_verifier_->isFec(segment_number)) {
-      // the packet may be alredy sent to the ap by the decoder, check again if
-      // it is already received
-      state = state_->isReceivedOrLost(segment_number);
-      if (state != PacketState::RECEIVED) {
-        DLOG_IF(INFO, VLOG_IS_ON(4)) << "Received content " << segment_number;
+  // Check if the packet is a retransmission
+  if (ldr_->isRtx(segment_number) && state != PacketState::RECEIVED) {
+    if (is_data || is_manifest) {
+      state_->onPacketRecoveredRtx(segment_number);
 
-        state_->onDataPacketReceived(content_object, compute_stats);
+      if (*on_content_object_input_) {
+        (*on_content_object_input_)(*socket_->getInterface(), content_object);
+      }
 
-        if (*on_content_object_input_) {
-          (*on_content_object_input_)(*socket_->getInterface(), content_object);
-        }
-        ec = make_error_code(protocol_error::success);
+      if (is_manifest) {
+        processManifest(interest, *content_ptr);
       }
-    } else {
-      DLOG_IF(INFO, VLOG_IS_ON(4)) << "Received fec " << segment_number;
-      state_->onFecPacketReceived(content_object);
+
+      ec = is_manifest ? make_error_code(protocol_error::not_reassemblable)
+                       : make_error_code(protocol_error::success);
+
+      // The packet is considered received, return early
+      onDataPacketReceived(*content_ptr, compute_stats);
+      return;
     }
-  } else {
+
+    if (is_fec) {
+      state_->onFecPacketRecoveredRtx(segment_number);
+    }
+  }
+
+  // Fetch packet state again; it may have changed
+  state = state_->getPacketState(segment_number);
+
+  // Check if the packet was already received
+  if (state == PacketState::RECEIVED || state == PacketState::TO_BE_RECEIVED) {
     DLOG_IF(INFO, VLOG_IS_ON(3))
         << "Received duplicated content " << segment_number << ", drop it";
     ec = make_error_code(protocol_error::duplicated_content);
+    onDataPacketReceived(*content_ptr, compute_stats);
+    return;
   }
 
-  ldr_->onDataPacketReceived(content_object);
-  rc_->onDataPacketReceived(content_object);
+  if (!is_fec) {
+    state_->dataToBeReceived(segment_number);
+  }
 
-  updateSyncWindow();
+  // Send packet to FEC decoder
+  if (fec_decoder_) {
+    DLOG_IF(INFO, VLOG_IS_ON(4))
+        << "Send packet " << segment_number << " to FEC decoder";
+
+    uint32_t offset = is_manifest
+                          ? content_object.headerSize()
+                          : content_object.headerSize() + rtc::DATA_HEADER_SIZE;
+    uint32_t metadata = static_cast<uint32_t>(content_object.getPayloadType());
+
+    fec_decoder_->onDataPacket(content_object, offset, metadata);
+  }
+
+  // We can return early if FEC
+  if (is_fec) {
+    DLOG_IF(INFO, VLOG_IS_ON(4)) << "Received FEC " << segment_number;
+    state_->onFecPacketReceived(content_object);
+    onDataPacketReceived(*content_ptr, compute_stats);
+    return;
+  }
+
+  // The packet may have been already sent to the app by the decoder, check
+  // again if it is already received
+  state = state_->getPacketState(
+      segment_number);  // state == RECEIVED or TO_BE_RECEIVED
+
+  if (state != PacketState::RECEIVED) {
+    DLOG_IF(INFO, VLOG_IS_ON(4))
+        << (is_manifest ? "Received manifest " : "Received data ")
+        << segment_number;
+
+    if (is_manifest) {
+      processManifest(interest, *content_ptr);
+    }
+
+    state_->onDataPacketReceived(*content_ptr, compute_stats);
+
+    if (*on_content_object_input_) {
+      (*on_content_object_input_)(*socket_->getInterface(), content_object);
+    }
+
+    ec = is_manifest ? make_error_code(protocol_error::not_reassemblable)
+                     : make_error_code(protocol_error::success);
+  }
+
+  onDataPacketReceived(*content_ptr, compute_stats);
 }
 
 void RTCTransportProtocol::sendStatsToApp(
@@ -729,33 +911,149 @@ void RTCTransportProtocol::sendStatsToApp(
     stats_->updateReceivedNacks(received_nacks);
     stats_->updateReceivedFEC(received_fec);
 
-    stats_->updateAverageWindowSize(current_sync_win_);
-    stats_->updateLossRatio(state_->getLossRate());
-    stats_->updateAverageRtt(state_->getRTT());
+    stats_->updateAverageWindowSize(state_->getPendingInterestNumber());
+    stats_->updateLossRatio(state_->getPerSecondLossRate());
+    uint64_t rtt = state_->getAvgRTT();
+    stats_->updateAverageRtt(utils::SteadyTime::Milliseconds(rtt));
+
     stats_->updateQueuingDelay(state_->getQueuing());
     stats_->updateLostData(lost_data);
     stats_->updateDefinitelyLostData(definitely_lost);
     stats_->updateRecoveredData(recovered_losses);
     stats_->updateCCState((unsigned int)current_state_ ? 1 : 0);
     (*stats_summary_)(*socket_->getInterface(), *stats_);
+    bool in_congestion = rc_->inCongestionState();
+    stats_->updateCongestionState(in_congestion);
+    double residual_losses = state_->getResidualLossRate();
+    stats_->updateResidualLossRate(residual_losses);
+    stats_->updateQualityScore(state_->getQualityScore());
+
+    // set alerts
+    if (rtt > MAX_RTT)
+      stats_->setAlert(interface::TransportStatistics::statsAlerts::LATENCY);
+    else
+      stats_->clearAlert(interface::TransportStatistics::statsAlerts::LATENCY);
+
+    if (in_congestion)
+      stats_->setAlert(interface::TransportStatistics::statsAlerts::CONGESTION);
+    else
+      stats_->clearAlert(
+          interface::TransportStatistics::statsAlerts::CONGESTION);
+
+    if (residual_losses > MAX_RESIDUAL_LOSSES)
+      stats_->setAlert(interface::TransportStatistics::statsAlerts::LOSSES);
+    else
+      stats_->clearAlert(interface::TransportStatistics::statsAlerts::LOSSES);
   }
 }
 
-void RTCTransportProtocol::onFecPackets(
-    std::vector<std::pair<uint32_t, fec::buffer>> &packets) {
+void RTCTransportProtocol::onFecPackets(fec::BufferArray &packets) {
+  Packet::Format format;
+  socket_->getSocketOption(interface::GeneralTransportOptions::PACKET_FORMAT,
+                           format);
+
+  Name *name = nullptr;
+  socket_->getSocketOption(GeneralTransportOptions::NETWORK_NAME, &name);
+
   for (auto &packet : packets) {
-    PacketState state = state_->isReceivedOrLost(packet.first);
-    if (state != PacketState::RECEIVED) {
-      state_->onPacketRecoveredFec(packet.first);
-      ldr_->onPacketRecoveredFec(packet.first);
-      DLOG_IF(INFO, VLOG_IS_ON(3))
-          << "Recovered packet " << packet.first << " through FEC.";
-      reassembly_->reassemble(*packet.second, packet.first);
-    } else {
-      DLOG_IF(INFO, VLOG_IS_ON(3))
-          << "Packet" << packet.first << "already received.";
+    uint32_t seq_number = packet.getIndex();
+    uint32_t metadata = packet.getMetadata();
+    fec::buffer buffer = packet.getBuffer();
+
+    PayloadType payload_type = static_cast<PayloadType>(metadata);
+    switch (payload_type) {
+      case PayloadType::DATA:
+      case PayloadType::MANIFEST:
+        break;
+      case PayloadType::UNSPECIFIED:
+      default:
+        payload_type = PayloadType::DATA;
+        break;
     }
+
+    switch (state_->getPacketState(seq_number)) {
+      case PacketState::RECEIVED:
+      case PacketState::TO_BE_RECEIVED: {
+        DLOG_IF(INFO, VLOG_IS_ON(3))
+            << "Packet " << seq_number << " already received";
+        break;
+      }
+      default: {
+        DLOG_IF(INFO, VLOG_IS_ON(3))
+            << "Recovered packet " << seq_number << " through FEC";
+
+        if (payload_type == PayloadType::MANIFEST) {
+          name->setSuffix(seq_number);
+
+          auto interest =
+              core::PacketManager<>::getInstance().getPacket<Interest>(format);
+          interest->setName(*name);
+
+          auto content_object = toContentObject(
+              *name, format, payload_type, buffer->data(), buffer->length());
+
+          processManifest(*interest, *content_object);
+        }
+
+        state_->onPacketRecoveredFec(seq_number, buffer->length());
+        ldr_->onPacketRecoveredFec(seq_number);
+
+        if (payload_type == PayloadType::DATA) {
+          verifier_->onDataRecoveredFec(seq_number);
+          reassembly_->reassemble(*buffer, seq_number);
+        }
+
+        break;
+      }
+    }
+  }
+}
+
+void RTCTransportProtocol::processManifest(Interest &interest,
+                                           ContentObject &manifest) {
+  auth::VerificationPolicy policy = verifier_->processManifest(manifest);
+  indexer_verifier_->applyPolicy(interest, manifest, false, policy);
+}
+
+ContentObject::Ptr RTCTransportProtocol::removeFecHeader(
+    const ContentObject &content_object) {
+  if (!fec_decoder_ || !fec_decoder_->getFecHeaderSize()) {
+    return nullptr;
   }
+
+  size_t fec_header_size = fec_decoder_->getFecHeaderSize();
+  const uint8_t *payload =
+      content_object.data() + content_object.headerSize() + fec_header_size;
+  size_t payload_size = content_object.payloadSize() - fec_header_size;
+
+  ContentObject::Ptr co =
+      toContentObject(content_object.getName(), content_object.getFormat(),
+                      content_object.getPayloadType(), payload, payload_size);
+
+  return co;
+}
+
+ContentObject::Ptr RTCTransportProtocol::toContentObject(
+    const Name &name, Packet::Format format, PayloadType payload_type,
+    const uint8_t *payload, std::size_t payload_size,
+    std::size_t additional_header_size) {
+  // Recreate ContentObject
+  ContentObject::Ptr co =
+      core::PacketManager<>::getInstance().getPacket<ContentObject>(
+          format, additional_header_size);
+  co->updateLength(payload_size);
+  co->append(payload_size);
+  co->trimStart(co->headerSize());
+
+  // Copy payload
+  std::memcpy(co->writableData(), payload, payload_size);
+
+  // Restore network headers and some fields
+  co->prepend(co->headerSize());
+  co->setName(name);
+  co->setPayloadType(payload_type);
+
+  return co;
 }
 
 }  // end namespace rtc
diff --git a/libtransport/src/protocols/rtc/rtc.h b/libtransport/src/protocols/rtc/rtc.h
index e6431264d..37706eb1c 100644
--- a/libtransport/src/protocols/rtc/rtc.h
+++ b/libtransport/src/protocols/rtc/rtc.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -15,10 +15,12 @@
 
 #pragma once
 
-#include <protocols/datagram_reassembly.h>
+#include <protocols/rtc/rtc_forwarding_strategy.h>
 #include <protocols/rtc/rtc_ldr.h>
 #include <protocols/rtc/rtc_rc.h>
+#include <protocols/rtc/rtc_reassembly.h>
 #include <protocols/rtc/rtc_state.h>
+#include <protocols/rtc/rtc_verifier.h>
 #include <protocols/transport_protocol.h>
 
 #include <unordered_set>
@@ -44,6 +46,8 @@ class RTCTransportProtocol : public TransportProtocol {
 
   std::size_t transportHeaderLength() override;
 
+  auto shared_from_this() { return utils::shared_from(this); }
+
  private:
   enum class SyncState { catch_up = 0, in_sync = 1, last };
 
@@ -76,6 +80,7 @@ class RTCTransportProtocol : public TransportProtocol {
   void onPacketDropped(Interest &interest, ContentObject &content_object,
                        const std::error_code &reason) override {}
   void onReassemblyFailed(std::uint32_t missing_segment) override {}
+  void processManifest(Interest &interest, ContentObject &manifest);
 
   // interaction with app functions
   void sendStatsToApp(uint32_t retx_count, uint32_t received_bytes,
@@ -84,11 +89,20 @@ class RTCTransportProtocol : public TransportProtocol {
                       uint32_t received_nacks, uint32_t received_fec);
 
   // FEC functions
-  void onFecPackets(std::vector<std::pair<uint32_t, fec::buffer>> &packets);
+  void onFecPackets(fec::BufferArray &packets);
+
+  // Utils
+  ContentObject::Ptr removeFecHeader(const ContentObject &content_object);
+  ContentObject::Ptr toContentObject(const Name &name, Packet::Format format,
+                                     PayloadType payload_type,
+                                     const uint8_t *payload,
+                                     std::size_t payload_size,
+                                     std::size_t additional_header_size = 0);
 
   // protocol state
   bool start_send_interest_;
   SyncState current_state_;
+
   // cwin vars
   uint32_t current_sync_win_;
   uint32_t max_sync_win_;
@@ -120,6 +134,10 @@ class RTCTransportProtocol : public TransportProtocol {
   std::shared_ptr<RTCState> state_;
   std::shared_ptr<RTCRateControl> rc_;
   std::shared_ptr<RTCLossDetectionAndRecovery> ldr_;
+  std::shared_ptr<RTCVerifier> verifier_;
+
+  // forwarding strategy selection
+  RTCForwardingStrategy fwd_strategy_;
 
   uint32_t number_;
 };
diff --git a/libtransport/src/protocols/rtc/rtc_consts.h b/libtransport/src/protocols/rtc/rtc_consts.h
index d04bc1b1f..03efd8e84 100644
--- a/libtransport/src/protocols/rtc/rtc_consts.h
+++ b/libtransport/src/protocols/rtc/rtc_consts.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -45,22 +45,22 @@ const uint32_t MAX_INTERESTS_IN_BATCH = 5;    // number of seq numbers per
 const uint32_t WAIT_FOR_INTEREST_BATCH = 20;  // msec. timer that we wait to try
                                               // to aggregate interest in the
                                               // same packet
-const uint32_t MAX_PACING_BATCH = 5;
-// number of interest that we can send inside
-// the loop before they get dropped by the
-// kernel.
+const uint32_t MAX_PACING_BATCH = 5;  // number of interest that we can send
+                                      // inside the loop before they get dropped
+                                      // by the kernel.
 const uint32_t PACING_WAIT = 1000;  // usec to wait betwing two pacing batch. As
                                     // for MAX_PACING_BATCH this value was
                                     // computed during tests
 const uint32_t MAX_RTX_IN_BATCH = 10;  // max rtx to send in loop
 
 // packet const
-const uint32_t HICN_HEADER_SIZE = 40 + 20;  //  IPv6 + TCP bytes
 const uint32_t RTC_INTEREST_LIFETIME = 2000;
 
 // probes sequence range
 const uint32_t MIN_PROBE_SEQ = 0xefffffff;
-const uint32_t MIN_RTT_PROBE_SEQ = MIN_PROBE_SEQ;
+const uint32_t MIN_INIT_PROBE_SEQ = MIN_PROBE_SEQ;
+const uint32_t MAX_INIT_PROBE_SEQ = 0xf7ffffff - 1;
+const uint32_t MIN_RTT_PROBE_SEQ = MAX_INIT_PROBE_SEQ + 1;
 const uint32_t MAX_RTT_PROBE_SEQ = 0xffffffff - 1;
 // RTT_PROBE_INTERVAL will be used during the section while
 // INIT_RTT_PROBE_INTERVAL is used at the beginning to
@@ -78,15 +78,16 @@ const uint32_t INIT_RTT_MIN_PROBES_TO_RECV = 5;  // ms
 const uint32_t MAX_PENDING_PROBES = 10;
 
 // congestion
-const double MAX_QUEUING_DELAY = 100.0;  // ms
+const double MAX_QUEUING_DELAY = 50.0;  // ms
 
 // data from cache
 const double MAX_DATA_FROM_CACHE = 0.25;  // 25%
 
 // window const
-const uint32_t INITIAL_WIN = 5;            // pkts
-const uint32_t INITIAL_WIN_MAX = 1000000;  // pkts
-const uint32_t WIN_MIN = 5;                // pkts
+const uint32_t INITIAL_WIN = 5;                    // pkts
+const uint32_t INITIAL_WIN_MAX = 1000000;          // pkts
+const uint32_t WIN_MIN = 5;                        // pkts
+const uint32_t WIN_MIN_WITH_AGGREGARED_DATA = 10;  // pkts
 const double CATCH_UP_WIN_INCREMENT = 1.2;
 // used in rate control
 const double WIN_DECREASE_FACTOR = 0.5;
@@ -105,10 +106,8 @@ const double MOVING_AVG_ALPHA = 0.8;
 
 const double MILLI_IN_A_SEC = 1000.0;
 const double MICRO_IN_A_SEC = 1000000.0;
-
-const double MAX_CACHED_PACKETS = 262144;  // 2^18
-                                           // about 50 sec of traffic at 50Mbps
-                                           // with 1200 bytes packets
+const uint32_t ROUNDS_PER_SEC = (uint32_t)(MILLI_IN_A_SEC / ROUND_LEN);
+const uint32_t ROUNDS_PER_MIN = (uint32_t)ROUNDS_PER_SEC * 60;
 
 const uint32_t MAX_ROUND_WHIOUT_PACKETS =
     (20 * MILLI_IN_A_SEC) / ROUND_LEN;  // 20 sec in rounds;
@@ -120,12 +119,24 @@ const uint64_t MAX_TIMER_RTX = ~0;
 const uint32_t SENTINEL_TIMER_INTERVAL = 100;  // ms
 const uint32_t MAX_RTX_WITH_SENTINEL = 10;     // packets
 const double CATCH_UP_RTT_INCREMENT = 1.2;
+const double MAX_RESIDUAL_LOSS_RATE = 2.0;  // %
+const uint32_t WAIT_BEFORE_FEC_UPDATE = ROUNDS_PER_SEC * 5;
 
 // used by producer
 const uint32_t PRODUCER_STATS_INTERVAL = 200;  // ms
-const uint32_t MIN_PRODUCTION_RATE = 10;       // pps
-                                               // min prod rate
-                                               // set running several test
+const uint32_t MIN_PRODUCTION_RATE = 25;       // pps, equal to min window *
+                                               // rounds in a second
+const uint32_t NACK_DELAY = 1500;              // ms
+const uint32_t FEC_PACING_TIME = 5;            // ms
+
+// aggregated data consts
+const uint16_t MAX_RTC_PAYLOAD_SIZE = 1200;   // bytes
+const uint16_t MAX_AGGREGATED_PACKETS = 5;    // pkt
+const uint32_t AGGREGATED_PACKETS_TIMER = 2;  // ms
+
+// alert thresholds
+const uint32_t MAX_RTT = 200;             // ms
+const double MAX_RESIDUAL_LOSSES = 0.05;  // %
 
 }  // namespace rtc
 
diff --git a/libtransport/src/protocols/rtc/rtc_data_path.cc b/libtransport/src/protocols/rtc/rtc_data_path.cc
index c098088a3..b3abf5ea8 100644
--- a/libtransport/src/protocols/rtc/rtc_data_path.cc
+++ b/libtransport/src/protocols/rtc/rtc_data_path.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -13,14 +13,17 @@
  * limitations under the License.
  */
 
+#include <hicn/transport/utils/chrono_typedefs.h>
 #include <protocols/rtc/rtc_data_path.h>
 #include <stdlib.h>
 
 #include <algorithm>
 #include <cfloat>
 #include <chrono>
+#include <cmath>
 
 #define MAX_ROUNDS_WITHOUT_PKTS 10  // 2sec
+#define AVG_RTT_TIME 1000           // (ms) 1sec
 
 namespace transport {
 
@@ -32,6 +35,8 @@ RTCDataPath::RTCDataPath(uint32_t path_id)
     : path_id_(path_id),
       min_rtt(UINT_MAX),
       prev_min_rtt(UINT_MAX),
+      max_rtt(0),
+      prev_max_rtt(0),
       min_owd(INT_MAX),  // this is computed like in LEDBAT, so it is not the
                          // real OWD, but the measured one, that depends on the
                          // clock of sender and receiver. the only meaningful
@@ -46,20 +51,46 @@ RTCDataPath::RTCDataPath(uint32_t path_id)
       largest_recv_seq_(0),
       largest_recv_seq_time_(0),
       avg_inter_arrival_(DBL_MAX),
+      rtt_sum_(0),
+      last_avg_rtt_compute_(0),
+      rtt_samples_(0),
+      avg_rtt_(0.0),
       received_nacks_(false),
-      received_packets_(false),
+      received_packets_(0),
       rounds_without_packets_(0),
       last_received_data_packet_(0),
-      RTT_history_(HISTORY_LEN),
+      min_RTT_history_(HISTORY_LEN),
+      max_RTT_history_(HISTORY_LEN),
       OWD_history_(HISTORY_LEN){};
 
-void RTCDataPath::insertRttSample(uint64_t rtt) {
-  // for the rtt we only keep track of the min one
+void RTCDataPath::insertRttSample(
+    const utils::SteadyTime::Milliseconds& rtt_milliseconds, bool is_probe) {
+  // compute min rtt
+  uint64_t rtt = rtt_milliseconds.count();
   if (rtt < min_rtt) min_rtt = rtt;
-  last_received_data_packet_ =
-      std::chrono::duration_cast<std::chrono::milliseconds>(
-          std::chrono::steady_clock::now().time_since_epoch())
-          .count();
+
+  uint64_t now = utils::SteadyTime::nowMs().count();
+  last_received_data_packet_ = now;
+
+  // compute avg rtt
+  if (is_probe) {
+    // max rtt is computed only on probes to avoid to take into account the
+    // production time at the server
+    if (rtt > max_rtt) max_rtt = rtt;
+
+    rtt_sum_ += rtt;
+    rtt_samples_++;
+  }
+
+  if ((now - last_avg_rtt_compute_) >= AVG_RTT_TIME) {
+    // compute a new avg rtt
+    // if rtt_samples_ = 0 keep the same rtt
+    if (rtt_samples_ != 0) avg_rtt_ = (double)rtt_sum_ / (double)rtt_samples_;
+
+    rtt_sum_ = 0;
+    rtt_samples_ = 0;
+    last_avg_rtt_compute_ = now;
+  }
 }
 
 void RTCDataPath::insertOwdSample(int64_t owd) {
@@ -87,15 +118,13 @@ void RTCDataPath::insertOwdSample(int64_t owd) {
 
   // owd is computed only for valid data packets so we count only
   // this for decide if we recevie traffic or not
-  received_packets_ = true;
+  received_packets_++;
 }
 
 void RTCDataPath::computeInterArrivalGap(uint32_t segment_number) {
   // got packet in sequence, compute gap
   if (largest_recv_seq_ == (segment_number - 1)) {
-    uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                       std::chrono::steady_clock::now().time_since_epoch())
-                       .count();
+    uint64_t now = utils::SteadyTime::nowMs().count();
     uint64_t delta = now - largest_recv_seq_time_;
     largest_recv_seq_ = segment_number;
     largest_recv_seq_time_ = now;
@@ -110,10 +139,7 @@ void RTCDataPath::computeInterArrivalGap(uint32_t segment_number) {
   // ooo packet, update the stasts if needed
   if (largest_recv_seq_ <= segment_number) {
     largest_recv_seq_ = segment_number;
-    largest_recv_seq_time_ =
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now().time_since_epoch())
-            .count();
+    largest_recv_seq_time_ = utils::SteadyTime::nowMs().count();
   }
 }
 
@@ -146,10 +172,20 @@ void RTCDataPath::roundEnd() {
     min_rtt = prev_min_rtt;
   }
 
+  // same for max_rtt
+  if (max_rtt != 0) {
+    prev_max_rtt = max_rtt;
+  } else {
+    max_rtt = prev_max_rtt;
+  }
+
   if (min_rtt == 0) min_rtt = 1;
+  if (max_rtt == 0) max_rtt = 1;
 
-  RTT_history_.pushBack(min_rtt);
+  min_RTT_history_.pushBack(min_rtt);
+  max_RTT_history_.pushBack(max_rtt);
   min_rtt = UINT_MAX;
+  max_rtt = 0;
 
   // do the same for min owd
   if (min_owd != INT_MAX) {
@@ -163,32 +199,47 @@ void RTCDataPath::roundEnd() {
     min_owd = INT_MAX;
   }
 
-  if (!received_packets_)
+  if (received_packets_ == 0)
     rounds_without_packets_++;
   else
     rounds_without_packets_ = 0;
-  received_packets_ = false;
+  received_packets_ = 0;
 }
 
 uint32_t RTCDataPath::getPathId() { return path_id_; }
 
-double RTCDataPath::getQueuingDealy() { return queuing_delay; }
+double RTCDataPath::getQueuingDealy() {
+  if (queuing_delay == DBL_MAX) return 0;
+  return queuing_delay;
+}
 
 uint64_t RTCDataPath::getMinRtt() {
-  if (RTT_history_.size() != 0) return RTT_history_.begin();
+  if (min_RTT_history_.size() != 0) return min_RTT_history_.begin();
+  return 0;
+}
+
+uint64_t RTCDataPath::getAvgRtt() { return std::round(avg_rtt_); }
+
+uint64_t RTCDataPath::getMaxRtt() {
+  if (max_RTT_history_.size() != 0) return max_RTT_history_.begin();
   return 0;
 }
 
 int64_t RTCDataPath::getMinOwd() {
   if (OWD_history_.size() != 0) return OWD_history_.begin();
-  return 0;
+  return INT_MAX;
 }
 
 double RTCDataPath::getJitter() { return jitter_; }
 
 uint64_t RTCDataPath::getLastPacketTS() { return last_received_data_packet_; }
 
-void RTCDataPath::clearRtt() { RTT_history_.clear(); }
+uint32_t RTCDataPath::getPacketsLastRound() { return received_packets_; }
+
+void RTCDataPath::clearRtt() {
+  min_RTT_history_.clear();
+  max_RTT_history_.clear();
+}
 
 }  // end namespace rtc
 
diff --git a/libtransport/src/protocols/rtc/rtc_data_path.h b/libtransport/src/protocols/rtc/rtc_data_path.h
index c5c37fc0d..5afbbb87f 100644
--- a/libtransport/src/protocols/rtc/rtc_data_path.h
+++ b/libtransport/src/protocols/rtc/rtc_data_path.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -15,7 +15,9 @@
 
 #pragma once
 
+#include <hicn/transport/utils/chrono_typedefs.h>
 #include <stdint.h>
+#include <utils/max_filter.h>
 #include <utils/min_filter.h>
 
 #include <climits>
@@ -34,19 +36,23 @@ class RTCDataPath {
   RTCDataPath(uint32_t path_id);
 
  public:
-  void insertRttSample(uint64_t rtt);
+  void insertRttSample(const utils::SteadyTime::Milliseconds &rtt,
+                       bool is_probe);
   void insertOwdSample(int64_t owd);
   void computeInterArrivalGap(uint32_t segment_number);
   void receivedNack();
 
   uint32_t getPathId();
   uint64_t getMinRtt();
+  uint64_t getAvgRtt();
+  uint64_t getMaxRtt();
   double getQueuingDealy();
   double getInterArrivalGap();
   double getJitter();
   bool isActive();
   bool pathToProducer();
   uint64_t getLastPacketTS();
+  uint32_t getPacketsLastRound();
 
   void clearRtt();
 
@@ -60,6 +66,9 @@ class RTCDataPath {
   uint64_t min_rtt;
   uint64_t prev_min_rtt;
 
+  uint64_t max_rtt;
+  uint64_t prev_max_rtt;
+
   int64_t min_owd;
   int64_t prev_min_owd;
 
@@ -74,19 +83,26 @@ class RTCDataPath {
   uint64_t largest_recv_seq_time_;
   double avg_inter_arrival_;
 
+  // compute the avg rtt over one sec
+  uint64_t rtt_sum_;
+  uint64_t last_avg_rtt_compute_;
+  uint32_t rtt_samples_;
+  double avg_rtt_;
+
   // flags to check if a path is active
   // we considere a path active if it reaches a producer
   //(not a cache) --aka we got at least one nack on this path--
   // and if we receives packets
   bool received_nacks_;
-  bool received_packets_;
-  uint8_t rounds_without_packets_;      // if we don't get any packet
+  uint32_t received_packets_;
+  uint32_t rounds_without_packets_;     // if we don't get any packet
                                         // for MAX_ROUNDS_WITHOUT_PKTS
                                         // we consider the path inactive
   uint64_t last_received_data_packet_;  // timestamp for the last data received
                                         // on this path
 
-  utils::MinFilter<uint64_t> RTT_history_;
+  utils::MinFilter<uint64_t> min_RTT_history_;
+  utils::MaxFilter<uint64_t> max_RTT_history_;
   utils::MinFilter<int64_t> OWD_history_;
 };
 
diff --git a/libtransport/src/protocols/rtc/rtc_forwarding_strategy.cc b/libtransport/src/protocols/rtc/rtc_forwarding_strategy.cc
new file mode 100644
index 000000000..9503eed3e
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_forwarding_strategy.cc
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <hicn/transport/interfaces/notification.h>
+#include <protocols/rtc/rtc_forwarding_strategy.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+using namespace transport::interface;
+
+RTCForwardingStrategy::RTCForwardingStrategy()
+    : init_(false),
+      forwarder_set_(false),
+      selected_strategy_(NONE),
+      current_strategy_(NONE),
+      rounds_since_last_set_(0),
+      portal_(nullptr),
+      state_(nullptr) {}
+
+RTCForwardingStrategy::~RTCForwardingStrategy() {}
+
+void RTCForwardingStrategy::setCallback(interface::StrategyCallback* callback) {
+  callback_ = callback;
+}
+
+void RTCForwardingStrategy::initFwdStrategy(
+    std::shared_ptr<core::Portal> portal, core::Prefix& prefix, RTCState* state,
+    strategy_t strategy) {
+  init_ = true;
+  selected_strategy_ = strategy;
+  if (strategy == BOTH)
+    current_strategy_ = BEST_PATH;
+  else
+    current_strategy_ = strategy;
+  rounds_since_last_set_ = 0;
+  prefix_ = prefix;
+  portal_ = portal;
+  state_ = state;
+}
+
+void RTCForwardingStrategy::checkStrategy() {
+  if (*callback_) {
+    strategy_t used_strategy = selected_strategy_;
+    if (used_strategy == BOTH) used_strategy = current_strategy_;
+    assert(used_strategy == BEST_PATH || used_strategy == REPLICATION ||
+           used_strategy == NONE);
+
+    notification::ForwardingStrategy strategy =
+        notification::ForwardingStrategy::NONE;
+    switch (used_strategy) {
+      case BEST_PATH:
+        strategy = notification::ForwardingStrategy::BEST_PATH;
+        break;
+      case REPLICATION:
+        strategy = notification::ForwardingStrategy::REPLICATION;
+        break;
+      default:
+        break;
+    }
+
+    (*callback_)(strategy);
+  }
+
+  if (!init_) return;
+
+  if (selected_strategy_ == NONE) return;
+
+  if (selected_strategy_ == BEST_PATH) {
+    checkStrategyBestPath();
+    return;
+  }
+
+  if (selected_strategy_ == REPLICATION) {
+    checkStrategyReplication();
+    return;
+  }
+
+  checkStrategyBoth();
+}
+
+void RTCForwardingStrategy::checkStrategyBestPath() {
+  if (!forwarder_set_) {
+    setStrategy(BEST_PATH);
+    forwarder_set_ = true;
+    return;
+  }
+
+  uint8_t qs = state_->getQualityScore();
+
+  if (qs >= 4 || rounds_since_last_set_ < 25) {  // wait a least 5 sec
+                                                 // between each switch
+    rounds_since_last_set_++;
+    return;
+  }
+
+  // try to switch path
+  setStrategy(BEST_PATH);
+}
+
+void RTCForwardingStrategy::checkStrategyReplication() {
+  if (!forwarder_set_) {
+    setStrategy(REPLICATION);
+    forwarder_set_ = true;
+    return;
+  }
+
+  // here we have nothing to do for the moment
+  return;
+}
+
+void RTCForwardingStrategy::checkStrategyBoth() {
+  if (!forwarder_set_) {
+    setStrategy(current_strategy_);
+    forwarder_set_ = true;
+    return;
+  }
+
+  checkStrategyBestPath();
+
+  // TODO
+  // for the moment we use only best path.
+  // but later:
+  // 1. if both paths are bad use replication
+  // 2. while using replication compute the effectiveness. if the majority of
+  //    the packets are coming from a single path, try to use bestpath
+}
+
+void RTCForwardingStrategy::setStrategy(strategy_t strategy) {
+  rounds_since_last_set_ = 0;
+  current_strategy_ = strategy;
+  portal_->setForwardingStrategy(prefix_,
+                                 string_strategies_[current_strategy_]);
+}
+
+}  // namespace rtc
+
+}  // namespace protocol
+
+}  // namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_forwarding_strategy.h b/libtransport/src/protocols/rtc/rtc_forwarding_strategy.h
new file mode 100644
index 000000000..821b28051
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_forwarding_strategy.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <core/portal.h>
+#include <hicn/transport/interfaces/callbacks.h>
+#include <protocols/rtc/rtc_state.h>
+
+#include <array>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+class RTCForwardingStrategy {
+ public:
+  enum strategy_t {
+    BEST_PATH,
+    REPLICATION,
+    BOTH,
+    NONE,
+  };
+
+  RTCForwardingStrategy();
+  ~RTCForwardingStrategy();
+
+  void initFwdStrategy(std::shared_ptr<core::Portal> portal,
+                       core::Prefix& prefix, RTCState* state,
+                       strategy_t strategy);
+
+  void checkStrategy();
+  void setCallback(interface::StrategyCallback* callback);
+
+ private:
+  void checkStrategyBestPath();
+  void checkStrategyReplication();
+  void checkStrategyBoth();
+
+  void setStrategy(strategy_t strategy);
+
+  std::array<std::string, 4> string_strategies_ = {"bestpath", "replication",
+                                                   "both", "none"};
+
+  bool init_;                     // true if all val are initializes
+  bool forwarder_set_;            // true if the strategy is been set at least
+                                  // once
+  strategy_t selected_strategy_;  // this is the strategy selected using socket
+                                  // options. this can also be equal to BOTH
+  strategy_t current_strategy_;   // if both strategies can be used this
+                                  // indicates the one that is currently in use
+                                  // that can be only replication or best path
+  uint32_t rounds_since_last_set_;
+  core::Prefix prefix_;
+  std::shared_ptr<core::Portal> portal_;
+  RTCState* state_;
+  interface::StrategyCallback* callback_;
+};
+
+}  // namespace rtc
+
+}  // namespace protocol
+
+}  // namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_indexer.h b/libtransport/src/protocols/rtc/rtc_indexer.h
index 4aee242bb..cda156b22 100644
--- a/libtransport/src/protocols/rtc/rtc_indexer.h
+++ b/libtransport/src/protocols/rtc/rtc_indexer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -18,8 +18,10 @@
 #include <protocols/errors.h>
 #include <protocols/fec_utils.h>
 #include <protocols/indexer.h>
+#include <protocols/rtc/probe_handler.h>
 #include <protocols/rtc/rtc_consts.h>
 #include <protocols/transport_protocol.h>
+#include <utils/suffix_strategy.h>
 
 #include <deque>
 
@@ -54,7 +56,7 @@ class RtcIndexer : public Indexer {
     n_fec_ = 0;
   }
 
-  uint32_t checkNextSuffix() override { return next_suffix_; }
+  uint32_t checkNextSuffix() const override { return next_suffix_; }
 
   uint32_t getNextSuffix() override {
     if (isFec(next_suffix_)) {
@@ -77,7 +79,7 @@ class RtcIndexer : public Indexer {
     first_suffix_ = suffix % LIMIT;
   }
 
-  uint32_t getFirstSuffix() override { return first_suffix_; }
+  uint32_t getFirstSuffix() const override { return first_suffix_; }
 
   uint32_t jumpToIndex(uint32_t index) override {
     next_suffix_ = index % LIMIT;
@@ -87,30 +89,8 @@ class RtcIndexer : public Indexer {
   void onContentObject(core::Interest &interest,
                        core::ContentObject &content_object,
                        bool reassembly) override {
-    setVerifier();
-    auto ret = verifier_->verifyPackets(&content_object);
-
-    switch (ret) {
-      case auth::VerificationPolicy::ACCEPT: {
-        if (reassembly) {
-          reassembly_->reassemble(content_object);
-        }
-        break;
-      }
-
-      case auth::VerificationPolicy::UNKNOWN:
-      case auth::VerificationPolicy::DROP: {
-        transport_->onPacketDropped(
-            interest, content_object,
-            make_error_code(protocol_error::verification_failed));
-        break;
-      }
-
-      case auth::VerificationPolicy::ABORT: {
-        transport_->onContentReassembled(
-            make_error_code(protocol_error::session_aborted));
-        break;
-      }
+    if (reassembly) {
+      reassembly_->reassemble(content_object);
     }
   }
 
@@ -120,13 +100,12 @@ class RtcIndexer : public Indexer {
   uint32_t getNextReassemblySegment() override {
     throw errors::RuntimeException(
         "Get reassembly segment called on rtc indexer. RTC indexer does not "
-        "provide "
-        "reassembly.");
+        "provide reassembly.");
   }
 
   bool isFinalSuffixDiscovered() override { return true; }
 
-  uint32_t getFinalSuffix() override { return LIMIT; }
+  uint32_t getFinalSuffix() const override { return LIMIT; }
 
   void enableFec(fec::FECType fec_type) override { fec_type_ = fec_type; }
 
@@ -137,13 +116,13 @@ class RtcIndexer : public Indexer {
     n_current_fec_ = n_fec_;
   }
 
-  uint32_t getNFec() override { return n_fec_; }
+  uint32_t getNFec() const override { return n_fec_; }
 
   bool isFec(uint32_t index) override {
     return isFec(fec_type_, index, first_suffix_);
   }
 
-  double getFecOverhead() override {
+  double getFecOverhead() const override {
     if (fec_type_ == fec::FECType::UNKNOWN) {
       return 0;
     }
@@ -152,7 +131,7 @@ class RtcIndexer : public Indexer {
     return (double)n_fec_ / k;
   }
 
-  double getMaxFecOverhead() override {
+  double getMaxFecOverhead() const override {
     if (fec_type_ == fec::FECType::UNKNOWN) {
       return 0;
     }
diff --git a/libtransport/src/protocols/rtc/rtc_ldr.cc b/libtransport/src/protocols/rtc/rtc_ldr.cc
index f0de48871..1ca1cf48d 100644
--- a/libtransport/src/protocols/rtc/rtc_ldr.cc
+++ b/libtransport/src/protocols/rtc/rtc_ldr.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,6 +16,12 @@
 #include <glog/logging.h>
 #include <protocols/rtc/rtc_consts.h>
 #include <protocols/rtc/rtc_ldr.h>
+#include <protocols/rtc/rtc_rs_delay.h>
+#include <protocols/rtc/rtc_rs_fec_only.h>
+#include <protocols/rtc/rtc_rs_low_rate.h>
+#include <protocols/rtc/rtc_rs_recovery_off.h>
+#include <protocols/rtc/rtc_rs_rtx_only.h>
+#include <protocols/rtc/rtc_state.h>
 
 #include <algorithm>
 #include <unordered_set>
@@ -27,146 +33,115 @@ namespace protocol {
 namespace rtc {
 
 RTCLossDetectionAndRecovery::RTCLossDetectionAndRecovery(
-    Indexer *indexer, SendRtxCallback &&callback, asio::io_service &io_service)
-    : rtx_on_(false),
-      fec_on_(false),
-      next_rtx_timer_(MAX_TIMER_RTX),
-      last_event_(0),
-      sentinel_timer_interval_(MAX_TIMER_RTX),
-      indexer_(indexer),
-      send_rtx_callback_(std::move(callback)) {
-  timer_ = std::make_unique<asio::steady_timer>(io_service);
-  sentinel_timer_ = std::make_unique<asio::steady_timer>(io_service);
+    Indexer *indexer, asio::io_service &io_service,
+    interface::RtcTransportRecoveryStrategies type,
+    RecoveryStrategy::SendRtxCallback &&callback,
+    interface::StrategyCallback *external_callback) {
+  rs_type_ = type;
+  if (type == interface::RtcTransportRecoveryStrategies::RECOVERY_OFF) {
+    rs_ = std::make_shared<RecoveryStrategyRecoveryOff>(
+        indexer, std::move(callback), io_service, external_callback);
+  } else if (type == interface::RtcTransportRecoveryStrategies::DELAY_BASED) {
+    rs_ = std::make_shared<RecoveryStrategyDelayBased>(
+        indexer, std::move(callback), io_service, external_callback);
+  } else if (type == interface::RtcTransportRecoveryStrategies::FEC_ONLY) {
+    rs_ = std::make_shared<RecoveryStrategyFecOnly>(
+        indexer, std::move(callback), io_service, external_callback);
+  } else if (type == interface::RtcTransportRecoveryStrategies::LOW_RATE ||
+             type == interface::RtcTransportRecoveryStrategies::
+                         LOW_RATE_AND_BESTPATH ||
+             type == interface::RtcTransportRecoveryStrategies::
+                         LOW_RATE_AND_REPLICATION ||
+             type == interface::RtcTransportRecoveryStrategies::
+                         LOW_RATE_AND_ALL_FWD_STRATEGIES) {
+    rs_ = std::make_shared<RecoveryStrategyLowRate>(
+        indexer, std::move(callback), io_service, external_callback);
+  } else {
+    // default
+    rs_type_ = interface::RtcTransportRecoveryStrategies::RTX_ONLY;
+    rs_ = std::make_shared<RecoveryStrategyRtxOnly>(
+        indexer, std::move(callback), io_service, external_callback);
+  }
 }
 
 RTCLossDetectionAndRecovery::~RTCLossDetectionAndRecovery() {}
 
-void RTCLossDetectionAndRecovery::turnOnRTX() {
-  rtx_on_ = true;
-  scheduleSentinelTimer(state_->getRTT() * CATCH_UP_RTT_INCREMENT);
-}
-
-void RTCLossDetectionAndRecovery::turnOffRTX() {
-  rtx_on_ = false;
-  clear();
-}
-
-uint32_t RTCLossDetectionAndRecovery::computeFecPacketsToAsk(bool in_sync) {
-  uint32_t current_fec = indexer_->getNFec();
-  double current_loss_rate = state_->getLossRate();
-  double last_loss_rate = state_->getLastRoundLossRate();
-
-  // when in sync ask for fec only if there are losses for 2 rounds
-  if (in_sync && current_fec == 0 &&
-      (current_loss_rate == 0 || last_loss_rate == 0))
-    return 0;
-
-  double loss_rate = state_->getMaxLossRate() * 1.5;
-
-  if (!in_sync && loss_rate == 0) loss_rate = 0.05;
-  if (loss_rate > 0.5) loss_rate = 0.5;
-
-  double exp_losses = (double)k_ * loss_rate;
-  uint32_t fec_to_ask = ceil(exp_losses / (1 - loss_rate));
-
-  if (fec_to_ask > (n_ - k_)) fec_to_ask = n_ - k_;
-
-  return fec_to_ask;
+void RTCLossDetectionAndRecovery::changeRecoveryStrategy(
+    interface::RtcTransportRecoveryStrategies type) {
+  if (type == rs_type_) return;
+
+  rs_type_ = type;
+  if (type == interface::RtcTransportRecoveryStrategies::RECOVERY_OFF) {
+    rs_ =
+        std::make_shared<RecoveryStrategyRecoveryOff>(std::move(*(rs_.get())));
+  } else if (type == interface::RtcTransportRecoveryStrategies::DELAY_BASED) {
+    rs_ = std::make_shared<RecoveryStrategyDelayBased>(std::move(*(rs_.get())));
+  } else if (type == interface::RtcTransportRecoveryStrategies::FEC_ONLY) {
+    rs_ = std::make_shared<RecoveryStrategyFecOnly>(std::move(*(rs_.get())));
+  } else if (type == interface::RtcTransportRecoveryStrategies::LOW_RATE ||
+             type == interface::RtcTransportRecoveryStrategies::
+                         LOW_RATE_AND_BESTPATH ||
+             type == interface::RtcTransportRecoveryStrategies::
+                         LOW_RATE_AND_REPLICATION ||
+             type == interface::RtcTransportRecoveryStrategies::
+                         LOW_RATE_AND_ALL_FWD_STRATEGIES) {
+    rs_ = std::make_shared<RecoveryStrategyLowRate>(std::move(*(rs_.get())));
+  } else {
+    // default
+    rs_ = std::make_shared<RecoveryStrategyRtxOnly>(std::move(*(rs_.get())));
+  }
 }
 
 void RTCLossDetectionAndRecovery::onNewRound(bool in_sync) {
-  uint64_t rtt = state_->getRTT();
-  if (!fec_on_ && rtt >= 100) {
-    // turn on fec, here we may have no info so ask for all packets
-    fec_on_ = true;
-    turnOffRTX();
-    indexer_->setNFec(computeFecPacketsToAsk(in_sync));
-    return;
-  }
-
-  if (fec_on_ && rtt > 80) {
-    // keep using fec, maybe update it
-    indexer_->setNFec(computeFecPacketsToAsk(in_sync));
-    return;
-  }
-
-  if ((fec_on_ && rtt <= 80) || (!rtx_on_ && rtt <= 100)) {
-    // turn on rtx
-    fec_on_ = false;
-    indexer_->setNFec(0);
-    turnOnRTX();
-    return;
-  }
+  rs_->incRoundId();
+  rs_->onNewRound(in_sync);
 }
 
-void RTCLossDetectionAndRecovery::onTimeout(uint32_t seq) {
-  // always add timeouts to the RTX list to avoid to send the same packet as if
-  // it was not a rtx
-  addToRetransmissions(seq, seq + 1);
-  last_event_ = getNow();
+void RTCLossDetectionAndRecovery::onTimeout(uint32_t seq, bool lost) {
+  if (!lost) {
+    detectLoss(seq, seq + 1);
+  } else {
+    rs_->onLostTimeout(seq);
+  }
 }
 
 void RTCLossDetectionAndRecovery::onPacketRecoveredFec(uint32_t seq) {
-  // if an RTX is scheduled for a packet recovered using FEC delete it
-  deleteRtx(seq);
-  recover_with_fec_.erase(seq);
+  rs_->receivedPacket(seq);
 }
 
 void RTCLossDetectionAndRecovery::onDataPacketReceived(
     const core::ContentObject &content_object) {
-  last_event_ = getNow();
-
   uint32_t seq = content_object.getName().getSuffix();
-  if (deleteRtx(seq)) {
-    state_->onPacketRecoveredRtx(seq);
-  } else {
-    DLOG_IF(INFO, VLOG_IS_ON(3))
-        << "received data. add from "
-        << state_->getHighestSeqReceivedInOrder() + 1 << " to " << seq;
-    addToRetransmissions(state_->getHighestSeqReceivedInOrder() + 1, seq);
-  }
+  bool is_rtx = rs_->isRtx(seq);
+  rs_->receivedPacket(seq);
+  DLOG_IF(INFO, VLOG_IS_ON(3))
+      << "received data. add from "
+      << rs_->getState()->getHighestSeqReceivedInOrder() + 1 << " to " << seq;
+  if (!is_rtx)
+    detectLoss(rs_->getState()->getHighestSeqReceivedInOrder() + 1, seq);
 }
 
 void RTCLossDetectionAndRecovery::onNackPacketReceived(
     const core::ContentObject &nack) {
-  last_event_ = getNow();
-
-  uint32_t seq = nack.getName().getSuffix();
-
   struct nack_packet_t *nack_pkt =
       (struct nack_packet_t *)nack.getPayload()->data();
-  uint32_t production_seq = nack_pkt->getProductionSegement();
+  uint32_t production_seq = nack_pkt->getProductionSegment();
+  uint32_t seq = nack.getName().getSuffix();
 
-  if (production_seq > seq) {
-    // this is a past nack, all data before productionSeq are lost. if
-    // productionSeq > state_->getHighestSeqReceivedInOrder() is impossible to
-    // recover any packet. If this is not the case we can try to recover the
-    // packets between state_->getHighestSeqReceivedInOrder() and productionSeq.
-    // e.g.: the client receives packets 8 10 11 9 where 9 is a nack with
-    // productionSeq = 14. 9 is lost but we can try to recover packets 12 13 and
-    // 14 that are not arrived yet
-    deleteRtx(seq);
-    DLOG_IF(INFO, VLOG_IS_ON(3)) << "received past nack. add from "
-                                 << state_->getHighestSeqReceivedInOrder() + 1
-                                 << " to " << production_seq;
-    addToRetransmissions(state_->getHighestSeqReceivedInOrder() + 1,
-                         production_seq);
-  } else {
-    // future nack. here there should be a gap between the last data received
-    // and this packet and is it possible to recover the packets between the
-    // last received data and the production seq. we should not use the seq
-    // number of the nack since we know that is too early to ask for this seq
-    // number
-    // e.g.: // e.g.: the client receives packets 10 11 12 20 where 20 is a nack
-    // with productionSeq = 18. this says that all the packets between 12 and 18
-    // may got lost and we should ask them
-    deleteRtx(seq);
-    DLOG_IF(INFO, VLOG_IS_ON(3)) << "received futrue nack. add from "
-                                 << state_->getHighestSeqReceivedInOrder() + 1
-                                 << " to " << production_seq;
-    addToRetransmissions(state_->getHighestSeqReceivedInOrder() + 1,
-                         production_seq);
-  }
+  // received a nack. we can try to recover all data packets between the last
+  // received data and the production seq in the nack. this is similar to the
+  // recption of a probe
+  // e.g.: the client receives packets 10 11 12 20 where 20 is a nack
+  // with productionSeq = 18. this says that all the packets between 12 and 18
+  // may got lost and we should ask them
+
+  rs_->receivedPacket(seq);
+  DLOG_IF(INFO, VLOG_IS_ON(3))
+      << "received nack. add from "
+      << rs_->getState()->getHighestSeqReceivedInOrder() + 1 << " to "
+      << production_seq;
+  detectLoss(rs_->getState()->getHighestSeqReceivedInOrder() + 1,
+             production_seq);
 }
 
 void RTCLossDetectionAndRecovery::onProbePacketReceived(
@@ -174,336 +149,38 @@ void RTCLossDetectionAndRecovery::onProbePacketReceived(
   // we don't log the reception of a probe packet for the sentinel timer because
   // probes are not taken into account into the sync window. we use them as
   // future nacks to detect possible packets lost
-  struct nack_packet_t *probe_pkt =
-      (struct nack_packet_t *)probe.getPayload()->data();
-  uint32_t production_seq = probe_pkt->getProductionSegement();
+
+  uint32_t production_seq = RTCState::getProbeParams(probe).prod_seg;
+
   DLOG_IF(INFO, VLOG_IS_ON(3))
       << "received probe. add from "
-      << state_->getHighestSeqReceivedInOrder() + 1 << " to " << production_seq;
+      << rs_->getState()->getHighestSeqReceivedInOrder() + 1 << " to "
+      << production_seq;
 
-  addToRetransmissions(state_->getHighestSeqReceivedInOrder() + 1,
-                       production_seq);
+  detectLoss(rs_->getState()->getHighestSeqReceivedInOrder() + 1,
+             production_seq);
 }
 
-void RTCLossDetectionAndRecovery::clear() {
-  rtx_state_.clear();
-  rtx_timers_.clear();
-  sentinel_timer_->cancel();
-  if (next_rtx_timer_ != MAX_TIMER_RTX) {
-    next_rtx_timer_ = MAX_TIMER_RTX;
-    timer_->cancel();
-  }
-}
+void RTCLossDetectionAndRecovery::detectLoss(uint32_t start, uint32_t stop) {
+  if (start >= stop) return;
 
-void RTCLossDetectionAndRecovery::addToRetransmissions(uint32_t start,
-                                                       uint32_t stop) {
   // skip nacked packets
-  if (start <= state_->getLastSeqNacked()) {
-    start = state_->getLastSeqNacked() + 1;
+  if (start <= rs_->getState()->getLastSeqNacked()) {
+    start = rs_->getState()->getLastSeqNacked() + 1;
   }
 
   // skip received or lost packets
-  if (start <= state_->getHighestSeqReceivedInOrder()) {
-    start = state_->getHighestSeqReceivedInOrder() + 1;
+  if (start <= rs_->getState()->getHighestSeqReceivedInOrder()) {
+    start = rs_->getState()->getHighestSeqReceivedInOrder() + 1;
   }
 
   for (uint32_t seq = start; seq < stop; seq++) {
-    if (state_->isReceivedOrLost(seq) == PacketState::UNKNOWN) {
-      if (rtx_on_) {
-        if (!indexer_->isFec(seq)) {
-          // handle it with rtx
-          if (!isRtx(seq)) {
-            state_->onLossDetected(seq);
-            rtxState state;
-            state.first_send_ = state_->getInterestSentTime(seq);
-            if (state.first_send_ == 0)  // this interest was never sent before
-              state.first_send_ = getNow();
-            state.next_send_ = computeNextSend(seq, true);
-            state.rtx_count_ = 0;
-            DLOG_IF(INFO, VLOG_IS_ON(4))
-                << "Add " << seq << " to retransmissions. next rtx is %lu "
-                << state.next_send_ - getNow();
-            rtx_state_.insert(std::pair<uint32_t, rtxState>(seq, state));
-            rtx_timers_.insert(
-                std::pair<uint64_t, uint32_t>(state.next_send_, seq));
-          }
-        } else {
-          // is fec, do not send it
-          auto it = recover_with_fec_.find(seq);
-          if (it == recover_with_fec_.end()) {
-            state_->onLossDetected(seq);
-            recover_with_fec_.insert(seq);
-          }
-        }
-      } else {
-        // keep track of losses but recover with FEC
-        auto it = recover_with_fec_.find(seq);
-        if (it == recover_with_fec_.end()) {
-          state_->onLossDetected(seq);
-          recover_with_fec_.insert(seq);
-        }
-      }
-    }
-  }
-  scheduleNextRtx();
-}
-
-uint64_t RTCLossDetectionAndRecovery::computeNextSend(uint32_t seq,
-                                                      bool new_rtx) {
-  uint64_t now = getNow();
-  if (new_rtx) {
-    // for the new rtx we wait one estimated IAT after the loss detection. this
-    // is bacause, assuming that packets arrive with a constant IAT, we should
-    // get a new packet every IAT
-    double prod_rate = state_->getProducerRate();
-    uint32_t estimated_iat = SENTINEL_TIMER_INTERVAL;
-    uint32_t jitter = 0;
-
-    if (prod_rate != 0) {
-      double packet_size = state_->getAveragePacketSize();
-      estimated_iat = ceil(1000.0 / (prod_rate / packet_size));
-      jitter = ceil(state_->getJitter());
-    }
-
-    uint32_t wait = estimated_iat + jitter;
-    DLOG_IF(INFO, VLOG_IS_ON(3))
-        << "first rtx for " << seq << " in " << wait
-        << " ms, rtt = " << state_->getRTT() << " ait = " << estimated_iat
-        << " jttr = " << jitter;
-
-    return now + wait;
-  } else {
-    // wait one RTT
-    // however if the IAT is larger than the RTT, wait one IAT
-    uint32_t wait = SENTINEL_TIMER_INTERVAL;
-
-    double prod_rate = state_->getProducerRate();
-    if (prod_rate == 0) {
-      return now + SENTINEL_TIMER_INTERVAL;
-    }
-
-    double packet_size = state_->getAveragePacketSize();
-    uint32_t estimated_iat = ceil(1000.0 / (prod_rate / packet_size));
-
-    uint64_t rtt = state_->getRTT();
-    if (rtt == 0) rtt = SENTINEL_TIMER_INTERVAL;
-    wait = rtt;
-
-    if (estimated_iat > rtt) wait = estimated_iat;
-
-    uint32_t jitter = ceil(state_->getJitter());
-    wait += jitter;
-
-    // it may happen that the channel is congested and we have some additional
-    // queuing delay to take into account
-    uint32_t queue = ceil(state_->getQueuing());
-    wait += queue;
-
-    DLOG_IF(INFO, VLOG_IS_ON(3))
-        << "next rtx for " << seq << " in " << wait
-        << " ms, rtt = " << state_->getRTT() << " ait = " << estimated_iat
-        << " jttr = " << jitter << " queue = " << queue;
-
-    return now + wait;
-  }
-}
-
-void RTCLossDetectionAndRecovery::retransmit() {
-  if (rtx_timers_.size() == 0) return;
-
-  uint64_t now = getNow();
-
-  auto it = rtx_timers_.begin();
-  std::unordered_set<uint32_t> lost_pkt;
-  uint32_t sent_counter = 0;
-  while (it != rtx_timers_.end() && it->first <= now &&
-         sent_counter < MAX_RTX_IN_BATCH) {
-    uint32_t seq = it->second;
-    auto rtx_it =
-        rtx_state_.find(seq);  // this should always return a valid iter
-    if (rtx_it->second.rtx_count_ >= RTC_MAX_RTX ||
-        (now - rtx_it->second.first_send_) >= RTC_MAX_AGE ||
-        seq < state_->getLastSeqNacked()) {
-      // max rtx reached or packet too old or packet nacked, this packet is lost
-      DLOG_IF(INFO, VLOG_IS_ON(3))
-          << "packet " << seq << " lost because 1) max rtx: "
-          << (rtx_it->second.rtx_count_ >= RTC_MAX_RTX) << " 2) max age: "
-          << ((now - rtx_it->second.first_send_) >= RTC_MAX_AGE)
-          << " 3) nacked: " << (seq < state_->getLastSeqNacked());
-      lost_pkt.insert(seq);
-      it++;
-    } else {
-      // resend the packet
-      state_->onRetransmission(seq);
-      double prod_rate = state_->getProducerRate();
-      if (prod_rate != 0) rtx_it->second.rtx_count_++;
-      rtx_it->second.next_send_ = computeNextSend(seq, false);
-      it = rtx_timers_.erase(it);
-      rtx_timers_.insert(
-          std::pair<uint64_t, uint32_t>(rtx_it->second.next_send_, seq));
-      DLOG_IF(INFO, VLOG_IS_ON(3))
-          << "send rtx for sequence " << seq << ", next send in "
-          << (rtx_it->second.next_send_ - now);
-      send_rtx_callback_(seq);
-      sent_counter++;
-    }
-  }
-
-  // remove packets if needed
-  for (auto lost_it = lost_pkt.begin(); lost_it != lost_pkt.end(); lost_it++) {
-    uint32_t seq = *lost_it;
-    state_->onPacketLost(seq);
-    deleteRtx(seq);
-  }
-}
-
-void RTCLossDetectionAndRecovery::scheduleNextRtx() {
-  if (rtx_timers_.size() == 0) {
-    // all the rtx were removed, reset timer
-    next_rtx_timer_ = MAX_TIMER_RTX;
-    return;
-  }
-
-  // check if timer is alreay set
-  if (next_rtx_timer_ != MAX_TIMER_RTX) {
-    // a new check for rtx is already scheduled
-    if (next_rtx_timer_ > rtx_timers_.begin()->first) {
-      // we need to re-schedule it
-      timer_->cancel();
-    } else {
-      // wait for the next timer
-      return;
-    }
-  }
-
-  // set a new timer
-  next_rtx_timer_ = rtx_timers_.begin()->first;
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
-  uint64_t wait = 1;
-  if (next_rtx_timer_ != MAX_TIMER_RTX && next_rtx_timer_ > now)
-    wait = next_rtx_timer_ - now;
-
-  std::weak_ptr<RTCLossDetectionAndRecovery> self(shared_from_this());
-  timer_->expires_from_now(std::chrono::milliseconds(wait));
-  timer_->async_wait([self](std::error_code ec) {
-    if (ec) return;
-    if (auto s = self.lock()) {
-      s->retransmit();
-      s->next_rtx_timer_ = MAX_TIMER_RTX;
-      s->scheduleNextRtx();
-    }
-  });
-}
-
-bool RTCLossDetectionAndRecovery::deleteRtx(uint32_t seq) {
-  auto it_rtx = rtx_state_.find(seq);
-  if (it_rtx == rtx_state_.end()) return false;  // rtx not found
-
-  uint64_t ts = it_rtx->second.next_send_;
-  auto it_timers = rtx_timers_.find(ts);
-  while (it_timers != rtx_timers_.end() && it_timers->first == ts) {
-    if (it_timers->second == seq) {
-      rtx_timers_.erase(it_timers);
-      break;
-    }
-    it_timers++;
-  }
-
-  bool lost = it_rtx->second.rtx_count_ > 0;
-  rtx_state_.erase(it_rtx);
-
-  return lost;
-}
-
-void RTCLossDetectionAndRecovery::scheduleSentinelTimer(
-    uint64_t expires_from_now) {
-  std::weak_ptr<RTCLossDetectionAndRecovery> self(shared_from_this());
-  sentinel_timer_->expires_from_now(
-      std::chrono::milliseconds(expires_from_now));
-  sentinel_timer_->async_wait([self](std::error_code ec) {
-    if (ec) return;
-    if (auto s = self.lock()) {
-      s->sentinelTimer();
-    }
-  });
-}
-
-void RTCLossDetectionAndRecovery::sentinelTimer() {
-  uint64_t now = getNow();
-
-  bool expired = false;
-  bool sent = false;
-  if ((now - last_event_) >= sentinel_timer_interval_) {
-    // at least a sentinel_timer_interval_ elapsed since last event
-    expired = true;
-    if (TRANSPORT_EXPECT_FALSE(!state_->isProducerActive())) {
-      // this happens at the beginning (or if the producer stops for some
-      // reason) we need to keep sending interest 0 until we get an answer
-      DLOG_IF(INFO, VLOG_IS_ON(3))
-          << "sentinel timer: the producer is not active, send packet 0";
-      state_->onRetransmission(0);
-      send_rtx_callback_(0);
-    } else {
-      DLOG_IF(INFO, VLOG_IS_ON(3)) << "sentinel timer: the producer is active, "
-                                      "send the 10 oldest packets";
-      sent = true;
-      uint32_t rtx = 0;
-      auto it = state_->getPendingInterestsMapBegin();
-      auto end = state_->getPendingInterestsMapEnd();
-      while (it != end && rtx < MAX_RTX_WITH_SENTINEL) {
-        uint32_t seq = it->first;
-        DLOG_IF(INFO, VLOG_IS_ON(3))
-            << "sentinel timer, add " << seq << " to the rtx list";
-        addToRetransmissions(seq, seq + 1);
-        rtx++;
-        it++;
-      }
-    }
-  } else {
-    // sentinel timer did not expire because we registered at least one event
-  }
-
-  uint32_t next_timer;
-  double prod_rate = state_->getProducerRate();
-  if (TRANSPORT_EXPECT_FALSE(!state_->isProducerActive()) || prod_rate == 0) {
-    DLOG_IF(INFO, VLOG_IS_ON(3)) << "next timer in " << SENTINEL_TIMER_INTERVAL;
-    next_timer = SENTINEL_TIMER_INTERVAL;
-  } else {
-    double prod_rate = state_->getProducerRate();
-    double packet_size = state_->getAveragePacketSize();
-    uint32_t estimated_iat = ceil(1000.0 / (prod_rate / packet_size));
-    uint32_t jitter = ceil(state_->getJitter());
-
-    // try to reduce the number of timers if the estimated IAT is too small
-    next_timer = std::max((estimated_iat + jitter) * 20, (uint32_t)1);
-    DLOG_IF(INFO, VLOG_IS_ON(3))
-        << "next sentinel in " << next_timer
-        << " ms, rate: " << ((prod_rate * 8.0) / 1000000.0)
-        << ", iat: " << estimated_iat << ", jitter: " << jitter;
-
-    if (!expired) {
-      // discount the amout of time that is already passed
-      uint32_t discount = now - last_event_;
-      if (next_timer > discount) {
-        next_timer = next_timer - discount;
-      } else {
-        // in this case we trigger the timer in 1 ms
-        next_timer = 1;
+    if (rs_->getState()->getPacketState(seq) == PacketState::UNKNOWN) {
+      if (rs_->lossDetected(seq)) {
+        rs_->getState()->onLossDetected(seq);
       }
-      DLOG_IF(INFO, VLOG_IS_ON(3)) << "timer after discout: " << next_timer;
-    } else if (sent) {
-      // wait at least one producer stats interval + owd to check if the
-      // production rate is reducing.
-      uint32_t min_wait = PRODUCER_STATS_INTERVAL + ceil(state_->getQueuing());
-      next_timer = std::max(next_timer, min_wait);
-      DLOG_IF(INFO, VLOG_IS_ON(3))
-          << "wait for updates from prod, next timer: " << next_timer;
     }
   }
-
-  scheduleSentinelTimer(next_timer);
 }
 
 }  // namespace rtc
diff --git a/libtransport/src/protocols/rtc/rtc_ldr.h b/libtransport/src/protocols/rtc/rtc_ldr.h
index 1b9f9afd6..e7f8ce5db 100644
--- a/libtransport/src/protocols/rtc/rtc_ldr.h
+++ b/libtransport/src/protocols/rtc/rtc_ldr.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -15,16 +15,14 @@
 
 #pragma once
 #include <hicn/transport/config.h>
+#include <hicn/transport/interfaces/socket_options_keys.h>
+// RtcTransportRecoveryStrategies
 #include <hicn/transport/core/asio_wrapper.h>
 #include <hicn/transport/core/content_object.h>
 #include <hicn/transport/core/name.h>
-#include <protocols/indexer.h>
-#include <protocols/rtc/rtc_consts.h>
-#include <protocols/rtc/rtc_state.h>
+#include <protocols/rtc/rtc_recovery_strategy.h>
 
 #include <functional>
-#include <map>
-#include <unordered_map>
 
 namespace transport {
 
@@ -34,91 +32,45 @@ namespace rtc {
 
 class RTCLossDetectionAndRecovery
     : public std::enable_shared_from_this<RTCLossDetectionAndRecovery> {
-  struct rtx_state_ {
-    uint64_t first_send_;
-    uint64_t next_send_;
-    uint32_t rtx_count_;
-  };
-
-  using rtxState = struct rtx_state_;
-  using SendRtxCallback = std::function<void(uint32_t)>;
-
  public:
-  RTCLossDetectionAndRecovery(Indexer *indexer, SendRtxCallback &&callback,
-                              asio::io_service &io_service);
+  RTCLossDetectionAndRecovery(Indexer *indexer, asio::io_service &io_service,
+                              interface::RtcTransportRecoveryStrategies type,
+                              RecoveryStrategy::SendRtxCallback &&callback,
+                              interface::StrategyCallback *external_callback);
 
   ~RTCLossDetectionAndRecovery();
 
-  void setState(std::shared_ptr<RTCState> state) { state_ = state; }
-  void setFecParams(uint32_t n, uint32_t k) {
-    n_ = n;
-    k_ = k;
+  void setState(RTCState *state) { rs_->setState(state); }
+  void setRateControl(RTCRateControl *rateControl) {
+    rs_->setRateControl(rateControl);
   }
-  void turnOnRTX();
-  void turnOffRTX();
-  bool isRtxOn() { return rtx_on_; }
+
+  void setFecParams(uint32_t n, uint32_t k) { rs_->setFecParams(n, k); }
+
+  void turnOnRecovery() { rs_->tunrOnRecovery(); }
+  bool isRtxOn() { return rs_->isRtxOn(); }
+
+  void changeRecoveryStrategy(interface::RtcTransportRecoveryStrategies type);
 
   void onNewRound(bool in_sync);
-  void onTimeout(uint32_t seq);
+  void onTimeout(uint32_t seq, bool lost);
   void onPacketRecoveredFec(uint32_t seq);
   void onDataPacketReceived(const core::ContentObject &content_object);
   void onNackPacketReceived(const core::ContentObject &nack);
   void onProbePacketReceived(const core::ContentObject &probe);
 
-  void clear();
+  void clear() { rs_->clear(); }
 
-  bool isRtx(uint32_t seq) {
-    if (rtx_state_.find(seq) != rtx_state_.end()) return true;
-    return false;
+  bool isRtx(uint32_t seq) { return rs_->isRtx(seq); }
+  bool isPossibleLossWithNoRtx(uint32_t seq) {
+    return rs_->isPossibleLossWithNoRtx(seq);
   }
 
  private:
-  void addToRetransmissions(uint32_t start, uint32_t stop);
-  uint64_t computeNextSend(uint32_t seq, bool new_rtx);
-  void retransmit();
-  void scheduleNextRtx();
-  bool deleteRtx(uint32_t seq);
-  void scheduleSentinelTimer(uint64_t expires_from_now);
-  void sentinelTimer();
-  uint32_t computeFecPacketsToAsk(bool in_sync);
-
-  uint64_t getNow() {
-    using namespace std::chrono;
-    uint64_t now =
-        duration_cast<milliseconds>(steady_clock::now().time_since_epoch())
-            .count();
-    return now;
-  }
-
-  // this map keeps track of the retransmitted interest, ordered from the oldest
-  // to the newest one. the state contains the timer of the first send of the
-  // interest (from pendingIntetests_), the timer of the next send (key of the
-  // multimap) and the number of rtx
-  std::map<uint32_t, rtxState> rtx_state_;
-  // this map stored the rtx by timer. The key is the time at which the rtx
-  // should be sent, and the val is the interest seq number
-  std::multimap<uint64_t, uint32_t> rtx_timers_;
-
-  // lost packets that will be recovered with fec
-  std::unordered_set<uint32_t> recover_with_fec_;
-
-  bool rtx_on_;
-  bool fec_on_;
-  uint64_t next_rtx_timer_;
-  uint64_t last_event_;
-  uint64_t sentinel_timer_interval_;
-
-  // fec params
-  uint32_t n_;
-  uint32_t k_;
-
-  std::unique_ptr<asio::steady_timer> timer_;
-  std::unique_ptr<asio::steady_timer> sentinel_timer_;
-  std::shared_ptr<RTCState> state_;
-
-  Indexer *indexer_;
+  void detectLoss(uint32_t start, uint32_t stop);
 
-  SendRtxCallback send_rtx_callback_;
+  interface::RtcTransportRecoveryStrategies rs_type_;
+  std::shared_ptr<RecoveryStrategy> rs_;
 };
 
 }  // end namespace rtc
diff --git a/libtransport/src/protocols/rtc/rtc_packet.h b/libtransport/src/protocols/rtc/rtc_packet.h
index 7dc2f82c3..391aedfc6 100644
--- a/libtransport/src/protocols/rtc/rtc_packet.h
+++ b/libtransport/src/protocols/rtc/rtc_packet.h
@@ -24,6 +24,27 @@
  *     +-----------------------------------------+
  */
 
+/*        aggregated packets
+ *    +---------------------------------+
+ *    |c| #pkts | len1  | len2  | ....  |
+ *    +----------------------------------
+ *
+ *    +---------------------------------+
+ *    |c| #pkts | resv  |     len 1     |
+ *    +----------------------------------
+ *
+ *  aggregated packets header.
+ *  header position. just after the data packet header
+ *
+ *  c: 1 bit: 0 8bit encoding, 1 16bit encoding
+ *  #pkts: 7 bits: number of application packets contained
+ *  8bits encoding:
+ *  lenX: 8 bits: len in bites of packet X
+ *  16bits econding:
+ *  resv: 8 bits: reserved field (unused)
+ *  lenX: 16bits: len in bytes of packet X
+ */
+
 #pragma once
 #ifndef _WIN32
 #include <arpa/inet.h>
@@ -31,6 +52,8 @@
 #include <hicn/transport/portability/win_portability.h>
 #endif
 
+#include <cstring>
+
 namespace transport {
 
 namespace protocol {
@@ -82,8 +105,144 @@ struct nack_packet_t {
   inline uint32_t getProductionRate() const { return ntohl(prod_rate); }
   inline void setProductionRate(uint32_t rate) { prod_rate = htonl(rate); }
 
-  inline uint32_t getProductionSegement() const { return ntohl(prod_seg); }
-  inline void setProductionSegement(uint32_t seg) { prod_seg = htonl(seg); }
+  inline uint32_t getProductionSegment() const { return ntohl(prod_seg); }
+  inline void setProductionSegment(uint32_t seg) { prod_seg = htonl(seg); }
+};
+
+class AggrPktHeader {
+ public:
+  // XXX buf always point to the payload after the data header
+  AggrPktHeader(uint8_t *buf, uint16_t max_packet_len, uint16_t pkt_number)
+      : buf_(buf), pkt_num_(pkt_number) {
+    *buf_ = 0;  // reset the first byte to correctly add the header
+                // encoding and the packet number
+    if (max_packet_len > 0xff) {
+      setAggrPktEncoding16bit();
+    } else {
+      setAggrPktEncoding8bit();
+    }
+    setAggrPktNUmber(pkt_number);
+    header_len_ = computeHeaderLen();
+    memset(buf_ + 1, 0, header_len_ - 1);
+  }
+
+  // XXX buf always point to the payload after the data header
+  AggrPktHeader(uint8_t *buf) : buf_(buf) {
+    encoding_ = getAggrPktEncoding();
+    pkt_num_ = getAggrPktNumber();
+    header_len_ = computeHeaderLen();
+  }
+
+  ~AggrPktHeader(){};
+
+  int addPacketToHeader(uint8_t index, uint16_t len) {
+    if (index > pkt_num_) return -1;
+
+    setAggrPktLen(index, len);
+    return 0;
+  }
+
+  int getPointerToPacket(uint8_t index, uint8_t **pkt_ptr, uint16_t *pkt_len) {
+    if (index > pkt_num_) return -1;
+
+    uint16_t len = 0;
+    for (int i = 0; i < index; i++)
+      len += getAggrPktLen(i);  // sum the pkts len from 0 to index - 1
+
+    uint16_t offset = len + header_len_;
+    *pkt_ptr = buf_ + offset;
+    *pkt_len = getAggrPktLen(index);
+    return 0;
+  }
+
+  int getPacketOffsets(uint8_t index, uint16_t *pkt_offset, uint16_t *pkt_len) {
+    if (index > pkt_num_) return -1;
+
+    uint16_t len = 0;
+    for (int i = 0; i < index; i++)
+      len += getAggrPktLen(i);  // sum the pkts len from 0 to index - 1
+
+    uint16_t offset = len + header_len_;
+    *pkt_offset = offset;
+    *pkt_len = getAggrPktLen(index);
+
+    return 0;
+  }
+
+  uint8_t *getPayloadAppendPtr() { return buf_ + header_len_; }
+
+  uint16_t getHeaderLen() { return header_len_; }
+
+  uint8_t getNumberOfPackets() { return pkt_num_; }
+
+ private:
+  inline uint16_t computeHeaderLen() const {
+    uint16_t len = 4;  // min len in bytes
+    if (!encoding_) {
+      while (pkt_num_ >= len) {
+        len += 4;
+      }
+    } else {
+      while (pkt_num_ * 2 >= len) {
+        len += 4;
+      }
+    }
+    return len;
+  }
+
+  inline uint8_t getAggrPktEncoding() const {
+    // get the first bit of the first byte
+    return (*buf_ >> 7);
+  }
+
+  inline void setAggrPktEncoding8bit() {
+    // reset the first bit of the first byte
+    encoding_ = 0;
+    *buf_ &= 0x7f;
+  }
+
+  inline void setAggrPktEncoding16bit() {
+    // set the first bit of the first byte
+    encoding_ = 1;
+    *buf_ ^= 0x80;
+  }
+
+  inline uint8_t getAggrPktNumber() const {
+    // return the first byte with the first bit = 0
+    return (*buf_ & 0x7f);
+  }
+
+  inline void setAggrPktNUmber(uint8_t val) {
+    // set the val without modifying the first bit
+    *buf_ &= 0x80;  // reset everithing but the first bit
+    val &= 0x7f;    // reset the first bit
+    *buf_ |= val;   // or the vals, done!
+  }
+
+  inline uint16_t getAggrPktLen(uint8_t pkt_index) const {
+    pkt_index++;
+    if (!encoding_) {  // 8 bits
+      return (uint16_t) * (buf_ + pkt_index);
+    } else {  // 16 bits
+      uint16_t *buf_16 = (uint16_t *)buf_;
+      return ntohs(*(buf_16 + pkt_index));
+    }
+  }
+
+  inline void setAggrPktLen(uint8_t pkt_index, uint16_t len) {
+    pkt_index++;
+    if (!encoding_) {  // 8 bits
+      *(buf_ + pkt_index) = (uint8_t)len;
+    } else {  // 16 bits
+      uint16_t *buf_16 = (uint16_t *)buf_;
+      *(buf_16 + pkt_index) = htons(len);
+    }
+  }
+
+  uint8_t *buf_;
+  uint8_t encoding_;
+  uint8_t pkt_num_;
+  uint16_t header_len_;
 };
 
 }  // end namespace rtc
diff --git a/libtransport/src/protocols/rtc/rtc_rc.h b/libtransport/src/protocols/rtc/rtc_rc.h
index 34d090092..62636ce40 100644
--- a/libtransport/src/protocols/rtc/rtc_rc.h
+++ b/libtransport/src/protocols/rtc/rtc_rc.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -34,11 +34,15 @@ class RTCRateControl : public std::enable_shared_from_this<RTCRateControl> {
 
   void turnOnRateControl() { rc_on_ = true; }
   void setState(std::shared_ptr<RTCState> state) { protocol_state_ = state; };
-  uint32_t getCongesionWindow() { return congestion_win_; };
+  uint32_t getCongestionWindow() { return congestion_win_; };
+  bool inCongestionState() {
+    if (congestion_state_ == CongestionState::Congested) return true;
+    return false;
+  }
 
   virtual void onNewRound(double round_len) = 0;
-  virtual void onDataPacketReceived(
-      const core::ContentObject &content_object) = 0;
+  virtual void onDataPacketReceived(const core::ContentObject &content_object,
+                                    bool compute_stats) = 0;
 
  protected:
   enum class CongestionState { Normal = 0, Underuse = 1, Congested = 2, Last };
diff --git a/libtransport/src/protocols/rtc/rtc_rc_congestion_detection.cc b/libtransport/src/protocols/rtc/rtc_rc_congestion_detection.cc
new file mode 100644
index 000000000..6cd3094b5
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rc_congestion_detection.cc
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <protocols/rtc/rtc_consts.h>
+#include <protocols/rtc/rtc_rc_congestion_detection.h>
+
+#include <algorithm>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+RTCRateControlCongestionDetection::RTCRateControlCongestionDetection()
+    : rounds_without_congestion_(4), last_queue_(0) {}  // must be > 3
+
+RTCRateControlCongestionDetection::~RTCRateControlCongestionDetection() {}
+
+void RTCRateControlCongestionDetection::onNewRound(double round_len) {
+  if (!rc_on_) return;
+
+  double rtt = (double)protocol_state_->getMinRTT() / MILLI_IN_A_SEC;
+  double queue = protocol_state_->getQueuing();
+
+  if (rtt == 0.0) return;  // no info from the producer
+
+  if (last_queue_ == queue) {
+    // if last_queue == queue the consumer didn't receive any
+    // packet from the producer. we do not change the current congestion state.
+    // we just increase the counter of rounds whithout congestion if needed
+    // (in case of congestion the counter is already set to 0)
+    if (congestion_state_ == CongestionState::Normal)
+      rounds_without_congestion_++;
+  } else {
+    if (queue > MAX_QUEUING_DELAY) {
+      // here we detect congestion.
+      congestion_state_ = CongestionState::Congested;
+      rounds_without_congestion_ = 0;
+    } else {
+      // wait 3 rounds before switch back to no congestion
+      if (rounds_without_congestion_ > 3) {
+        // nothing bad is happening
+        congestion_state_ = CongestionState::Normal;
+      }
+      rounds_without_congestion_++;
+    }
+    last_queue_ = queue;
+  }
+}
+
+void RTCRateControlCongestionDetection::onDataPacketReceived(
+    const core::ContentObject &content_object, bool compute_stats) {
+  // nothing to do
+  return;
+}
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rc_congestion_detection.h b/libtransport/src/protocols/rtc/rtc_rc_congestion_detection.h
new file mode 100644
index 000000000..9afa6c39a
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rc_congestion_detection.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <hicn/transport/utils/shared_ptr_utils.h>
+#include <protocols/rtc/rtc_rc.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+class RTCRateControlCongestionDetection : public RTCRateControl {
+ public:
+  RTCRateControlCongestionDetection();
+
+  ~RTCRateControlCongestionDetection();
+
+  void onNewRound(double round_len);
+  void onDataPacketReceived(const core::ContentObject &content_object,
+                            bool compute_stats);
+
+  auto shared_from_this() { return utils::shared_from(this); }
+
+ private:
+  uint32_t rounds_without_congestion_;
+  double last_queue_;
+};
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rc_iat.cc b/libtransport/src/protocols/rtc/rtc_rc_iat.cc
new file mode 100644
index 000000000..f06f377f3
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rc_iat.cc
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <protocols/rtc/rtc_consts.h>
+#include <protocols/rtc/rtc_rc_iat.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+RTCRateControlIAT::RTCRateControlIAT()
+    : rounds_since_last_drop_(0),
+      rounds_without_congestion_(0),
+      rounds_with_congestion_(0),
+      last_queue_(0),
+      last_rcv_time_(0),
+      last_prod_time_(0),
+      last_seq_number_(0),
+      target_rate_avg_(0),
+      round_index_(0),
+      congestion_cause_(CongestionCause::UNKNOWN) {}
+
+RTCRateControlIAT::~RTCRateControlIAT() {}
+
+void RTCRateControlIAT::onNewRound(double round_len) {
+  if (!rc_on_) return;
+
+  double received_rate = protocol_state_->getReceivedRate() +
+                         protocol_state_->getRecoveredFecRate();
+
+  double target_rate =
+      protocol_state_->getProducerRate();  // * PRODUCTION_RATE_FRACTION;
+  double rtt = (double)protocol_state_->getMinRTT() / MILLI_IN_A_SEC;
+  // double packet_size = protocol_state_->getAveragePacketSize();
+  double queue = protocol_state_->getQueuing();
+
+  if (rtt == 0.0) return;  // no info from the producer
+
+  CongestionState prev_congestion_state = congestion_state_;
+
+  target_rate_avg_ = target_rate_avg_ * (1 - MOVING_AVG_ALPHA) +
+                     target_rate * MOVING_AVG_ALPHA;
+
+  if (prev_congestion_state == CongestionState::Congested) {
+    if (queue > MAX_QUEUING_DELAY || last_queue_ == queue) {
+      congestion_state_ = CongestionState::Congested;
+
+      received_rate_.push_back(received_rate);
+      target_rate_.push_back(target_rate);
+
+      // We assume the cause does not change
+      // Note that the first assumption about the cause could be wrong
+      // the cause of congestion could change
+      if (congestion_cause_ == CongestionCause::UNKNOWN)
+        if (rounds_with_congestion_ >= 1)
+          congestion_cause_ = apply_classification_tree(
+              rounds_with_congestion_ > ROUND_TO_WAIT_FORCE_DECISION);
+
+      rounds_with_congestion_++;
+    } else {
+      congestion_state_ = CongestionState::Normal;
+
+      // clear past history
+      reset_congestion_statistics();
+
+      // TODO maybe we can use some of these values for the stdev of the
+      // congestion mode
+      for (int i = 0; i < ROUND_HISTORY_SIZE; i++) {
+        iat_on_hold_[i].clear();
+      }
+    }
+  } else if (queue > MAX_QUEUING_DELAY) {
+    if (prev_congestion_state == CongestionState::Normal) {
+      rounds_with_congestion_ = 0;
+
+      if (rounds_without_congestion_ > ROUND_TO_RESET_CAUSE)
+        congestion_cause_ = CongestionCause::UNKNOWN;
+    }
+    congestion_state_ = CongestionState::Congested;
+    received_rate_.push_back(received_rate);
+    target_rate_.push_back(target_rate);
+  } else {
+    // nothing bad is happening
+    congestion_state_ = CongestionState::Normal;
+    reset_congestion_statistics();
+
+    int past_index = (round_index_ + 1) % ROUND_HISTORY_SIZE;
+    for (std::vector<double>::iterator it = iat_on_hold_[past_index].begin();
+         it != iat_on_hold_[past_index].end(); ++it) {
+      congestion_free_iat_.push_back(*it);
+      if (congestion_free_iat_.size() > 50) {
+        congestion_free_iat_.erase(congestion_free_iat_.begin());
+      }
+    }
+    iat_on_hold_[past_index].clear();
+    round_index_ = (round_index_ + 1) % ROUND_HISTORY_SIZE;
+  }
+
+  last_queue_ = queue;
+
+  if (congestion_state_ == CongestionState::Congested) {
+    if (prev_congestion_state == CongestionState::Normal) {
+      // init the congetion window using the received rate
+      // disabling for the moment the congestion window setup
+      // congestion_win_ = (uint32_t)ceil(received_rate * rtt / packet_size);
+      rounds_since_last_drop_ = ROUNDS_BEFORE_TAKE_ACTION + 1;
+    }
+
+    if (rounds_since_last_drop_ >= ROUNDS_BEFORE_TAKE_ACTION) {
+      // disabling for the moment the congestion window setup
+      // uint32_t win = congestion_win_ * WIN_DECREASE_FACTOR;
+      // congestion_win_ = std::max(win, WIN_MIN);
+      rounds_since_last_drop_ = 0;
+      return;
+    }
+
+    rounds_since_last_drop_++;
+  }
+
+  if (congestion_state_ == CongestionState::Normal) {
+    if (prev_congestion_state == CongestionState::Congested) {
+      rounds_without_congestion_ = 0;
+    }
+
+    rounds_without_congestion_++;
+    if (rounds_without_congestion_ < ROUNDS_BEFORE_TAKE_ACTION) return;
+
+    // disabling for the moment the congestion window setup
+    // congestion_win_ = congestion_win_ * WIN_INCREASE_FACTOR;
+    // congestion_win_ = std::min(congestion_win_, INITIAL_WIN_MAX);
+  }
+
+  if (received_rate_.size() > 1000)
+    received_rate_.erase(received_rate_.begin());
+  if (target_rate_.size() > 1000) target_rate_.erase(target_rate_.begin());
+}
+
+void RTCRateControlIAT::onDataPacketReceived(
+    const core::ContentObject &content_object, bool compute_stats) {
+  core::ParamsRTC params = RTCState::getDataParams(content_object);
+
+  uint64_t now = utils::SteadyTime::nowMs().count();
+
+  uint32_t segment_number = content_object.getName().getSuffix();
+
+  if (segment_number == (last_seq_number_ + 1) && compute_stats) {
+    uint64_t iat = now - last_rcv_time_;
+    uint64_t ist = params.timestamp - last_prod_time_;
+    if (now >= last_rcv_time_ && params.timestamp > last_prod_time_) {
+      if (iat >= ist && ist < MIN_IST_VALUE) {
+        if (congestion_state_ == CongestionState::Congested) {
+          iat_.push_back((iat - ist));
+        } else {
+          // no congestion, but we do not always add new values, but only when
+          // there is no sign of congestion
+          double queue = protocol_state_->getQueuing();
+          if (queue <= CONGESTION_FREE_QUEUEING_DELAY) {
+            iat_on_hold_[round_index_].push_back((iat - ist));
+          }
+        }
+      }
+    }
+  }
+
+  last_seq_number_ = segment_number;
+  last_rcv_time_ = now;
+  last_prod_time_ = params.timestamp;
+
+  if (iat_.size() > 1000) iat_.erase(iat_.begin());
+  return;
+}
+
+CongestionCause RTCRateControlIAT::apply_classification_tree(bool force_reply) {
+  if (iat_.size() <= 2 || received_rate_.size() < 2)
+    return CongestionCause::UNKNOWN;
+
+  double received_ratio = 0;
+  double iat_ratio = 0;
+  double iat_stdev = compute_iat_stdev(iat_);
+  double iat_congestion_free_stdev = compute_iat_stdev(congestion_free_iat_);
+
+  double iat_avg = 0.0;
+
+  double recv_avg = 0.0;
+  double recv_max = 0.0;
+
+  double target_rate_avg = 0.0;
+
+  int counter = 0;
+  std::vector<double>::reverse_iterator target_it = target_rate_.rbegin();
+  for (std::vector<double>::reverse_iterator it = received_rate_.rbegin();
+       it != received_rate_.rend(); ++it) {
+    recv_avg += *it;
+    target_rate_avg += *target_it;
+    if (counter < ROUND_HISTORY_SIZE)
+      if (recv_max < *it) {
+        recv_max = *it;  // we consider only the last 2 seconds
+      }
+    counter++;
+    target_it++;
+  }
+  recv_avg = recv_avg / received_rate_.size();
+  target_rate_avg = target_rate_avg / target_rate_.size();
+
+  for (std::vector<double>::iterator it = iat_.begin(); it != iat_.end();
+       ++it) {
+    iat_avg += *it;
+  }
+  iat_avg = iat_avg / iat_.size();
+
+  double congestion_free_iat_avg = 0.0;
+  for (std::vector<double>::iterator it = congestion_free_iat_.begin();
+       it != congestion_free_iat_.end(); ++it) {
+    congestion_free_iat_avg += *it;
+  }
+  congestion_free_iat_avg =
+      congestion_free_iat_avg / congestion_free_iat_.size();
+
+  received_ratio = recv_avg / target_rate_avg;
+
+  iat_ratio = iat_stdev / iat_congestion_free_stdev;
+
+  CongestionCause congestion_cause = CongestionCause::UNKNOWN;
+  // applying classification tree model
+  if (received_ratio <= 0.87)
+    if (iat_stdev <= 6.48)
+      if (received_ratio <= 0.83)
+        congestion_cause = CongestionCause::LINK_CAPACITY;
+      else if (force_reply)
+        congestion_cause = CongestionCause::LINK_CAPACITY;
+      else
+        congestion_cause = CongestionCause::UNKNOWN;  // accuracy is too low
+    else if (iat_ratio <= 2.46)
+      if (force_reply)
+        congestion_cause = CongestionCause::LINK_CAPACITY;
+      else
+        congestion_cause = CongestionCause::UNKNOWN;  // accuracy is too low
+    else
+      congestion_cause = CongestionCause::COMPETING_CROSS_TRAFFIC;
+  else if (received_ratio <= 0.913 && iat_stdev <= 0.784)
+    congestion_cause = CongestionCause::LINK_CAPACITY;
+  else
+    congestion_cause = CongestionCause::COMPETING_CROSS_TRAFFIC;
+
+  return congestion_cause;
+}
+
+void RTCRateControlIAT::reset_congestion_statistics() {
+  iat_.clear();
+  received_rate_.clear();
+  target_rate_.clear();
+}
+
+double RTCRateControlIAT::compute_iat_stdev(std::vector<double> v) {
+  if (v.size() == 0) return 0;
+
+  float sum = 0.0, mean, standard_deviation = 0.0;
+  for (std::vector<double>::iterator it = v.begin(); it != v.end(); it++) {
+    sum += *it;
+  }
+
+  mean = sum / v.size();
+  for (std::vector<double>::iterator it = v.begin(); it != v.end(); it++) {
+    standard_deviation += pow(*it - mean, 2);
+  }
+  return sqrt(standard_deviation / v.size());
+}
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rc_iat.h b/libtransport/src/protocols/rtc/rtc_rc_iat.h
new file mode 100644
index 000000000..715637807
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rc_iat.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <hicn/transport/utils/shared_ptr_utils.h>
+#include <protocols/rtc/rtc_rc.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+const int ROUND_HISTORY_SIZE = 10;  // equivalent to two seconds
+const int ROUND_TO_WAIT_FORCE_DECISION = 5;
+
+// once congestion is gone, we need to wait for k rounds before changing the
+// congestion cause in the case it appears again
+const int ROUND_TO_RESET_CAUSE = 5;
+
+const int MIN_IST_VALUE = 150;  // samples of ist larger than 150ms are
+                                // discarded
+const double CONGESTION_FREE_QUEUEING_DELAY = 10;
+
+enum class CongestionCause : uint8_t {
+  COMPETING_CROSS_TRAFFIC,
+  FRIENDLY_CROSS_TRAFFIC,
+  UNKNOWN_CROSS_TRAFFIC,
+  LINK_CAPACITY,
+  UNKNOWN
+};
+
+class RTCRateControlIAT : public RTCRateControl {
+ public:
+  RTCRateControlIAT();
+
+  ~RTCRateControlIAT();
+
+  void onNewRound(double round_len);
+  void onDataPacketReceived(const core::ContentObject &content_object,
+                            bool compute_stats);
+
+  auto shared_from_this() { return utils::shared_from(this); }
+
+ private:
+  void reset_congestion_statistics();
+
+  double compute_iat_stdev(std::vector<double> v);
+
+  CongestionCause apply_classification_tree(bool force_reply);
+
+ private:
+  uint32_t rounds_since_last_drop_;
+  uint32_t rounds_without_congestion_;
+  uint32_t rounds_with_congestion_;
+  double last_queue_;
+  uint64_t last_rcv_time_;
+  uint64_t last_prod_time_;
+  uint32_t last_seq_number_;
+  double target_rate_avg_;
+
+  // Iat values are not immediately added to the congestion free set of values
+  std::array<std::vector<double>, ROUND_HISTORY_SIZE> iat_on_hold_;
+  uint32_t round_index_;
+
+  // with congestion statistics
+  std::vector<double> iat_;
+  std::vector<double> received_rate_;
+  std::vector<double> target_rate_;
+
+  // congestion free statistics
+  std::vector<double> congestion_free_iat_;
+
+  CongestionCause congestion_cause_;
+};
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rc_queue.cc b/libtransport/src/protocols/rtc/rtc_rc_queue.cc
index a1c89e329..ecabc5205 100644
--- a/libtransport/src/protocols/rtc/rtc_rc_queue.cc
+++ b/libtransport/src/protocols/rtc/rtc_rc_queue.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -37,7 +37,7 @@ void RTCRateControlQueue::onNewRound(double round_len) {
   double received_rate = protocol_state_->getReceivedRate();
   double target_rate =
       protocol_state_->getProducerRate() * PRODUCTION_RATE_FRACTION;
-  double rtt = (double)protocol_state_->getRTT() / MILLI_IN_A_SEC;
+  double rtt = (double)protocol_state_->getMinRTT() / MILLI_IN_A_SEC;
   double packet_size = protocol_state_->getAveragePacketSize();
   double queue = protocol_state_->getQueuing();
 
@@ -94,7 +94,7 @@ void RTCRateControlQueue::onNewRound(double round_len) {
 }
 
 void RTCRateControlQueue::onDataPacketReceived(
-    const core::ContentObject &content_object) {
+    const core::ContentObject &content_object, bool compute_stats) {
   // nothing to do
   return;
 }
diff --git a/libtransport/src/protocols/rtc/rtc_rc_queue.h b/libtransport/src/protocols/rtc/rtc_rc_queue.h
index 407354d43..cdf78fd47 100644
--- a/libtransport/src/protocols/rtc/rtc_rc_queue.h
+++ b/libtransport/src/protocols/rtc/rtc_rc_queue.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -30,7 +30,8 @@ class RTCRateControlQueue : public RTCRateControl {
   ~RTCRateControlQueue();
 
   void onNewRound(double round_len);
-  void onDataPacketReceived(const core::ContentObject &content_object);
+  void onDataPacketReceived(const core::ContentObject &content_object,
+                            bool compute_stats);
 
   auto shared_from_this() { return utils::shared_from(this); }
 
diff --git a/libtransport/src/protocols/rtc/rtc_reassembly.cc b/libtransport/src/protocols/rtc/rtc_reassembly.cc
new file mode 100644
index 000000000..992bab50e
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_reassembly.cc
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <hicn/transport/interfaces/socket_consumer.h>
+#include <implementation/socket_consumer.h>
+#include <protocols/rtc/rtc_reassembly.h>
+#include <protocols/transport_protocol.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+RtcReassembly::RtcReassembly(implementation::ConsumerSocket* icn_socket,
+                             TransportProtocol* transport_protocol)
+    : DatagramReassembly(icn_socket, transport_protocol) {
+  is_setup_ = false;
+}
+
+void RtcReassembly::reassemble(core::ContentObject& content_object) {
+  if (!is_setup_) {
+    is_setup_ = true;
+    reassembly_consumer_socket_->getSocketOption(
+        interface::RtcTransportOptions::AGGREGATED_DATA, data_aggregation_);
+  }
+
+  auto read_buffer = content_object.getPayload();
+  DLOG_IF(INFO, VLOG_IS_ON(3)) << "Size of payload: " << read_buffer->length();
+
+  read_buffer->trimStart(transport_protocol_->transportHeaderLength());
+
+  if (data_aggregation_) {
+    rtc::AggrPktHeader hdr((uint8_t*)read_buffer->data());
+
+    for (uint8_t i = 0; i < hdr.getNumberOfPackets(); i++) {
+      std::unique_ptr<utils::MemBuf> segment = read_buffer->clone();
+
+      uint16_t pkt_start = 0;
+      uint16_t pkt_len = 0;
+      int res = hdr.getPacketOffsets(i, &pkt_start, &pkt_len);
+      if (res == -1) {
+        // this should not happen
+        break;
+      }
+
+      segment->trimStart(pkt_start);
+      segment->trimEnd(segment->length() - pkt_len);
+
+      Reassembly::read_buffer_ = std::move(segment);
+      Reassembly::notifyApplication();
+    }
+  } else {
+    Reassembly::read_buffer_ = std::move(read_buffer);
+    Reassembly::notifyApplication();
+  }
+}
+
+void RtcReassembly::reassemble(utils::MemBuf& buffer, uint32_t suffix) {
+  if (!is_setup_) {
+    is_setup_ = true;
+    reassembly_consumer_socket_->getSocketOption(
+        interface::RtcTransportOptions::AGGREGATED_DATA, data_aggregation_);
+  }
+
+  if (data_aggregation_) {
+    rtc::AggrPktHeader hdr((uint8_t*)buffer.data());
+
+    for (uint8_t i = 0; i < hdr.getNumberOfPackets(); i++) {
+      std::unique_ptr<utils::MemBuf> segment = buffer.clone();
+
+      uint16_t pkt_start = 0;
+      uint16_t pkt_len = 0;
+      int res = hdr.getPacketOffsets(i, &pkt_start, &pkt_len);
+      if (res == -1) {
+        // this should not happen
+        break;
+      }
+
+      segment->trimStart(pkt_start);
+      segment->trimEnd(segment->length() - pkt_len);
+
+      Reassembly::read_buffer_ = std::move(segment);
+      Reassembly::notifyApplication();
+    }
+
+  } else {
+    Reassembly::read_buffer_ = buffer.cloneOne();
+    Reassembly::notifyApplication();
+  }
+}
+
+}  // namespace rtc
+
+}  // namespace protocol
+
+}  // namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_reassembly.h b/libtransport/src/protocols/rtc/rtc_reassembly.h
index 15722a6d5..132004605 100644
--- a/libtransport/src/protocols/rtc/rtc_reassembly.h
+++ b/libtransport/src/protocols/rtc/rtc_reassembly.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -28,17 +28,14 @@ namespace rtc {
 class RtcReassembly : public DatagramReassembly {
  public:
   RtcReassembly(implementation::ConsumerSocket *icn_socket,
-                TransportProtocol *transport_protocol)
-      : DatagramReassembly(icn_socket, transport_protocol) {}
-
-  void reassemble(core::ContentObject &content_object) override {
-    auto read_buffer = content_object.getPayload();
-    DLOG_IF(INFO, VLOG_IS_ON(3))
-        << "Size of payload: " << read_buffer->length();
-    read_buffer->trimStart(transport_protocol_->transportHeaderLength());
-    Reassembly::read_buffer_ = std::move(read_buffer);
-    Reassembly::notifyApplication();
-  }
+                TransportProtocol *transport_protocol);
+
+  void reassemble(core::ContentObject &content_object) override;
+  void reassemble(utils::MemBuf &buffer, uint32_t suffix) override;
+
+ private:
+  bool is_setup_;
+  bool data_aggregation_;
 };
 
 }  // namespace rtc
diff --git a/libtransport/src/protocols/rtc/rtc_recovery_strategy.cc b/libtransport/src/protocols/rtc/rtc_recovery_strategy.cc
new file mode 100644
index 000000000..888105eab
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_recovery_strategy.cc
@@ -0,0 +1,418 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <glog/logging.h>
+#include <hicn/transport/interfaces/notification.h>
+#include <hicn/transport/interfaces/socket_options_keys.h>
+#include <protocols/rtc/rtc_consts.h>
+#include <protocols/rtc/rtc_recovery_strategy.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+using namespace transport::interface;
+
+RecoveryStrategy::RecoveryStrategy(
+    Indexer *indexer, SendRtxCallback &&callback, asio::io_service &io_service,
+    bool use_rtx, bool use_fec, interface::StrategyCallback *external_callback)
+    : recovery_on_(false),
+      next_rtx_timer_(MAX_TIMER_RTX),
+      send_rtx_callback_(std::move(callback)),
+      indexer_(indexer),
+      round_id_(0),
+      last_fec_used_(0),
+      callback_(external_callback) {
+  setRtxFec(use_rtx, use_fec);
+  timer_ = std::make_unique<asio::steady_timer>(io_service);
+}
+
+RecoveryStrategy::RecoveryStrategy(RecoveryStrategy &&rs)
+    : rtx_state_(std::move(rs.rtx_state_)),
+      rtx_timers_(std::move(rs.rtx_timers_)),
+      recover_with_fec_(std::move(rs.recover_with_fec_)),
+      timer_(std::move(rs.timer_)),
+      next_rtx_timer_(std::move(rs.next_rtx_timer_)),
+      send_rtx_callback_(std::move(rs.send_rtx_callback_)),
+      n_(std::move(rs.n_)),
+      k_(std::move(rs.k_)),
+      indexer_(std::move(rs.indexer_)),
+      state_(std::move(rs.state_)),
+      rc_(std::move(rs.rc_)),
+      round_id_(std::move(rs.round_id_)),
+      last_fec_used_(std::move(rs.last_fec_used_)),
+      callback_(rs.callback_) {
+  setFecParams(n_, k_);
+}
+
+RecoveryStrategy::~RecoveryStrategy() {}
+
+void RecoveryStrategy::setFecParams(uint32_t n, uint32_t k) {
+  n_ = n;
+  k_ = k;
+
+  // XXX for the moment we go in steps of 5% loss rate.
+  // max loss rate = 95%
+  for (uint32_t loss_rate = 5; loss_rate < 100; loss_rate += 5) {
+    double dec_loss_rate = (double)loss_rate / 100.0;
+    double exp_losses = (double)k_ * dec_loss_rate;
+    uint32_t fec_to_ask = ceil(exp_losses / (1 - dec_loss_rate));
+
+    fec_state_ f;
+    f.fec_to_ask = std::min(fec_to_ask, (n_ - k_));
+    f.last_update = round_id_;
+    f.avg_residual_losses = 0.0;
+    f.consecutive_use = 0;
+    fec_per_loss_rate_.push_back(f);
+  }
+}
+
+bool RecoveryStrategy::lossDetected(uint32_t seq) {
+  if (isRtx(seq)) {
+    // this packet is already in the list of rtx
+    return false;
+  }
+
+  auto it = recover_with_fec_.find(seq);
+  if (it != recover_with_fec_.end()) {
+    // this packet is already in list of packets to recover with fec
+    // this list contians also fec packets that will not be recovered with rtx
+    return false;
+  }
+
+  // new loss detected, recover it according to the strategy
+  newPacketLoss(seq);
+  return true;
+}
+
+void RecoveryStrategy::clear() {
+  rtx_state_.clear();
+  rtx_timers_.clear();
+  recover_with_fec_.clear();
+
+  if (next_rtx_timer_ != MAX_TIMER_RTX) {
+    next_rtx_timer_ = MAX_TIMER_RTX;
+    timer_->cancel();
+  }
+}
+
+// rtx functions
+void RecoveryStrategy::addNewRtx(uint32_t seq, bool force) {
+  if (!indexer_->isFec(seq) || force) {
+    // this packet needs to be re-transmitted
+    rtxState state;
+    state.first_send_ = state_->getInterestSentTime(seq);
+    if (state.first_send_ == 0)  // this interest was never sent before
+      state.first_send_ = getNow();
+    state.next_send_ = computeNextSend(seq, true);
+    state.rtx_count_ = 0;
+    DLOG_IF(INFO, VLOG_IS_ON(4))
+        << "Add " << seq << " to retransmissions. next rtx is in "
+        << state.next_send_ - getNow() << " ms";
+    rtx_state_.insert(std::pair<uint32_t, rtxState>(seq, state));
+    rtx_timers_.insert(std::pair<uint64_t, uint32_t>(state.next_send_, seq));
+
+    // if a new rtx is introduced, check the rtx timer
+    scheduleNextRtx();
+  } else {
+    // do not re-send fec packets but keep track of them
+    recover_with_fec_.insert(seq);
+    state_->onPossibleLossWithNoRtx(seq);
+  }
+}
+
+uint64_t RecoveryStrategy::computeNextSend(uint32_t seq, bool new_rtx) {
+  uint64_t now = getNow();
+  if (new_rtx) {
+    // for the new rtx we wait one estimated IAT after the loss detection. this
+    // is bacause, assuming that packets arrive with a constant IAT, we should
+    // get a new packet every IAT
+    double prod_rate = state_->getProducerRate();
+    uint32_t estimated_iat = SENTINEL_TIMER_INTERVAL;
+    uint32_t jitter = 0;
+
+    if (prod_rate != 0) {
+      double packet_size = state_->getAveragePacketSize();
+      estimated_iat = ceil(1000.0 / (prod_rate / packet_size));
+      jitter = ceil(state_->getJitter());
+    }
+
+    uint32_t wait = 1;
+    if (estimated_iat < 18) {
+      // for low rate app we do not wait to send a RTX
+      // we consider low rate stream with less than 50pps (iat >= 20ms)
+      // (e.g. audio in videoconf, mobile games).
+      // in the check we use 18ms to accomodate for measurements errors
+      // for flows with higher rate wait 1 ait + jitter
+      wait = estimated_iat + jitter;
+    }
+
+    DLOG_IF(INFO, VLOG_IS_ON(3))
+        << "first rtx for " << seq << " in " << wait
+        << " ms, rtt = " << state_->getMinRTT() << " ait = " << estimated_iat
+        << " jttr = " << jitter;
+
+    return now + wait;
+  } else {
+    // wait one RTT
+    uint32_t wait = SENTINEL_TIMER_INTERVAL;
+
+    double prod_rate = state_->getProducerRate();
+    if (prod_rate == 0) {
+      return now + SENTINEL_TIMER_INTERVAL;
+    }
+
+    double packet_size = state_->getAveragePacketSize();
+    uint32_t estimated_iat = ceil(1000.0 / (prod_rate / packet_size));
+
+    uint64_t rtt = state_->getMinRTT();
+    if (rtt == 0) rtt = SENTINEL_TIMER_INTERVAL;
+    wait = rtt;
+
+    uint32_t jitter = ceil(state_->getJitter());
+    wait += jitter;
+
+    // it may happen that the channel is congested and we have some additional
+    // queuing delay to take into account
+    uint32_t queue = ceil(state_->getQueuing());
+    wait += queue;
+
+    DLOG_IF(INFO, VLOG_IS_ON(3))
+        << "next rtx for " << seq << " in " << wait
+        << " ms, rtt = " << state_->getMinRTT() << " ait = " << estimated_iat
+        << " jttr = " << jitter << " queue = " << queue;
+
+    return now + wait;
+  }
+}
+
+void RecoveryStrategy::retransmit() {
+  if (rtx_timers_.size() == 0) return;
+
+  uint64_t now = getNow();
+
+  auto it = rtx_timers_.begin();
+  std::unordered_set<uint32_t> lost_pkt;
+  uint32_t sent_counter = 0;
+  while (it != rtx_timers_.end() && it->first <= now &&
+         sent_counter < MAX_RTX_IN_BATCH) {
+    uint32_t seq = it->second;
+    auto rtx_it =
+        rtx_state_.find(seq);  // this should always return a valid iter
+    if (rtx_it->second.rtx_count_ >= RTC_MAX_RTX ||
+        (now - rtx_it->second.first_send_) >= RTC_MAX_AGE ||
+        seq < state_->getLastSeqNacked()) {
+      // max rtx reached or packet too old or packet nacked, this packet is lost
+      DLOG_IF(INFO, VLOG_IS_ON(3))
+          << "packet " << seq << " lost because 1) max rtx: "
+          << (rtx_it->second.rtx_count_ >= RTC_MAX_RTX) << " 2) max age: "
+          << ((now - rtx_it->second.first_send_) >= RTC_MAX_AGE)
+          << " 3) nacked: " << (seq < state_->getLastSeqNacked());
+      lost_pkt.insert(seq);
+      it++;
+    } else {
+      // resend the packet
+      state_->onRetransmission(seq);
+      double prod_rate = state_->getProducerRate();
+      if (prod_rate != 0) rtx_it->second.rtx_count_++;
+      rtx_it->second.next_send_ = computeNextSend(seq, false);
+      it = rtx_timers_.erase(it);
+      rtx_timers_.insert(
+          std::pair<uint64_t, uint32_t>(rtx_it->second.next_send_, seq));
+      DLOG_IF(INFO, VLOG_IS_ON(3))
+          << "send rtx for sequence " << seq << ", next send in "
+          << (rtx_it->second.next_send_ - now);
+      send_rtx_callback_(seq);
+      sent_counter++;
+    }
+  }
+
+  // remove packets if needed
+  for (auto lost_it = lost_pkt.begin(); lost_it != lost_pkt.end(); lost_it++) {
+    uint32_t seq = *lost_it;
+    state_->onPacketLost(seq);
+    deleteRtx(seq);
+  }
+}
+
+void RecoveryStrategy::scheduleNextRtx() {
+  if (rtx_timers_.size() == 0) {
+    // all the rtx were removed, reset timer
+    next_rtx_timer_ = MAX_TIMER_RTX;
+    return;
+  }
+
+  // check if timer is alreay set
+  if (next_rtx_timer_ != MAX_TIMER_RTX) {
+    // a new check for rtx is already scheduled
+    if (next_rtx_timer_ > rtx_timers_.begin()->first) {
+      // we need to re-schedule it
+      timer_->cancel();
+    } else {
+      // wait for the next timer
+      return;
+    }
+  }
+
+  // set a new timer
+  next_rtx_timer_ = rtx_timers_.begin()->first;
+  uint64_t now = utils::SteadyTime::nowMs().count();
+  uint64_t wait = 1;
+  if (next_rtx_timer_ != MAX_TIMER_RTX && next_rtx_timer_ > now)
+    wait = next_rtx_timer_ - now;
+
+  std::weak_ptr<RecoveryStrategy> self(shared_from_this());
+  timer_->expires_from_now(std::chrono::milliseconds(wait));
+  timer_->async_wait([self](const std::error_code &ec) {
+    if (ec) return;
+    if (auto s = self.lock()) {
+      s->retransmit();
+      s->next_rtx_timer_ = MAX_TIMER_RTX;
+      s->scheduleNextRtx();
+    }
+  });
+}
+
+void RecoveryStrategy::deleteRtx(uint32_t seq) {
+  auto it_rtx = rtx_state_.find(seq);
+  if (it_rtx == rtx_state_.end()) return;  // rtx not found
+
+  // remove the rtx from the timers list
+  uint64_t ts = it_rtx->second.next_send_;
+  auto it_timers = rtx_timers_.find(ts);
+  while (it_timers != rtx_timers_.end() && it_timers->first == ts) {
+    if (it_timers->second == seq) {
+      rtx_timers_.erase(it_timers);
+      break;
+    }
+    it_timers++;
+  }
+  // remove rtx
+  rtx_state_.erase(it_rtx);
+}
+
+// fec functions
+uint32_t RecoveryStrategy::computeFecPacketsToAsk(bool in_sync) {
+  double loss_rate = state_->getMaxLossRate() * 100;  // use loss rate in %
+
+  if (loss_rate > 95) loss_rate = 95;  // max loss rate
+
+  if (loss_rate == 0) return 0;
+
+  // once per minute try to reduce the fec rate. it may happen that for some bin
+  // we ask too many fec packet. here we try to reduce this values gently
+  if (round_id_ % ROUNDS_PER_MIN == 0) {
+    reduceFec();
+  }
+
+  // keep track of the last used fec. if we use a new bin on this round reset
+  // consecutive use and avg loss in the prev bin
+  uint32_t bin = ceil(loss_rate / 5.0) - 1;
+  if (bin > fec_per_loss_rate_.size() - 1) bin = fec_per_loss_rate_.size() - 1;
+
+  if (bin != last_fec_used_) {
+    fec_per_loss_rate_[last_fec_used_].consecutive_use = 0;
+    fec_per_loss_rate_[last_fec_used_].avg_residual_losses = 0.0;
+  }
+  last_fec_used_ = bin;
+  fec_per_loss_rate_[last_fec_used_].consecutive_use++;
+
+  // we update the stats only once very 5 rounds (1sec) that is the rate at
+  // which we compute residual losses
+  if (round_id_ % ROUNDS_PER_SEC == 0) {
+    double residual_losses = state_->getResidualLossRate() * 100;
+    // update residual loss rate
+    fec_per_loss_rate_[bin].avg_residual_losses =
+        (fec_per_loss_rate_[bin].avg_residual_losses * MOVING_AVG_ALPHA) +
+        (1 - MOVING_AVG_ALPHA) * residual_losses;
+
+    if ((fec_per_loss_rate_[bin].last_update - round_id_) <
+        WAIT_BEFORE_FEC_UPDATE) {
+      // this bin is been updated recently so don't modify it  and
+      // return the current state
+      return fec_per_loss_rate_[bin].fec_to_ask;
+    }
+
+    // if the residual loss rate is too high and we can ask more fec packets and
+    // we are using this configuration since at least 5 sec update fec
+    if (fec_per_loss_rate_[bin].avg_residual_losses > MAX_RESIDUAL_LOSS_RATE &&
+        fec_per_loss_rate_[bin].fec_to_ask < (n_ - k_) &&
+        fec_per_loss_rate_[bin].consecutive_use > WAIT_BEFORE_FEC_UPDATE) {
+      // so increase the number of fec packets to ask
+      fec_per_loss_rate_[bin].fec_to_ask++;
+      fec_per_loss_rate_[bin].last_update = round_id_;
+      fec_per_loss_rate_[bin].avg_residual_losses = 0.0;
+    }
+  }
+
+  return fec_per_loss_rate_[bin].fec_to_ask;
+}
+
+void RecoveryStrategy::setRtxFec(std::optional<bool> rtx_on,
+                                 std::optional<bool> fec_on) {
+  if (rtx_on) rtx_on_ = *rtx_on;
+  if (fec_on) fec_on_ = *fec_on;
+
+  if (*callback_) {
+    notification::RecoveryStrategy strategy =
+        notification::RecoveryStrategy::RECOVERY_OFF;
+
+    if (rtx_on_ && fec_on_)
+      strategy = notification::RecoveryStrategy::RTX_AND_FEC;
+    else if (rtx_on_)
+      strategy = notification::RecoveryStrategy::RTX_ONLY;
+    else if (fec_on_)
+      strategy = notification::RecoveryStrategy::FEC_ONLY;
+
+    (*callback_)(strategy);
+  }
+}
+
+// common functions
+void RecoveryStrategy::onLostTimeout(uint32_t seq) { removePacketState(seq); }
+
+void RecoveryStrategy::removePacketState(uint32_t seq) {
+  auto it_fec = recover_with_fec_.find(seq);
+  if (it_fec != recover_with_fec_.end()) {
+    recover_with_fec_.erase(it_fec);
+    return;
+  }
+
+  deleteRtx(seq);
+}
+
+// private methods
+
+void RecoveryStrategy::reduceFec() {
+  for (uint32_t loss_rate = 5; loss_rate < 100; loss_rate += 5) {
+    double dec_loss_rate = (double)loss_rate / 100.0;
+    double exp_losses = (double)k_ * dec_loss_rate;
+    uint32_t fec_to_ask = ceil(exp_losses / (1 - dec_loss_rate));
+
+    uint32_t bin = ceil(loss_rate / 5.0) - 1;
+    if (fec_per_loss_rate_[bin].fec_to_ask > fec_to_ask) {
+      fec_per_loss_rate_[bin].fec_to_ask--;
+      // std::cout << "reduce fec to ask for bin " << bin << std::endl;
+    }
+  }
+}
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_recovery_strategy.h b/libtransport/src/protocols/rtc/rtc_recovery_strategy.h
new file mode 100644
index 000000000..9ffc69a1b
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_recovery_strategy.h
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <hicn/transport/interfaces/callbacks.h>
+#include <hicn/transport/utils/chrono_typedefs.h>
+#include <protocols/indexer.h>
+#include <protocols/rtc/rtc_rc.h>
+#include <protocols/rtc/rtc_state.h>
+
+#include <map>
+#include <unordered_map>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+class RecoveryStrategy : public std::enable_shared_from_this<RecoveryStrategy> {
+ protected:
+  struct rtx_state_ {
+    uint64_t first_send_;
+    uint64_t next_send_;
+    uint32_t rtx_count_;
+  };
+
+  using rtxState = struct rtx_state_;
+
+ public:
+  using SendRtxCallback = std::function<void(uint32_t)>;
+
+  RecoveryStrategy(Indexer *indexer, SendRtxCallback &&callback,
+                   asio::io_service &io_service, bool use_rtx, bool use_fec,
+                   interface::StrategyCallback *external_callback);
+
+  RecoveryStrategy(RecoveryStrategy &&rs);
+
+  virtual ~RecoveryStrategy();
+
+  void setRtxFec(std::optional<bool> rtx_on = {},
+                 std::optional<bool> fec_on = {});
+  void setState(RTCState *state) { state_ = state; }
+  void setRateControl(RTCRateControl *rateControl) { rc_ = rateControl; }
+  void setFecParams(uint32_t n, uint32_t k);
+
+  void tunrOnRecovery() { recovery_on_ = true; }
+
+  bool isRtx(uint32_t seq) {
+    if (rtx_state_.find(seq) != rtx_state_.end()) return true;
+    return false;
+  }
+
+  bool isPossibleLossWithNoRtx(uint32_t seq) {
+    if (recover_with_fec_.find(seq) != recover_with_fec_.end()) return true;
+    return false;
+  }
+
+  bool isRtxOn() { return rtx_on_; }
+
+  RTCState *getState() { return state_; }
+  bool lossDetected(uint32_t seq);
+  void clear();
+
+  virtual void onNewRound(bool in_sync) = 0;
+  virtual void newPacketLoss(uint32_t seq) = 0;
+  virtual void receivedPacket(uint32_t seq) = 0;
+  void onLostTimeout(uint32_t seq);
+
+  void incRoundId() { round_id_++; }
+
+  // utils
+  uint64_t getNow() {
+    uint64_t now = utils::SteadyTime::nowMs().count();
+    return now;
+  }
+
+ protected:
+  // rtx functions
+  void addNewRtx(uint32_t seq, bool force);
+  uint64_t computeNextSend(uint32_t seq, bool new_rtx);
+  void retransmit();
+  void scheduleNextRtx();
+  void deleteRtx(uint32_t seq);
+
+  // fec functions
+  uint32_t computeFecPacketsToAsk(bool in_sync);
+
+  // common functons
+  void removePacketState(uint32_t seq);
+
+  bool recovery_on_;
+  bool rtx_on_;
+  bool fec_on_;
+
+  // this map keeps track of the retransmitted interest, ordered from the oldest
+  // to the newest one. the state contains the timer of the first send of the
+  // interest (from pendingIntetests_), the timer of the next send (key of the
+  // multimap) and the number of rtx
+  std::map<uint32_t, rtxState> rtx_state_;
+  // this map stored the rtx by timer. The key is the time at which the rtx
+  // should be sent, and the val is the interest seq number
+  std::multimap<uint64_t, uint32_t> rtx_timers_;
+
+  // lost packets that will be recovered with fec
+  std::unordered_set<uint32_t> recover_with_fec_;
+
+  // rtx vars
+  std::unique_ptr<asio::steady_timer> timer_;
+  uint64_t next_rtx_timer_;
+  SendRtxCallback send_rtx_callback_;
+
+  // fec vars
+  uint32_t n_;
+  uint32_t k_;
+  Indexer *indexer_;
+
+  RTCState *state_;
+  RTCRateControl *rc_;
+
+ private:
+  struct fec_state_ {
+    uint32_t fec_to_ask;
+    uint32_t last_update;      // round id of the last update
+                               // (wait 10 ruonds (2sec) between updates)
+    uint32_t consecutive_use;  // consecutive ruonds where this fec was used
+    double avg_residual_losses;
+  };
+
+  void reduceFec();
+
+  uint32_t round_id_;  // number of rounds
+  uint32_t last_fec_used_;
+  std::vector<fec_state_> fec_per_loss_rate_;
+  interface::StrategyCallback *callback_;
+};
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rs_delay.cc b/libtransport/src/protocols/rtc/rtc_rs_delay.cc
new file mode 100644
index 000000000..e2c60ca77
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rs_delay.cc
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <glog/logging.h>
+#include <protocols/rtc/rtc_consts.h>
+#include <protocols/rtc/rtc_rs_delay.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+RecoveryStrategyDelayBased::RecoveryStrategyDelayBased(
+    Indexer *indexer, SendRtxCallback &&callback, asio::io_service &io_service,
+    interface::StrategyCallback *external_callback)
+    : RecoveryStrategy(indexer, std::move(callback), io_service, true, false,
+                       external_callback),  // start with rtx
+      congestion_state_(false),
+      probing_state_(false),
+      switch_rounds_(0) {}
+
+RecoveryStrategyDelayBased::RecoveryStrategyDelayBased(RecoveryStrategy &&rs)
+    : RecoveryStrategy(std::move(rs)) {
+  setRtxFec(true, false);
+  // we have to re-init congestion and
+  // probing
+  congestion_state_ = false;
+  probing_state_ = false;
+}
+
+RecoveryStrategyDelayBased::~RecoveryStrategyDelayBased() {}
+
+void RecoveryStrategyDelayBased::softSwitchToFec(uint32_t fec_to_ask) {
+  if (fec_to_ask == 0) {
+    setRtxFec(true, false);
+    switch_rounds_ = 0;
+  } else {
+    switch_rounds_++;
+    if (switch_rounds_ >= 5) {
+      setRtxFec(false, true);
+    } else {
+      setRtxFec({}, true);
+    }
+  }
+}
+
+void RecoveryStrategyDelayBased::onNewRound(bool in_sync) {
+  if (!recovery_on_) {
+    // disable fec so that no extra packet will be sent
+    // for rtx we check if recovery is on in newPacketLoss
+    setRtxFec(true, false);
+    indexer_->setNFec(0);
+    return;
+  }
+
+  uint64_t rtt = state_->getMinRTT();
+
+  bool congestion = false;
+  // XXX at the moment we are not looking at congestion events
+  // congestion = rc_->inCongestionState();
+
+  if ((!fec_on_ && rtt >= 100) || (fec_on_ && rtt > 80) || congestion) {
+    // switch from rtx to fec or keep use fec. Notice that if some rtx are
+    // waiting to be scheduled, they will be sent normally, but no new rtx will
+    // be created If the loss rate is 0 keep to use RTX.
+    uint32_t fec_to_ask = computeFecPacketsToAsk(in_sync);
+    softSwitchToFec(fec_to_ask);
+    indexer_->setNFec(fec_to_ask);
+    return;
+  }
+
+  if ((fec_on_ && rtt <= 80) || (!rtx_on_ && rtt <= 100)) {
+    // turn on rtx
+    softSwitchToFec(0);
+    indexer_->setNFec(0);
+    return;
+  }
+}
+
+void RecoveryStrategyDelayBased::newPacketLoss(uint32_t seq) {
+  if (rtx_on_ && recovery_on_) {
+    addNewRtx(seq, false);
+  } else {
+    if (!state_->isPending(seq) && !indexer_->isFec(seq)) {
+      addNewRtx(seq, true);
+    } else {
+      recover_with_fec_.insert(seq);
+      state_->onPossibleLossWithNoRtx(seq);
+    }
+  }
+}
+
+void RecoveryStrategyDelayBased::receivedPacket(uint32_t seq) {
+  removePacketState(seq);
+}
+
+void RecoveryStrategyDelayBased::probing() {
+  // TODO
+  // for the moment ask for all fec and exit the probing phase
+  probing_state_ = false;
+  setRtxFec(false, true);
+  indexer_->setNFec(computeFecPacketsToAsk(true));
+}
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rs_delay.h b/libtransport/src/protocols/rtc/rtc_rs_delay.h
new file mode 100644
index 000000000..0dd199965
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rs_delay.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <protocols/rtc/rtc_recovery_strategy.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+class RecoveryStrategyDelayBased : public RecoveryStrategy {
+ public:
+  RecoveryStrategyDelayBased(Indexer *indexer, SendRtxCallback &&callback,
+                             asio::io_service &io_service,
+                             interface::StrategyCallback *external_callback);
+
+  RecoveryStrategyDelayBased(RecoveryStrategy &&rs);
+
+  ~RecoveryStrategyDelayBased();
+
+  void onNewRound(bool in_sync);
+  void newPacketLoss(uint32_t seq);
+  void receivedPacket(uint32_t seq);
+
+ private:
+  void softSwitchToFec(uint32_t fec_to_ask);
+
+  bool congestion_state_;
+  bool probing_state_;
+  uint32_t switch_rounds_;
+
+  void probing();
+};
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rs_fec_only.cc b/libtransport/src/protocols/rtc/rtc_rs_fec_only.cc
new file mode 100644
index 000000000..36d8e39f0
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rs_fec_only.cc
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <glog/logging.h>
+#include <protocols/rtc/rtc_consts.h>
+#include <protocols/rtc/rtc_rs_fec_only.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+RecoveryStrategyFecOnly::RecoveryStrategyFecOnly(
+    Indexer *indexer, SendRtxCallback &&callback, asio::io_service &io_service,
+    interface::StrategyCallback *external_callback)
+    : RecoveryStrategy(indexer, std::move(callback), io_service, false, true,
+                       external_callback),
+      congestion_state_(false),
+      probing_state_(false),
+      switch_rounds_(0) {}
+
+RecoveryStrategyFecOnly::RecoveryStrategyFecOnly(RecoveryStrategy &&rs)
+    : RecoveryStrategy(std::move(rs)) {
+  setRtxFec(false, true);
+  congestion_state_ = false;
+  probing_state_ = false;
+}
+
+RecoveryStrategyFecOnly::~RecoveryStrategyFecOnly() {}
+
+void RecoveryStrategyFecOnly::onNewRound(bool in_sync) {
+  if (!recovery_on_) {
+    indexer_->setNFec(0);
+    return;
+  }
+
+  // XXX for the moment we are considering congestion events
+  // if(rc_->inCongestionState()){
+  //   congestion_state_ = true;
+  //   probing_state_ = false;
+  //   indexer_->setNFec(0);
+  //   return;
+  // }
+
+  // no congestion
+  if (congestion_state_) {
+    // this is the first round after congestion
+    // enter probing phase
+    probing_state_ = true;
+    congestion_state_ = false;
+  }
+
+  if (probing_state_) {
+    probing();
+  } else {
+    uint32_t fec_to_ask = computeFecPacketsToAsk(in_sync);
+    // If fec_to_ask == 0 we use rtx even if in these strategy we use only fec.
+    // In this way the first packet loss that triggers the usage of fec can be
+    // recovered using rtx, otherwise it will always be lost
+    if (fec_to_ask == 0) {
+      setRtxFec(true, false);
+      switch_rounds_ = 0;
+    } else {
+      switch_rounds_++;
+      if (switch_rounds_ >= 5) {
+        setRtxFec(false, true);
+      } else {
+        setRtxFec({}, true);
+      }
+    }
+    indexer_->setNFec(fec_to_ask);
+  }
+}
+
+void RecoveryStrategyFecOnly::newPacketLoss(uint32_t seq) {
+  if (rtx_on_ && recovery_on_) {
+    addNewRtx(seq, false);
+  } else {
+    if (!state_->isPending(seq) && !indexer_->isFec(seq)) {
+      addNewRtx(seq, true);
+    } else {
+      // if not pending add rtc
+      recover_with_fec_.insert(seq);
+      state_->onPossibleLossWithNoRtx(seq);
+    }
+  }
+}
+
+void RecoveryStrategyFecOnly::receivedPacket(uint32_t seq) {
+  removePacketState(seq);
+}
+
+void RecoveryStrategyFecOnly::probing() {
+  // TODO
+  // for the moment ask for all fec and exit the probing phase
+  probing_state_ = false;
+  uint32_t fec_to_ask = computeFecPacketsToAsk(true);
+  indexer_->setNFec(fec_to_ask);
+}
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rs_fec_only.h b/libtransport/src/protocols/rtc/rtc_rs_fec_only.h
new file mode 100644
index 000000000..37b505d35
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rs_fec_only.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <protocols/rtc/rtc_recovery_strategy.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+class RecoveryStrategyFecOnly : public RecoveryStrategy {
+ public:
+  RecoveryStrategyFecOnly(Indexer *indexer, SendRtxCallback &&callback,
+                          asio::io_service &io_service,
+                          interface::StrategyCallback *external_callback);
+
+  RecoveryStrategyFecOnly(RecoveryStrategy &&rs);
+
+  ~RecoveryStrategyFecOnly();
+
+  void onNewRound(bool in_sync);
+  void newPacketLoss(uint32_t seq);
+  void receivedPacket(uint32_t seq);
+
+ private:
+  bool congestion_state_;
+  bool probing_state_;
+  uint32_t switch_rounds_;
+
+  void probing();
+};
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rs_low_rate.cc b/libtransport/src/protocols/rtc/rtc_rs_low_rate.cc
new file mode 100644
index 000000000..bd153d209
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rs_low_rate.cc
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <glog/logging.h>
+#include <protocols/rtc/rtc_consts.h>
+#include <protocols/rtc/rtc_rs_low_rate.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+RecoveryStrategyLowRate::RecoveryStrategyLowRate(
+    Indexer *indexer, SendRtxCallback &&callback, asio::io_service &io_service,
+    interface::StrategyCallback *external_callback)
+    : RecoveryStrategy(indexer, std::move(callback), io_service, false, true,
+                       external_callback),  // start with fec
+      fec_consecutive_rounds_((MILLI_IN_A_SEC / ROUND_LEN) * 5),  // 5 sec
+      rtx_allowed_consecutive_rounds_(0) {
+  initSwitchVector();
+}
+
+RecoveryStrategyLowRate::RecoveryStrategyLowRate(RecoveryStrategy &&rs)
+    : RecoveryStrategy(std::move(rs)),
+      fec_consecutive_rounds_((MILLI_IN_A_SEC / ROUND_LEN) * 5),  // 5 sec
+      rtx_allowed_consecutive_rounds_(0) {
+  setRtxFec(false, true);
+  initSwitchVector();
+}
+
+RecoveryStrategyLowRate::~RecoveryStrategyLowRate() {}
+
+void RecoveryStrategyLowRate::initSwitchVector() {
+  // TODO adjust thresholds here when new data are collected
+  // see resutls in
+  // https://confluence-eng-gpk1.cisco.com/conf/display/SPT/dailyreports
+  thresholds_t t1;
+  t1.rtt = 15;              // 15ms
+  t1.loss_rtx_to_fec = 15;  // 15%
+  t1.loss_fec_to_rtx = 10;  // 10%
+  thresholds_t t2;
+  t2.rtt = 35;             // 35ms
+  t2.loss_rtx_to_fec = 5;  // 5%
+  t2.loss_fec_to_rtx = 1;  // 1%
+  switch_vector.push_back(t1);
+  switch_vector.push_back(t2);
+}
+
+void RecoveryStrategyLowRate::setRecoveryParameters(bool use_rtx, bool use_fec,
+                                                    uint32_t fec_to_ask) {
+  setRtxFec(use_rtx, use_fec);
+  indexer_->setNFec(fec_to_ask);
+}
+
+void RecoveryStrategyLowRate::selectRecoveryStrategy(bool in_sync) {
+  uint32_t fec_to_ask = computeFecPacketsToAsk(in_sync);
+  if (fec_to_ask == 0) {
+    // fec is off, turn on RTX immediatly to avoid packet losses
+    setRecoveryParameters(true, false, 0);
+    fec_consecutive_rounds_ = 0;
+    return;
+  }
+
+  uint32_t loss_rate = std::round(state_->getPerSecondLossRate() * 100);
+  uint32_t rtt = state_->getAvgRTT();
+
+  bool use_rtx = false;
+  for (size_t i = 0; i < switch_vector.size(); i++) {
+    uint32_t max_loss_rate = 0;
+    if (fec_on_)
+      max_loss_rate = switch_vector[i].loss_fec_to_rtx;
+    else
+      max_loss_rate = switch_vector[i].loss_rtx_to_fec;
+
+    if (rtt < switch_vector[i].rtt && loss_rate < max_loss_rate) {
+      use_rtx = true;
+      rtx_allowed_consecutive_rounds_++;
+      break;
+    }
+  }
+
+  if (!use_rtx) rtx_allowed_consecutive_rounds_ = 0;
+
+  if (use_rtx) {
+    if (fec_on_) {
+      // here we should swtich from RTX to FEC
+      // wait 10sec where the switch is allowed before actually switch
+      if (rtx_allowed_consecutive_rounds_ >=
+          ((MILLI_IN_A_SEC / ROUND_LEN) * 10)) {  // 10 sec
+        // use RTX
+        setRecoveryParameters(true, false, 0);
+        fec_consecutive_rounds_ = 0;
+      } else {
+        // keep using FEC (and maybe RTX)
+        setRecoveryParameters(true, true, fec_to_ask);
+        fec_consecutive_rounds_++;
+      }
+    } else {
+      // keep using RTX
+      setRecoveryParameters(true, false, 0);
+      fec_consecutive_rounds_ = 0;
+    }
+  } else {
+    // use FEC and RTX
+    setRecoveryParameters(true, true, fec_to_ask);
+    fec_consecutive_rounds_++;
+  }
+
+  // everytime that we anable FEC we keep also RTX on. in this way the first
+  // losses that are not covered by FEC are recovered using RTX. after 5 sec we
+  // disable fec
+  if (fec_consecutive_rounds_ >= ((MILLI_IN_A_SEC / ROUND_LEN) * 5)) {
+    // turn off RTX
+    setRtxFec(false);
+  }
+}
+
+void RecoveryStrategyLowRate::onNewRound(bool in_sync) {
+  if (!recovery_on_) {
+    // disable fec so that no extra packet will be sent
+    // for rtx we check if recovery is on in newPacketLoss
+    setRtxFec(true, false);
+    indexer_->setNFec(0);
+    return;
+  }
+
+  // XXX since this strategy will be used only for flow at low rate we do not
+  // consider congestion events like in other strategies
+
+  selectRecoveryStrategy(in_sync);
+}
+
+void RecoveryStrategyLowRate::newPacketLoss(uint32_t seq) {
+  if (rtx_on_ && recovery_on_) {
+    addNewRtx(seq, false);
+  } else {
+    if (!state_->isPending(seq) && !indexer_->isFec(seq)) {
+      addNewRtx(seq, true);
+    } else {
+      recover_with_fec_.insert(seq);
+      state_->onPossibleLossWithNoRtx(seq);
+    }
+  }
+}
+
+void RecoveryStrategyLowRate::receivedPacket(uint32_t seq) {
+  removePacketState(seq);
+}
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rs_low_rate.h b/libtransport/src/protocols/rtc/rtc_rs_low_rate.h
new file mode 100644
index 000000000..f0c7bd0d5
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rs_low_rate.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <protocols/rtc/rtc_recovery_strategy.h>
+
+#include <vector>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+struct thresholds_t {
+  uint32_t rtt;
+  uint32_t loss_rtx_to_fec;  // loss rate used to move from rtx to fec
+  uint32_t loss_fec_to_rtx;  // loss rate used to move from fec to rtx
+};
+
+class RecoveryStrategyLowRate : public RecoveryStrategy {
+ public:
+  RecoveryStrategyLowRate(Indexer *indexer, SendRtxCallback &&callback,
+                          asio::io_service &io_service,
+                          interface::StrategyCallback *external_callback);
+
+  RecoveryStrategyLowRate(RecoveryStrategy &&rs);
+
+  ~RecoveryStrategyLowRate();
+
+  void onNewRound(bool in_sync);
+  void newPacketLoss(uint32_t seq);
+  void receivedPacket(uint32_t seq);
+
+ private:
+  void initSwitchVector();
+  void setRecoveryParameters(bool use_rtx, bool use_fec, uint32_t fec_to_ask);
+  void selectRecoveryStrategy(bool in_sync);
+
+  uint32_t fec_consecutive_rounds_;
+  uint32_t rtx_allowed_consecutive_rounds_;
+
+  // this table contains the thresholds that indicates when to switch from RTX
+  // to FEC and viceversa. values in the vector are detected with a set of
+  // experiments. the vector is used in the following way: if rtt and loss rate
+  // are less than one of the values in the in the vector, losses are
+  // recovered using RTX. otherwive losses are recovered using FEC. as for FEC
+  // only and delay based strategy, the swith from RTX to FEC is smooth,
+  // meaning that FEC and RTX are used together for some rounds
+  std::vector<thresholds_t> switch_vector;
+};
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rs_recovery_off.cc b/libtransport/src/protocols/rtc/rtc_rs_recovery_off.cc
new file mode 100644
index 000000000..499e978f1
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rs_recovery_off.cc
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <glog/logging.h>
+#include <protocols/rtc/rtc_consts.h>
+#include <protocols/rtc/rtc_rs_recovery_off.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+RecoveryStrategyRecoveryOff::RecoveryStrategyRecoveryOff(
+    Indexer *indexer, SendRtxCallback &&callback, asio::io_service &io_service,
+    interface::StrategyCallback *external_callback)
+    : RecoveryStrategy(indexer, std::move(callback), io_service, false, false,
+                       external_callback) {}
+
+RecoveryStrategyRecoveryOff::RecoveryStrategyRecoveryOff(RecoveryStrategy &&rs)
+    : RecoveryStrategy(std::move(rs)) {
+  setRtxFec(false, false);
+}
+
+RecoveryStrategyRecoveryOff::~RecoveryStrategyRecoveryOff() {}
+
+void RecoveryStrategyRecoveryOff::onNewRound(bool in_sync) {
+  // nothing to do
+  return;
+}
+
+void RecoveryStrategyRecoveryOff::newPacketLoss(uint32_t seq) {
+  // here we only keep track of the lost packets to avoid to
+  // count them multple times in the counters. for this we
+  // use the recover_with_fec_ set
+  recover_with_fec_.insert(seq);
+  state_->onPossibleLossWithNoRtx(seq);
+}
+
+void RecoveryStrategyRecoveryOff::receivedPacket(uint32_t seq) {
+  removePacketState(seq);
+}
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rs_recovery_off.h b/libtransport/src/protocols/rtc/rtc_rs_recovery_off.h
new file mode 100644
index 000000000..98cd1e6a5
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rs_recovery_off.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <protocols/rtc/rtc_recovery_strategy.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+class RecoveryStrategyRecoveryOff : public RecoveryStrategy {
+ public:
+  RecoveryStrategyRecoveryOff(Indexer *indexer, SendRtxCallback &&callback,
+                              asio::io_service &io_service,
+                              interface::StrategyCallback *external_callback);
+
+  RecoveryStrategyRecoveryOff(RecoveryStrategy &&rs);
+
+  ~RecoveryStrategyRecoveryOff();
+
+  void onNewRound(bool in_sync);
+  void newPacketLoss(uint32_t seq);
+  void receivedPacket(uint32_t seq);
+};
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rs_rtx_only.cc b/libtransport/src/protocols/rtc/rtc_rs_rtx_only.cc
new file mode 100644
index 000000000..c1ae9b53d
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rs_rtx_only.cc
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <glog/logging.h>
+#include <protocols/rtc/rtc_consts.h>
+#include <protocols/rtc/rtc_rs_rtx_only.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+RecoveryStrategyRtxOnly::RecoveryStrategyRtxOnly(
+    Indexer *indexer, SendRtxCallback &&callback, asio::io_service &io_service,
+    interface::StrategyCallback *external_callback)
+    : RecoveryStrategy(indexer, std::move(callback), io_service, true, false,
+                       external_callback) {}
+
+RecoveryStrategyRtxOnly::RecoveryStrategyRtxOnly(RecoveryStrategy &&rs)
+    : RecoveryStrategy(std::move(rs)) {
+  setRtxFec(true, false);
+}
+
+RecoveryStrategyRtxOnly::~RecoveryStrategyRtxOnly() {}
+
+void RecoveryStrategyRtxOnly::onNewRound(bool in_sync) {
+  // nothing to do
+  return;
+}
+
+void RecoveryStrategyRtxOnly::newPacketLoss(uint32_t seq) {
+  if (!recovery_on_) {
+    recover_with_fec_.insert(seq);
+    state_->onPossibleLossWithNoRtx(seq);
+    return;
+  }
+  addNewRtx(seq, false);
+}
+
+void RecoveryStrategyRtxOnly::receivedPacket(uint32_t seq) {
+  removePacketState(seq);
+}
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_rs_rtx_only.h b/libtransport/src/protocols/rtc/rtc_rs_rtx_only.h
new file mode 100644
index 000000000..7ae909454
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_rs_rtx_only.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include <protocols/rtc/rtc_recovery_strategy.h>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+class RecoveryStrategyRtxOnly : public RecoveryStrategy {
+ public:
+  RecoveryStrategyRtxOnly(Indexer *indexer, SendRtxCallback &&callback,
+                          asio::io_service &io_service,
+                          interface::StrategyCallback *external_callback);
+
+  RecoveryStrategyRtxOnly(RecoveryStrategy &&rs);
+
+  ~RecoveryStrategyRtxOnly();
+
+  void onNewRound(bool in_sync);
+  void newPacketLoss(uint32_t seq);
+  void receivedPacket(uint32_t seq);
+};
+
+}  // end namespace rtc
+
+}  // end namespace protocol
+
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_state.cc b/libtransport/src/protocols/rtc/rtc_state.cc
index c99205a26..6a21531f8 100644
--- a/libtransport/src/protocols/rtc/rtc_state.cc
+++ b/libtransport/src/protocols/rtc/rtc_state.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -24,15 +24,15 @@ namespace protocol {
 namespace rtc {
 
 RTCState::RTCState(Indexer *indexer,
-                   ProbeHandler::SendProbeCallback &&rtt_probes_callback,
+                   ProbeHandler::SendProbeCallback &&probe_callback,
                    DiscoveredRttCallback &&discovered_rtt_callback,
                    asio::io_service &io_service)
-    : indexer_(indexer),
-      rtt_probes_(std::make_shared<ProbeHandler>(std::move(rtt_probes_callback),
-                                                 io_service)),
+    : loss_history_(10),  // log 10sec history
+      indexer_(indexer),
+      probe_handler_(std::make_shared<ProbeHandler>(std::move(probe_callback),
+                                                    io_service)),
       discovered_rtt_callback_(std::move(discovered_rtt_callback)) {
   init_rtt_timer_ = std::make_unique<asio::steady_timer>(io_service);
-  initParams();
 }
 
 RTCState::~RTCState() {}
@@ -55,9 +55,19 @@ void RTCState::initParams() {
   highest_seq_received_in_order_ = 0;
   last_seq_nacked_ = 0;
   loss_rate_ = 0.0;
-  avg_loss_rate_ = 0.0;
+  avg_loss_rate_ = -1.0;
   max_loss_rate_ = 0.0;
   last_round_loss_rate_ = 0.0;
+
+  // loss rate per sec
+  lost_per_sec_ = 0;
+  total_expected_packets_ = 0;
+  per_sec_loss_rate_ = 0.0;
+
+  // residual losses counters
+  expected_packets_ = 0;
+  packets_sent_to_app_ = 0;
+  rounds_from_last_compute_ = 0;
   residual_loss_rate_ = 0.0;
 
   // fec counters
@@ -66,9 +76,13 @@ void RTCState::initParams() {
 
   // bw counters
   received_bytes_ = 0;
+  received_fec_bytes_ = 0;
+  recovered_bytes_with_fec_ = 0;
+
   avg_packet_size_ = INIT_PACKET_SIZE;
   production_rate_ = 0.0;
   received_rate_ = 0.0;
+  fec_recovered_rate_ = 0.0;
 
   // nack counter
   nack_on_last_round_ = false;
@@ -95,31 +109,30 @@ void RTCState::initParams() {
   path_table_.clear();
   main_path_ = nullptr;
 
-  // packet received
-  received_or_lost_packets_.clear();
+  // packet cache (not pending anymore)
+  packet_cache_.clear();
 
   // pending interests
   pending_interests_.clear();
 
-  // skipped interest
+  // used to keep track of the skipped interest
   last_interest_sent_ = 0;
-  skipped_interests_.clear();
 
   // init rtt
   first_interest_sent_time_ = ~0;
   first_interest_sent_seq_ = 0;
 
+  // start probing the producer
   init_rtt_ = false;
-  rtt_probes_->setProbes(INIT_RTT_PROBE_INTERVAL, INIT_RTT_PROBES);
-  rtt_probes_->sendProbes();
+  probe_handler_->setSuffixRange(MIN_INIT_PROBE_SEQ, MAX_INIT_PROBE_SEQ);
+  probe_handler_->setProbes(INIT_RTT_PROBE_INTERVAL, INIT_RTT_PROBES);
+  probe_handler_->sendProbes();
   setInitRttTimer(INIT_RTT_PROBE_RESTART);
 }
 
 // packet events
 void RTCState::onSendNewInterest(const core::Name *interest_name) {
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
+  uint64_t now = utils::SteadyTime::nowMs().count();
   uint32_t seq = interest_name->getSuffix();
   pending_interests_.insert(std::pair<uint32_t, uint64_t>(seq, now));
 
@@ -137,11 +150,12 @@ void RTCState::onSendNewInterest(const core::Name *interest_name) {
   }
 
   // TODO what happen in case of jumps?
-  // look for skipped interests
-  skipped_interests_.erase(seq);  // remove seq if it is there
+  eraseFromPacketCache(
+      seq);  // if we send this interest we don't know its state
   for (uint32_t i = last_interest_sent_ + 1; i < seq; i++) {
     if (indexer_->isFec(i)) {
-      skipped_interests_.insert(i);
+      // only fec packets can be skipped
+      addToPacketCache(i, PacketState::SKIPPED);
     }
   }
 
@@ -155,6 +169,7 @@ void RTCState::onTimeout(uint32_t seq, bool lost) {
   auto it = pending_interests_.find(seq);
   if (it != pending_interests_.end()) {
     pending_interests_.erase(it);
+    if (indexer_->isFec(seq)) pending_fec_pkt_--;
   }
   received_timeouts_++;
 
@@ -162,11 +177,12 @@ void RTCState::onTimeout(uint32_t seq, bool lost) {
 }
 
 void RTCState::onLossDetected(uint32_t seq) {
-  if (!indexer_->isFec(seq)) {
-    packets_lost_++;
-  } else if (skipped_interests_.find(seq) == skipped_interests_.end() &&
-             seq >= first_interest_sent_seq_) {
+  PacketState state = getPacketState(seq);
+
+  // if the packet is already marked with a state, do nothing
+  if (state == PacketState::UNKNOWN) {
     packets_lost_++;
+    addToPacketCache(seq, PacketState::LOST);
   }
 }
 
@@ -178,30 +194,40 @@ void RTCState::onRetransmission(uint32_t seq) {
   auto it = pending_interests_.find(seq);
   if (it != pending_interests_.end()) {
     pending_interests_.erase(it);
-#if 0
-    packets_lost_++;
-#endif
+    if (indexer_->isFec(seq)) pending_fec_pkt_--;
   }
   sent_rtx_++;
   sent_rtx_last_round_++;
 }
 
+void RTCState::onPossibleLossWithNoRtx(uint32_t seq) {
+  // if fec is on or rtx is disable we don't need to do anything to recover a
+  // packet. however in both cases we need to remove possible missing packets
+  // from the window of pendinig interest in order to free space without wating
+  // for the timeout.
+  auto it = pending_interests_.find(seq);
+  if (it != pending_interests_.end()) {
+    pending_interests_.erase(it);
+    if (indexer_->isFec(seq)) pending_fec_pkt_--;
+  }
+}
+
 void RTCState::onDataPacketReceived(const core::ContentObject &content_object,
                                     bool compute_stats) {
   uint32_t seq = content_object.getName().getSuffix();
+
   if (compute_stats) {
     updatePathStats(content_object, false);
     received_data_last_round_++;
   }
   received_data_++;
+  packets_sent_to_app_++;
 
-  struct data_packet_t *data_pkt =
-      (struct data_packet_t *)content_object.getPayload()->data();
-  uint64_t production_time = data_pkt->getTimestamp();
-  if (last_prod_update_ < production_time) {
-    last_prod_update_ = production_time;
-    uint32_t production_rate = data_pkt->getProductionRate();
-    production_rate_ = (double)production_rate;
+  core::ParamsRTC params = RTCState::getDataParams(content_object);
+
+  if (last_prod_update_ < params.timestamp) {
+    last_prod_update_ = params.timestamp;
+    production_rate_ = (double)params.prod_rate;
   }
 
   updatePacketSize(content_object);
@@ -219,9 +245,18 @@ void RTCState::onDataPacketReceived(const core::ContentObject &content_object,
 
 void RTCState::onFecPacketReceived(const core::ContentObject &content_object) {
   uint32_t seq = content_object.getName().getSuffix();
-  updateReceivedBytes(content_object);
+  // updateReceivedBytes(content_object);
+  received_fec_bytes_ +=
+      (uint32_t)(content_object.headerSize() + content_object.payloadSize());
+
+  if (seq > highest_seq_received_) highest_seq_received_ = seq;
+
+  PacketState state = getPacketState(seq);
+  if (state != PacketState::LOST) {
+    // increase only for not lost packets
+    received_fec_pkt_++;
+  }
   addRecvOrLost(seq, PacketState::RECEIVED);
-  received_fec_pkt_++;
   // the producer is responding
   // it is generating valid data packets so we consider it active
   producer_is_active_ = true;
@@ -233,7 +268,7 @@ void RTCState::onNackPacketReceived(const core::ContentObject &nack,
   struct nack_packet_t *nack_pkt =
       (struct nack_packet_t *)nack.getPayload()->data();
   uint64_t production_time = nack_pkt->getTimestamp();
-  uint32_t production_seq = nack_pkt->getProductionSegement();
+  uint32_t production_seq = nack_pkt->getProductionSegment();
   uint32_t production_rate = nack_pkt->getProductionRate();
 
   if (TRANSPORT_EXPECT_FALSE(main_path_ == nullptr) ||
@@ -255,6 +290,7 @@ void RTCState::onNackPacketReceived(const core::ContentObject &nack,
   received_nacks_++;
   received_nacks_last_round_++;
 
+  bool to_delete = false;
   if (production_seq > seq) {
     // old nack, seq is lost
     // update last nacked
@@ -266,12 +302,19 @@ void RTCState::onNackPacketReceived(const core::ContentObject &nack,
     // future nack
     // remove the nack from the pending interest map
     // (the packet is not received/lost yet)
-    if (indexer_->isFec(seq)) pending_fec_pkt_--;
-    pending_interests_.erase(seq);
+    to_delete = true;
   } else {
     // this should be a quite rear event. simply remove the
     // packet from the pending interest list
-    pending_interests_.erase(seq);
+    to_delete = true;
+  }
+
+  if (to_delete) {
+    auto it = pending_interests_.find(seq);
+    if (it != pending_interests_.end()) {
+      pending_interests_.erase(it);
+      if (indexer_->isFec(seq)) pending_fec_pkt_--;
+    }
   }
 
   // the producer is responding
@@ -295,44 +338,58 @@ void RTCState::onPacketLost(uint32_t seq) {
   }
 #endif
   if (!indexer_->isFec(seq)) {
-    definitely_lost_pkt_++;
-    DLOG_IF(INFO, VLOG_IS_ON(4)) << "packet " << seq << " is lost";
+    PacketState state = getPacketState(seq);
+    if (state == PacketState::LOST || state == PacketState::UNKNOWN) {
+      definitely_lost_pkt_++;
+      DLOG_IF(INFO, VLOG_IS_ON(4)) << "packet " << seq << " is lost";
+    }
   }
-  addRecvOrLost(seq, PacketState::LOST);
+  addRecvOrLost(seq, PacketState::DEFINITELY_LOST);
 }
 
 void RTCState::onPacketRecoveredRtx(uint32_t seq) {
+  packets_sent_to_app_++;
+  if (seq > highest_seq_received_) highest_seq_received_ = seq;
   losses_recovered_++;
   addRecvOrLost(seq, PacketState::RECEIVED);
 }
 
-void RTCState::onPacketRecoveredFec(uint32_t seq) {
+void RTCState::onFecPacketRecoveredRtx(uint32_t seq) {
+  // This is the same as onPacketRecoveredRtx, but in this is case the
+  // pkt is also a FEC pkt, the addRecvOrLost will be called afterwards
+  if (seq > highest_seq_received_) highest_seq_received_ = seq;
+  losses_recovered_++;
+}
+
+void RTCState::onPacketRecoveredFec(uint32_t seq, uint32_t size) {
   losses_recovered_++;
+  packets_sent_to_app_++;
+  recovered_bytes_with_fec_ += size;
+
+  if (seq > highest_seq_received_) highest_seq_received_ = seq;
+
+  // adding header to the count
+  recovered_bytes_with_fec_ += 60;  // XXX get header size some where
+
+  if (getPacketState(seq) == PacketState::UNKNOWN)
+    onLossDetected(seq);  // the pkt was lost but didn't account for it yet
+
   addRecvOrLost(seq, PacketState::RECEIVED);
 }
 
 bool RTCState::onProbePacketReceived(const core::ContentObject &probe) {
   uint32_t seq = probe.getName().getSuffix();
-  uint64_t rtt;
-
-  rtt = rtt_probes_->getRtt(seq);
 
+  uint64_t rtt;
+  rtt = probe_handler_->getRtt(seq);
   if (rtt == 0) return false;  // this is not a valid probe
 
-  // like for data and nacks update the path stats. Here the RTT is computed
-  // by the probe handler. Both probes for rtt and bw are good to esimate
-  // info on the path
+  // Like for data and nacks update the path stats. Here the RTT is computed
+  // by the probe handler. Both probes for rtt and bw are good to estimate
+  // info on the path.
   uint32_t path_label = probe.getPathLabel();
-
   auto path_it = path_table_.find(path_label);
 
-  // update production rate and last_seq_nacked like in case of a nack
-  struct nack_packet_t *probe_pkt =
-      (struct nack_packet_t *)probe.getPayload()->data();
-  uint64_t sender_timestamp = probe_pkt->getTimestamp();
-  uint32_t production_seq = probe_pkt->getProductionSegement();
-  uint32_t production_rate = probe_pkt->getProductionRate();
-
   if (path_it == path_table_.end()) {
     // found a new path
     std::shared_ptr<RTCDataPath> newPath =
@@ -344,26 +401,26 @@ bool RTCState::onProbePacketReceived(const core::ContentObject &probe) {
 
   auto path = path_it->second;
 
-  path->insertRttSample(rtt);
+  path->insertRttSample(utils::SteadyTime::Milliseconds(rtt), true);
   path->receivedNack();
 
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
+  uint64_t now = utils::SteadyTime::nowMs().count();
+
+  core::ParamsRTC params = RTCState::getProbeParams(probe);
 
-  int64_t OWD = now - sender_timestamp;
+  int64_t OWD = now - params.timestamp;
   path->insertOwdSample(OWD);
 
-  if (last_prod_update_ < sender_timestamp) {
-    last_production_seq_ = production_seq;
-    last_prod_update_ = sender_timestamp;
-    production_rate_ = (double)production_rate;
+  if (last_prod_update_ < params.timestamp) {
+    last_production_seq_ = params.prod_seg;
+    last_prod_update_ = params.timestamp;
+    production_rate_ = (double)params.prod_rate;
   }
 
   // the producer is responding
   // we consider it active only if the production rate is not 0
   // or the production sequence numner is not 1
-  if (production_rate_ != 0 || production_seq != 1) {
+  if (production_rate_ != 0 || params.prod_seg != 1) {
     producer_is_active_ = true;
   }
 
@@ -375,7 +432,7 @@ bool RTCState::onProbePacketReceived(const core::ContentObject &probe) {
   if (!init_rtt_ && received_probes_ <= INIT_RTT_PROBES) {
     if (received_probes_ == 1) {
       // we got the first probe, wait at most INIT_RTT_PROBE_WAIT sec for the
-      // others
+      // others.
       main_path_ = path;
       setInitRttTimer(INIT_RTT_PROBE_WAIT);
     }
@@ -393,11 +450,21 @@ bool RTCState::onProbePacketReceived(const core::ContentObject &probe) {
   return true;
 }
 
-void RTCState::onNewRound(double round_len, bool in_sync) {
-  // XXX
-  // here we take into account only the single path case so we assume that we
-  // don't use two paths in parellel for this single flow
+void RTCState::onJumpForward(uint32_t next_seq) {
+  for (uint32_t seq = highest_seq_received_in_order_ + 1; seq < next_seq;
+       seq++) {
+    auto it = pending_interests_.find(seq);
+    PacketState packet_state = getPacketState(seq);
+    if (it == pending_interests_.end() &&
+        packet_state != PacketState::RECEIVED &&
+        packet_state != PacketState::DEFINITELY_LOST) {
+      onLossDetected(seq);
+      onPacketLost(seq);
+    }
+  }
+}
 
+void RTCState::onNewRound(double round_len, bool in_sync) {
   if (path_table_.empty()) return;
 
   double bytes_per_sec =
@@ -407,7 +474,24 @@ void RTCState::onNewRound(double round_len, bool in_sync) {
   else
     received_rate_ = (received_rate_ * MOVING_AVG_ALPHA) +
                      ((1 - MOVING_AVG_ALPHA) * bytes_per_sec);
+  double fec_bytes_per_sec =
+      ((double)received_fec_bytes_ * (MILLI_IN_A_SEC / round_len));
+
+  if (fec_received_rate_ == 0)
+    fec_received_rate_ = fec_bytes_per_sec;
+  else
+    fec_received_rate_ = (fec_received_rate_ * 0.8) + (0.2 * fec_bytes_per_sec);
+
+  double fec_recovered_bytes_per_sec =
+      ((double)recovered_bytes_with_fec_ * (MILLI_IN_A_SEC / round_len));
 
+  if (fec_recovered_rate_ == 0)
+    fec_recovered_rate_ = fec_recovered_bytes_per_sec;
+  else
+    fec_recovered_rate_ =
+        (fec_recovered_rate_ * 0.8) + (0.2 * fec_recovered_bytes_per_sec);
+
+#if 0
   // search for an active path. There should be only one active path (meaning a
   // path that leads to the producer socket -no cache- and from which we are
   // currently getting data packets) at any time. However it may happen that
@@ -428,9 +512,36 @@ void RTCState::onNewRound(double round_len, bool in_sync) {
       }
     }
   }
+#endif
+
+  // search for an active path. Is it possible to have multiple path that are
+  // used at the same time. We use as reference path the one from where we gets
+  // more packets. This means that the path should have better lantecy or less
+  // channel losses
+
+  uint32_t last_round_packets = 0;
+  std::shared_ptr<RTCDataPath> old_main_path = main_path_;
+  main_path_ = nullptr;
+
+  for (auto it = path_table_.begin(); it != path_table_.end(); it++) {
+    if (it->second->isActive()) {
+      uint32_t pkt = it->second->getPacketsLastRound();
+      if (pkt > last_round_packets) {
+        last_round_packets = pkt;
+        main_path_ = it->second;
+      }
+    }
+    it->second->roundEnd();
+  }
 
-  // if (in_sync) updateLossRate();
-  updateLossRate();
+  if (main_path_ == nullptr) main_path_ = old_main_path;
+
+  // in case we get a new main path we reset the stats of the old one. this is
+  // beacuse, in case we need to switch back we don't what to take decisions on
+  // old stats that may be outdated.
+  if (main_path_ != old_main_path) old_main_path->clearRtt();
+
+  updateLossRate(in_sync);
 
   // handle nacks
   if (!nack_on_last_round_ && received_bytes_ > 0) {
@@ -460,6 +571,8 @@ void RTCState::onNewRound(double round_len, bool in_sync) {
 
   // reset counters
   received_bytes_ = 0;
+  received_fec_bytes_ = 0;
+  recovered_bytes_with_fec_ = 0;
   packets_lost_ = 0;
   definitely_lost_pkt_ = 0;
   losses_recovered_ = 0;
@@ -516,20 +629,16 @@ void RTCState::updatePathStats(const core::ContentObject &content_object,
              // it means that we are processing an interest
              // that is not pending
 
-  uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::steady_clock::now().time_since_epoch())
-                     .count();
+  uint64_t now = utils::SteadyTime::nowMs().count();
 
   uint64_t RTT = now - interest_sent_time;
 
-  path->insertRttSample(RTT);
+  path->insertRttSample(utils::SteadyTime::Milliseconds(RTT), false);
 
   // compute OWD (the first part of the nack and data packet header are the
   // same, so we cast to data data packet)
-  struct data_packet_t *packet =
-      (struct data_packet_t *)content_object.getPayload()->data();
-  uint64_t sender_timestamp = packet->getTimestamp();
-  int64_t OWD = now - sender_timestamp;
+  core::ParamsRTC params = RTCState::getDataParams(content_object);
+  int64_t OWD = now - params.timestamp;
   path->insertOwdSample(OWD);
 
   // compute IAT or set path to producer
@@ -543,59 +652,106 @@ void RTCState::updatePathStats(const core::ContentObject &content_object,
   }
 }
 
-void RTCState::updateLossRate() {
+void RTCState::updateLossRate(bool in_sync) {
   last_round_loss_rate_ = loss_rate_;
   loss_rate_ = 0.0;
-  residual_loss_rate_ = 0.0;
 
   uint32_t number_theorically_received_packets_ =
       highest_seq_received_ - first_seq_in_round_;
 
-  // in this case no new packet was recevied after the previuos round, avoid
-  // division by 0
-  if (number_theorically_received_packets_ == 0) return;
-
   // XXX this may be quite inefficient if the rate is high
   // maybe is better to iterate over the set?
-  for (uint32_t i = first_seq_in_round_; i < highest_seq_received_; i++) {
-    auto it = skipped_interests_.find(i);
-    if (it != skipped_interests_.end()) {
+
+  uint32_t fec_packets = 0;
+  for (uint32_t i = (first_seq_in_round_ + 1); i < highest_seq_received_; i++) {
+    PacketState state = getPacketState(i);
+    if (state == PacketState::SKIPPED) {
       if (number_theorically_received_packets_ > 0)
         number_theorically_received_packets_--;
-      skipped_interests_.erase(it);
     }
+    if (indexer_->isFec(i)) fec_packets++;
   }
+  if (indexer_->isFec(highest_seq_received_)) fec_packets++;
 
-  loss_rate_ = (double)((double)(packets_lost_) /
-                        (double)number_theorically_received_packets_);
+  // in this case no new packet was received after the previous round, avoid
+  // division by 0
+  if (number_theorically_received_packets_ == 0 && packets_lost_ == 0) return;
 
-  if (rounds_ % 15 == 0) max_loss_rate_ = 0;  // reset every 3 sec
-  if (loss_rate_ > max_loss_rate_) max_loss_rate_ = loss_rate_;
+  if (number_theorically_received_packets_ != 0)
+    loss_rate_ = (double)((double)(packets_lost_) /
+                          (double)number_theorically_received_packets_);
+  else
+    // we didn't receive anything except NACKs that triggered losses
+    loss_rate_ = 1.0;
 
-  if (avg_loss_rate_ == 0)
+  if (avg_loss_rate_ == -1.0)
     avg_loss_rate_ = loss_rate_;
   else
     avg_loss_rate_ =
         avg_loss_rate_ * MOVING_AVG_ALPHA + loss_rate_ * (1 - MOVING_AVG_ALPHA);
 
-  residual_loss_rate_ = (double)((double)(packets_lost_ - losses_recovered_) /
-                                 (double)number_theorically_received_packets_);
+  // update counters for loss rate per second
+  total_expected_packets_ += number_theorically_received_packets_;
+  lost_per_sec_ += packets_lost_;
+
+  if (in_sync) {
+    // update counters for residual losses
+    // fec packets are not sent to the app so we don't want to count them here
+    expected_packets_ +=
+        ((highest_seq_received_ - first_seq_in_round_) - fec_packets);
+  } else {
+    packets_sent_to_app_ = 0;
+  }
+
+  if (rounds_from_last_compute_ >= (MILLI_IN_A_SEC / ROUND_LEN)) {
+    // compute loss rate per second
+    if (lost_per_sec_ > total_expected_packets_)
+      lost_per_sec_ = total_expected_packets_;
+
+    if (total_expected_packets_ == 0)
+      per_sec_loss_rate_ = 0;
+    else
+      per_sec_loss_rate_ =
+          (double)((double)(lost_per_sec_) / (double)total_expected_packets_);
+
+    loss_history_.pushBack(per_sec_loss_rate_);
+    max_loss_rate_ = getMaxLoss();
+
+    if (in_sync && expected_packets_ != 0) {
+      // compute residual loss rate
+      if (packets_sent_to_app_ > expected_packets_) {
+        // this may happen if we get packet from the prev bin that get recovered
+        // on the current one
+        packets_sent_to_app_ = expected_packets_;
+      }
+
+      residual_loss_rate_ =
+          1.0 - ((double)packets_sent_to_app_ / (double)expected_packets_);
+      if (residual_loss_rate_ < 0.0) residual_loss_rate_ = 0.0;
+    }
+
+    lost_per_sec_ = 0;
+    total_expected_packets_ = 0;
+    expected_packets_ = 0;
+    packets_sent_to_app_ = 0;
+    rounds_from_last_compute_ = 0;
+  }
+
+  rounds_from_last_compute_++;
+}
 
-  if (residual_loss_rate_ < 0) residual_loss_rate_ = 0;
+void RTCState::dataToBeReceived(uint32_t seq) {
+  addToPacketCache(seq, PacketState::TO_BE_RECEIVED);
 }
 
 void RTCState::addRecvOrLost(uint32_t seq, PacketState state) {
-  if (indexer_->isFec(seq)) {
-    pending_fec_pkt_--;
+  auto it = pending_interests_.find(seq);
+  if (it != pending_interests_.end()) {
+    pending_interests_.erase(it);
+    if (indexer_->isFec(seq)) pending_fec_pkt_--;
   }
 
-  pending_interests_.erase(seq);
-  if (received_or_lost_packets_.size() >= MAX_CACHED_PACKETS) {
-    received_or_lost_packets_.erase(received_or_lost_packets_.begin());
-  }
-  // notice that it may happen that a packet that we consider lost arrives after
-  // some time, in this case we simply overwrite the packet state.
-  received_or_lost_packets_[seq] = state;
+  addToPacketCache(seq, state);
 
   // keep track of the last packet received/lost
   // without holes.
@@ -608,16 +764,25 @@ void RTCState::addRecvOrLost(uint32_t seq, PacketState state) {
   } else if (seq <= highest_seq_received_in_order_) {
     // here we do nothing
   } else if (seq > highest_seq_received_in_order_) {
-    // 1) there is a gap in the sequence so we do not update largest_in_seq_
-    // 2) all the packets from largest_in_seq_ to seq are in
-    //    received_or_lost_packets_ an we upate largest_in_seq_
-    //    or are FEC packets
+    // 1) there is a gap in the sequence so we do not update
+    // highest_seq_received_in_order_
+    // 2) all the packets from highest_seq_received_in_order_ to seq are
+    // received or lost or are fec packetis. In this case we increase
+    // highest_seq_received_in_order_ until we find an hole in the sequence
 
     for (uint32_t i = highest_seq_received_in_order_ + 1; i <= seq; i++) {
-      if (received_or_lost_packets_.find(i) ==
-              received_or_lost_packets_.end() &&
-          !indexer_->isFec(i)) {
-        break;
+      PacketState state = getPacketState(i);
+      if ((state == PacketState::UNKNOWN || state == PacketState::LOST)) {
+        if (indexer_->isFec(i)) {
+          // this is a fec packet and we don't care to receive it
+          // however we may need to increse the number or lost packets
+          // XXX: in case we want to use rtx to recover fec packets,
+          // this may prevent to detect a packet loss and no rtx will be sent
+          onLossDetected(i);
+        } else {
+          // this is a data packet and we need to get it
+          break;
+        }
       }
       // this packet is in order so we can update the
       // highest_seq_received_in_order_
@@ -629,9 +794,14 @@ void RTCState::addRecvOrLost(uint32_t seq, PacketState state) {
 void RTCState::setInitRttTimer(uint32_t wait) {
   init_rtt_timer_->cancel();
   init_rtt_timer_->expires_from_now(std::chrono::milliseconds(wait));
-  init_rtt_timer_->async_wait([this](std::error_code ec) {
+
+  std::weak_ptr<RTCState> self = shared_from_this();
+  init_rtt_timer_->async_wait([self](const std::error_code &ec) {
     if (ec) return;
-    checkInitRttTimer();
+
+    if (auto ptr = self.lock()) {
+      ptr->checkInitRttTimer();
+    }
   });
 }
 
@@ -639,19 +809,25 @@ void RTCState::checkInitRttTimer() {
   if (received_probes_ < INIT_RTT_MIN_PROBES_TO_RECV) {
     // we didn't received enough probes, restart
     received_probes_ = 0;
-    rtt_probes_->setProbes(INIT_RTT_PROBE_INTERVAL, INIT_RTT_PROBES);
-    rtt_probes_->sendProbes();
+    probe_handler_->setSuffixRange(MIN_INIT_PROBE_SEQ, MAX_INIT_PROBE_SEQ);
+    probe_handler_->setProbes(INIT_RTT_PROBE_INTERVAL, INIT_RTT_PROBES);
+    probe_handler_->sendProbes();
     setInitRttTimer(INIT_RTT_PROBE_RESTART);
     return;
   }
+
   init_rtt_ = true;
   main_path_->roundEnd();
-  rtt_probes_->setProbes(RTT_PROBE_INTERVAL, 0);
-  rtt_probes_->sendProbes();
+  loss_history_.pushBack(probe_handler_->getProbeLossRate());
+  max_loss_rate_ = getMaxLoss();
+
+  probe_handler_->setSuffixRange(MIN_RTT_PROBE_SEQ, MAX_RTT_PROBE_SEQ);
+  probe_handler_->setProbes(RTT_PROBE_INTERVAL, 0);
+  probe_handler_->sendProbes();
 
   // init last_seq_nacked_. skip packets that may come from the cache
   double prod_rate = getProducerRate();
-  double rtt = (double)getRTT() / MILLI_IN_A_SEC;
+  double rtt = (double)getMinRTT() / MILLI_IN_A_SEC;
   double packet_size = getAveragePacketSize();
   uint32_t pkt_in_rtt_ = std::floor(((prod_rate / packet_size) * rtt) * 0.8);
   last_seq_nacked_ = last_production_seq_ + pkt_in_rtt_;
@@ -659,6 +835,68 @@ void RTCState::checkInitRttTimer() {
   discovered_rtt_callback_();
 }
 
+double RTCState::getMaxLoss() {
+  if (loss_history_.size() != 0) return loss_history_.begin();
+  return 0;
+}
+
+core::ParamsRTC RTCState::getProbeParams(const core::ContentObject &probe) {
+  uint32_t seq = probe.getName().getSuffix();
+  core::ParamsRTC params;
+
+  switch (ProbeHandler::getProbeType(seq)) {
+    case ProbeType::INIT: {
+      core::ContentObjectManifest manifest(
+          const_cast<core::ContentObject &>(probe));
+      manifest.decode();
+      params = manifest.getParamsRTC();
+      break;
+    }
+    case ProbeType::RTT: {
+      struct nack_packet_t *probe_pkt =
+          (struct nack_packet_t *)probe.getPayload()->data();
+      params = core::ParamsRTC{
+          .timestamp = probe_pkt->getTimestamp(),
+          .prod_rate = probe_pkt->getProductionRate(),
+          .prod_seg = probe_pkt->getProductionSegment(),
+      };
+      break;
+    }
+    default:
+      break;
+  }
+
+  return params;
+}
+
+core::ParamsRTC RTCState::getDataParams(const core::ContentObject &data) {
+  core::ParamsRTC params;
+
+  switch (data.getPayloadType()) {
+    case core::PayloadType::DATA: {
+      struct data_packet_t *data_pkt =
+          (struct data_packet_t *)data.getPayload()->data();
+      params = core::ParamsRTC{
+          .timestamp = data_pkt->getTimestamp(),
+          .prod_rate = data_pkt->getProductionRate(),
+          .prod_seg = data.getName().getSuffix(),
+      };
+      break;
+    }
+    case core::PayloadType::MANIFEST: {
+      core::ContentObjectManifest manifest(
+          const_cast<core::ContentObject &>(data));
+      manifest.decode();
+      params = manifest.getParamsRTC();
+      break;
+    }
+    default:
+      break;
+  }
+
+  return params;
+}
+
 }  // namespace rtc
 
 }  // namespace protocol
diff --git a/libtransport/src/protocols/rtc/rtc_state.h b/libtransport/src/protocols/rtc/rtc_state.h
index 729ba7a1b..8bf48ccc2 100644
--- a/libtransport/src/protocols/rtc/rtc_state.h
+++ b/libtransport/src/protocols/rtc/rtc_state.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,13 +14,16 @@
  */
 
 #pragma once
+#include <core/facade.h>
 #include <hicn/transport/config.h>
 #include <hicn/transport/core/asio_wrapper.h>
 #include <hicn/transport/core/content_object.h>
 #include <hicn/transport/core/name.h>
+#include <hicn/transport/utils/rtc_quality_score.h>
 #include <protocols/indexer.h>
 #include <protocols/rtc/probe_handler.h>
 #include <protocols/rtc/rtc_data_path.h>
+#include <utils/max_filter.h>
 
 #include <map>
 #include <set>
@@ -31,25 +34,50 @@ namespace protocol {
 
 namespace rtc {
 
-enum class PacketState : uint8_t { RECEIVED, LOST, UNKNOWN };
+// packet state
+// RECEIVED: the packet was already received
+// LOST: the packet is marked as lost but can be recovered
+// DEFINITELY_LOST: the packet is lost and cannot be recovered
+// TO_BE_RECEIVED: when a packet is received is sent to the FEC decoder. the fec
+// decoder may decide to send the packet directly to the app. to avoid
+// duplicated the packet is marked with this state
+// SKIPPED: an interest that was not sent, only for FEC packets
+// UNKNOWN: unknown state
+enum class PacketState : uint8_t {
+  RECEIVED,
+  TO_BE_RECEIVED,
+  LOST,
+  DEFINITELY_LOST,
+  SKIPPED,
+  UNKNOWN
+};
+
+class RTCState : public std::enable_shared_from_this<RTCState> {
+  using PendingInterestsMap = std::map<uint32_t, uint64_t>;
+
+ private:
+  const double MAX_CACHED_PACKETS = 8192;  // XXX this value may be too small
+                                           // for high rate apps
 
-class RTCState : std::enable_shared_from_this<RTCState> {
  public:
   using DiscoveredRttCallback = std::function<void()>;
 
  public:
-  RTCState(Indexer *indexer,
-           ProbeHandler::SendProbeCallback &&rtt_probes_callback,
+  RTCState(Indexer *indexer, ProbeHandler::SendProbeCallback &&probe_callback,
            DiscoveredRttCallback &&discovered_rtt_callback,
            asio::io_service &io_service);
 
   ~RTCState();
 
+  // initialization
+  void initParams();
+
   // packet events
   void onSendNewInterest(const core::Name *interest_name);
   void onTimeout(uint32_t seq, bool lost);
   void onLossDetected(uint32_t seq);
   void onRetransmission(uint32_t seq);
+  void onPossibleLossWithNoRtx(uint32_t seq);
   void onDataPacketReceived(const core::ContentObject &content_object,
                             bool compute_stats);
   void onFecPacketReceived(const core::ContentObject &content_object);
@@ -57,8 +85,10 @@ class RTCState : std::enable_shared_from_this<RTCState> {
                             bool compute_stats);
   void onPacketLost(uint32_t seq);
   void onPacketRecoveredRtx(uint32_t seq);
-  void onPacketRecoveredFec(uint32_t seq);
+  void onFecPacketRecoveredRtx(uint32_t seq);
+  void onPacketRecoveredFec(uint32_t seq, uint32_t size);
   bool onProbePacketReceived(const core::ContentObject &probe);
+  void onJumpForward(uint32_t next_seq);
 
   // protocol state
   void onNewRound(double round_len, bool in_sync);
@@ -72,10 +102,21 @@ class RTCState : std::enable_shared_from_this<RTCState> {
   // delay metrics
   bool isRttDiscovered() const { return init_rtt_; }
 
-  uint64_t getRTT() const {
+  uint64_t getMinRTT() const {
     if (mainPathIsValid()) return main_path_->getMinRtt();
     return 0;
   }
+
+  uint64_t getAvgRTT() const {
+    if (mainPathIsValid()) return main_path_->getAvgRtt();
+    return 0;
+  }
+
+  uint64_t getMaxRTT() const {
+    if (mainPathIsValid()) return main_path_->getMaxRtt();
+    return 0;
+  }
+
   void resetRttStats() {
     if (mainPathIsValid()) main_path_->clearRtt();
   }
@@ -98,6 +139,7 @@ class RTCState : std::enable_shared_from_this<RTCState> {
   uint64_t getInterestSentTime(uint32_t seq) {
     auto it = pending_interests_.find(seq);
     if (it != pending_interests_.end()) return it->second;
+
     return 0;
   }
 
@@ -110,14 +152,15 @@ class RTCState : std::enable_shared_from_this<RTCState> {
     return pending_interests_.size();
   }
 
-  PacketState isReceivedOrLost(uint32_t seq) {
-    auto it = received_or_lost_packets_.find(seq);
-    if (it != received_or_lost_packets_.end()) return it->second;
+  PacketState getPacketState(uint32_t seq) {
+    auto it = packet_cache_.find(seq);
+    if (it != packet_cache_.end()) return it->second;
     return PacketState::UNKNOWN;
   }
 
   // loss rate
-  double getLossRate() const { return loss_rate_; }
+  double getPerRoundLossRate() const { return loss_rate_; }
+  double getPerSecondLossRate() const { return per_sec_loss_rate_; }
   double getAvgLossRate() const { return avg_loss_rate_; }
   double getMaxLossRate() const { return max_loss_rate_; }
   double getLastRoundLossRate() const { return last_round_loss_rate_; }
@@ -134,15 +177,22 @@ class RTCState : std::enable_shared_from_this<RTCState> {
     return highest_seq_received_in_order_;
   }
 
+  double getMaxLoss();
+
   // fec packets
   uint32_t getReceivedFecPackets() const { return received_fec_pkt_; }
   uint32_t getPendingFecPackets() const { return pending_fec_pkt_; }
 
   // generic stats
   uint32_t getReceivedBytesInRound() const { return received_bytes_; }
+  uint32_t getReceivedFecBytesInRound() const { return received_fec_bytes_; }
+  uint32_t getRecoveredFecBytesInRound() const {
+    return recovered_bytes_with_fec_;
+  }
   uint32_t getReceivedNacksInRound() const {
     return received_nacks_last_round_;
   }
+  uint32_t getReceivedDataInRound() const { return received_data_last_round_; }
   uint32_t getSentInterestInRound() const { return sent_interests_last_round_; }
   uint32_t getSentRtxInRound() const { return sent_rtx_last_round_; }
 
@@ -150,6 +200,9 @@ class RTCState : std::enable_shared_from_this<RTCState> {
   double getAvailableBw() const { return 0.0; };  // TODO
   double getProducerRate() const { return production_rate_; }
   double getReceivedRate() const { return received_rate_; }
+  double getReceivedFecRate() const { return fec_received_rate_; }
+  double getRecoveredFecRate() const { return fec_recovered_rate_; }
+
   double getAveragePacketSize() const { return avg_packet_size_; }
 
   // nacks
@@ -162,22 +215,46 @@ class RTCState : std::enable_shared_from_this<RTCState> {
   // packets from cache
   double getPacketFromCacheRatio() const { return data_from_cache_rate_; }
 
-  std::map<uint32_t, uint64_t>::iterator getPendingInterestsMapBegin() {
+  PendingInterestsMap::iterator getPendingInterestsMapBegin() {
     return pending_interests_.begin();
   }
-  std::map<uint32_t, uint64_t>::iterator getPendingInterestsMapEnd() {
+  PendingInterestsMap::iterator getPendingInterestsMapEnd() {
     return pending_interests_.end();
   }
 
+  // quality
+  uint8_t getQualityScore() {
+    uint8_t qs = quality_score_.getQualityScore(
+        getMaxRTT(), std::round(getResidualLossRate() * 100));
+    return qs;
+  }
+
+  // We received a data pkt that will be set to RECEIVED, but first we have to
+  // go through FEC. We do not want to consider this pkt as recovered, thus we
+  // set it as TO_BE_RECEIVED.
+  void dataToBeReceived(uint32_t seq);
+
+  // Extract RTC parameters from probes (init or RTT probes) and data packets.
+  static core::ParamsRTC getProbeParams(const core::ContentObject &probe);
+  static core::ParamsRTC getDataParams(const core::ContentObject &data);
+
  private:
-  void initParams();
+  void addToPacketCache(uint32_t seq, PacketState state) {
+    // this function adds or updates the current state
+    if (packet_cache_.size() >= MAX_CACHED_PACKETS) {
+      packet_cache_.erase(packet_cache_.begin());
+    }
+    packet_cache_[seq] = state;
+  }
+
+  void eraseFromPacketCache(uint32_t seq) { packet_cache_.erase(seq); }
 
   // update stats
   void updateState();
   void updateReceivedBytes(const core::ContentObject &content_object);
   void updatePacketSize(const core::ContentObject &content_object);
   void updatePathStats(const core::ContentObject &content_object, bool is_nack);
-  void updateLossRate();
+  void updateLossRate(bool in_sycn);
 
   void addRecvOrLost(uint32_t seq, PacketState state);
 
@@ -211,22 +288,39 @@ class RTCState : std::enable_shared_from_this<RTCState> {
   double avg_loss_rate_;
   double max_loss_rate_;
   double last_round_loss_rate_;
+  utils::MaxFilter<double> loss_history_;
+
+  // per second loss rate
+  uint32_t lost_per_sec_;
+  uint32_t total_expected_packets_;
+  double per_sec_loss_rate_;
+
+  // conunters for residual losses
+  // residual losses are computed every second and are used
+  // as feedback to the upper levels (e.g application)
+  uint32_t expected_packets_;
+  uint32_t packets_sent_to_app_;
+  uint32_t rounds_from_last_compute_;
   double residual_loss_rate_;
 
   // bw counters
   uint32_t received_bytes_;
+  uint32_t received_fec_bytes_;
+  uint32_t recovered_bytes_with_fec_;
   double avg_packet_size_;
-  double production_rate_;  // rate communicated by the producer using nacks
-  double received_rate_;    // rate recevied by the consumer
+  double production_rate_;     // rate communicated by the producer using nacks
+  double received_rate_;       // rate recevied by the consumer (only data)
+  double fec_received_rate_;   // fec rate recevied by the consumer
+  double fec_recovered_rate_;  // rate recovered using fec
 
-  // nack counter
+  // nack counters
   // the bool takes tracks only about the valid nacks (no rtx) and it is used to
   // switch between the states. Instead received_nacks_last_round_ logs all the
   // nacks for statistics
   bool nack_on_last_round_;
   uint32_t received_nacks_last_round_;
 
-  // packets counter
+  // packets counters
   uint32_t received_packets_last_round_;
   uint32_t received_data_last_round_;
   uint32_t received_data_from_cache_;
@@ -234,11 +328,11 @@ class RTCState : std::enable_shared_from_this<RTCState> {
   uint32_t sent_interests_last_round_;
   uint32_t sent_rtx_last_round_;
 
-  // fec counter
+  // fec counters
   uint32_t received_fec_pkt_;
   uint32_t pending_fec_pkt_;
 
-  // round conunters
+  // round counters
   uint32_t rounds_;
   uint32_t rounds_without_nacks_;
   uint32_t rounds_without_packets_;
@@ -261,23 +355,27 @@ class RTCState : std::enable_shared_from_this<RTCState> {
 
   // packet received
   // cache where to store info about the last MAX_CACHED_PACKETS
-  std::map<uint32_t, PacketState> received_or_lost_packets_;
+  // these are packets that are received or lost or definitely lost and are not
+  // anymore in the pending intetest list
+  std::map<uint32_t, PacketState> packet_cache_;
 
   // pending interests
-  std::map<uint32_t, uint64_t> pending_interests_;
+  PendingInterestsMap pending_interests_;
 
   // indexer
   Indexer *indexer_;
 
-  // skipped interests
+  // used to keep track of the skipped interests
   uint32_t last_interest_sent_;
-  std::unordered_set<uint32_t> skipped_interests_;
 
   // probes
-  std::shared_ptr<ProbeHandler> rtt_probes_;
+  std::shared_ptr<ProbeHandler> probe_handler_;
   bool init_rtt_;
   std::unique_ptr<asio::steady_timer> init_rtt_timer_;
 
+  // quality score
+  RTCQualityScore quality_score_;
+
   // callbacks
   DiscoveredRttCallback discovered_rtt_callback_;
 };
diff --git a/libtransport/src/protocols/rtc/rtc_verifier.cc b/libtransport/src/protocols/rtc/rtc_verifier.cc
new file mode 100644
index 000000000..29968dd02
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_verifier.cc
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <core/facade.h>
+#include <protocols/rtc/rtc_packet.h>
+#include <protocols/rtc/rtc_verifier.h>
+
+namespace transport {
+namespace protocol {
+namespace rtc {
+
+RTCVerifier::RTCVerifier(std::shared_ptr<auth::Verifier> verifier,
+                         uint32_t max_unverified_delay)
+    : verifier_(verifier), max_unverified_delay_(max_unverified_delay) {}
+
+void RTCVerifier::setState(std::shared_ptr<RTCState> rtc_state) {
+  rtc_state_ = rtc_state;
+}
+
+void RTCVerifier::setVerifier(std::shared_ptr<auth::Verifier> verifier) {
+  verifier_ = verifier;
+}
+
+void RTCVerifier::setMaxUnverifiedDelay(uint32_t max_unverified_delay) {
+  max_unverified_delay_ = max_unverified_delay;
+}
+
+auth::VerificationPolicy RTCVerifier::verify(
+    core::ContentObject &content_object, bool is_fec) {
+  uint32_t suffix = content_object.getName().getSuffix();
+  core::PayloadType payload_type = content_object.getPayloadType();
+
+  bool is_probe = ProbeHandler::getProbeType(suffix) != ProbeType::NOT_PROBE;
+  bool is_nack = !is_probe && content_object.payloadSize() == NACK_HEADER_SIZE;
+  bool is_manifest = !is_probe && !is_nack && !is_fec &&
+                     payload_type == core::PayloadType::MANIFEST;
+  bool is_data = !is_probe && !is_nack && !is_fec &&
+                 payload_type == core::PayloadType::DATA;
+
+  if (is_probe) return verifyProbe(content_object);
+  if (is_nack) return verifyNack(content_object);
+  if (is_fec) return verifyFec(content_object);
+  if (is_data) return verifyData(content_object);
+  if (is_manifest) return verifyManifest(content_object);
+
+  auth::VerificationPolicy policy = auth::VerificationPolicy::ABORT;
+  verifier_->callVerificationFailedCallback(suffix, policy);
+  return policy;
+}
+
+auth::VerificationPolicy RTCVerifier::verifyProbe(
+    core::ContentObject &content_object) {
+  switch (ProbeHandler::getProbeType(content_object.getName().getSuffix())) {
+    case ProbeType::INIT: {
+      auth::VerificationPolicy policy = verifyManifest(content_object);
+      if (policy != auth::VerificationPolicy::ACCEPT) {
+        return policy;
+      }
+      return processManifest(content_object);
+    }
+    case ProbeType::RTT:
+      return verifyNack(content_object);
+    default:
+      auth::VerificationPolicy policy = auth::VerificationPolicy::ABORT;
+      verifier_->callVerificationFailedCallback(
+          content_object.getName().getSuffix(), policy);
+      return policy;
+  }
+}
+
+auth::VerificationPolicy RTCVerifier::verifyNack(
+    core::ContentObject &content_object) {
+  return verifier_->verifyPackets(&content_object);
+}
+
+auth::VerificationPolicy RTCVerifier::verifyFec(
+    core::ContentObject &content_object) {
+  return verifier_->verifyPackets(&content_object);
+}
+
+auth::VerificationPolicy RTCVerifier::verifyData(
+    core::ContentObject &content_object) {
+  uint32_t suffix = content_object.getName().getSuffix();
+
+  if (_is_ah(content_object.getFormat())) {
+    return verifier_->verifyPackets(&content_object);
+  }
+
+  unverified_bytes_[suffix] =
+      content_object.headerSize() + content_object.payloadSize();
+  unverified_packets_[suffix] =
+      content_object.computeDigest(manifest_hash_algo_);
+
+  // An alert is raised when too much packets remain unverified
+  if (getTotalUnverified() > max_unverified_bytes_) {
+    unverified_bytes_.clear();
+    unverified_packets_.clear();
+
+    auth::VerificationPolicy policy = auth::VerificationPolicy::ABORT;
+    verifier_->callVerificationFailedCallback(suffix, policy);
+    return policy;
+  }
+
+  return auth::VerificationPolicy::ACCEPT;
+}
+
+auth::VerificationPolicy RTCVerifier::verifyManifest(
+    core::ContentObject &content_object) {
+  return verifier_->verifyPackets(&content_object);
+}
+
+auth::VerificationPolicy RTCVerifier::processManifest(
+    core::ContentObject &content_object) {
+  uint32_t suffix = content_object.getName().getSuffix();
+
+  core::ContentObjectManifest manifest(content_object);
+  manifest.decode();
+
+  // Update last manifest
+  if (suffix > last_manifest_) {
+    last_manifest_ = suffix;
+  }
+
+  // Extract parameters
+  manifest_hash_algo_ = manifest.getHashAlgorithm();
+  core::ParamsRTC params = manifest.getParamsRTC();
+
+  if (params.prod_rate > 0) {
+    max_unverified_bytes_ = static_cast<uint64_t>(
+        (max_unverified_delay_ / 1000.0) * params.prod_rate);
+  }
+
+  if (max_unverified_bytes_ == 0 || !rtc_state_) {
+    auth::VerificationPolicy policy = auth::VerificationPolicy::ABORT;
+    verifier_->callVerificationFailedCallback(suffix, policy);
+    return policy;
+  }
+
+  // Extract hashes
+  auth::Verifier::SuffixMap suffix_map =
+      core::ContentObjectManifest::getSuffixMap(&manifest);
+
+  // Return early if the manifest is empty
+  if (suffix_map.empty()) {
+    return auth::VerificationPolicy::ACCEPT;
+  }
+
+  // Remove lost packets from digest map
+  manifest_digests_.insert(suffix_map.begin(), suffix_map.end());
+  for (auto it = manifest_digests_.begin(); it != manifest_digests_.end();) {
+    if (rtc_state_->getPacketState(it->first) == PacketState::DEFINITELY_LOST) {
+      unverified_packets_.erase(it->first);
+      unverified_bytes_.erase(it->first);
+      it = manifest_digests_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+
+  // Verify packets
+  auth::Verifier::PolicyMap policies =
+      verifier_->verifyHashes(unverified_packets_, manifest_digests_);
+
+  for (const auto &policy : policies) {
+    switch (policy.second) {
+      case auth::VerificationPolicy::ACCEPT: {
+        manifest_digests_.erase(policy.first);
+        unverified_packets_.erase(policy.first);
+        unverified_bytes_.erase(policy.first);
+        break;
+      }
+      case auth::VerificationPolicy::UNKNOWN:
+        break;
+      case auth::VerificationPolicy::DROP:
+      case auth::VerificationPolicy::ABORT:
+        auth::VerificationPolicy p = policy.second;
+        verifier_->callVerificationFailedCallback(policy.first, p);
+        return p;
+    }
+  }
+
+  return auth::VerificationPolicy::ACCEPT;
+}
+
+void RTCVerifier::onDataRecoveredFec(uint32_t suffix) {
+  manifest_digests_.erase(suffix);
+}
+
+void RTCVerifier::onJumpForward(uint32_t next_suffix) {
+  if (next_suffix <= last_manifest_ + 1) {
+    return;
+  }
+
+  // When we jump forward in the suffix sequence, we remove packets that
+  // probably won't be verified. Those packets have a suffix in the range
+  // [last_manifest_ + 1, next_suffix[.
+  for (auto it = unverified_packets_.begin();
+       it != unverified_packets_.end();) {
+    if (it->first > last_manifest_) {
+      unverified_bytes_.erase(it->first);
+      it = unverified_packets_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+uint32_t RTCVerifier::getTotalUnverified() const {
+  uint32_t total = 0;
+
+  for (auto bytes : unverified_bytes_) {
+    if (bytes.second > UINT32_MAX - total) {
+      total = UINT32_MAX;
+      break;
+    }
+    total += bytes.second;
+  }
+
+  return total;
+}
+
+uint32_t RTCVerifier::getMaxUnverified() const { return max_unverified_bytes_; }
+
+}  // end namespace rtc
+}  // end namespace protocol
+}  // end namespace transport
diff --git a/libtransport/src/protocols/rtc/rtc_verifier.h b/libtransport/src/protocols/rtc/rtc_verifier.h
new file mode 100644
index 000000000..596bd8536
--- /dev/null
+++ b/libtransport/src/protocols/rtc/rtc_verifier.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <core/facade.h>
+#include <hicn/transport/auth/verifier.h>
+#include <hicn/transport/core/content_object.h>
+#include <protocols/rtc/rtc_state.h>
+
+namespace transport {
+namespace protocol {
+namespace rtc {
+
+class RTCVerifier {
+ public:
+  RTCVerifier(std::shared_ptr<auth::Verifier> verifier,
+              uint32_t max_unverified_delay);
+
+  virtual ~RTCVerifier() = default;
+
+  void setState(std::shared_ptr<RTCState> rtc_state);
+
+  void setVerifier(std::shared_ptr<auth::Verifier> verifier);
+
+  void setMaxUnverifiedDelay(uint32_t max_unverified_delay);
+
+  void onDataRecoveredFec(uint32_t suffix);
+  void onJumpForward(uint32_t next_suffix);
+
+  uint32_t getTotalUnverified() const;
+  uint32_t getMaxUnverified() const;
+
+  auth::VerificationPolicy verify(core::ContentObject &content_object,
+                                  bool is_fec = false);
+  auth::VerificationPolicy verifyProbe(core::ContentObject &content_object);
+  auth::VerificationPolicy verifyNack(core::ContentObject &content_object);
+  auth::VerificationPolicy verifyFec(core::ContentObject &content_object);
+  auth::VerificationPolicy verifyData(core::ContentObject &content_object);
+  auth::VerificationPolicy verifyManifest(core::ContentObject &content_object);
+
+  auth::VerificationPolicy processManifest(core::ContentObject &content_object);
+
+ protected:
+  // The RTC state.
+  std::shared_ptr<RTCState> rtc_state_;
+  // The verifier instance.
+  std::shared_ptr<auth::Verifier> verifier_;
+  // Hash algorithm used by manifests.
+  auth::CryptoHashType manifest_hash_algo_;
+  // The last manifest processed.
+  auth::Suffix last_manifest_;
+  // Hold digests extracted from all manifests received.
+  auth::Verifier::SuffixMap manifest_digests_;
+  // Hold hashes of all content objects received before they are verified.
+  auth::Verifier::SuffixMap unverified_packets_;
+  // Hold number of unverified bytes.
+  std::unordered_map<auth::Suffix, uint32_t> unverified_bytes_;
+  // Maximum delay (in ms) for an unverified byte to become verifed.
+  uint32_t max_unverified_delay_;
+  // Maximum number of unverified bytes before aborting the connection.
+  uint64_t max_unverified_bytes_;
+};
+
+}  // end namespace rtc
+}  // namespace protocol
+}  // namespace transport
diff --git a/libtransport/src/protocols/transport_protocol.cc b/libtransport/src/protocols/transport_protocol.cc
index d6954ac37..f1e49ec0b 100644
--- a/libtransport/src/protocols/transport_protocol.cc
+++ b/libtransport/src/protocols/transport_protocol.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -25,7 +25,8 @@ using namespace interface;
 
 TransportProtocol::TransportProtocol(implementation::ConsumerSocket *icn_socket,
                                      Indexer *indexer, Reassembly *reassembly)
-    : socket_(icn_socket),
+    : Protocol(),
+      socket_(icn_socket),
       indexer_verifier_(indexer),
       reassembly_(reassembly),
       fec_decoder_(nullptr),
@@ -36,90 +37,82 @@ TransportProtocol::TransportProtocol(implementation::ConsumerSocket *icn_socket,
       on_interest_satisfied_(VOID_HANDLER),
       on_content_object_input_(VOID_HANDLER),
       stats_summary_(VOID_HANDLER),
+      on_fwd_strategy_(VOID_HANDLER),
+      on_rec_strategy_(VOID_HANDLER),
       on_payload_(VOID_HANDLER),
-      fec_type_(fec::FECType::UNKNOWN),
-      is_running_(false) {
+      fec_type_(fec::FECType::UNKNOWN) {
   socket_->getSocketOption(GeneralTransportOptions::PORTAL, portal_);
   socket_->getSocketOption(OtherOptions::STATISTICS, &stats_);
 
-  // Set this transport protocol as portal's consumer callback
-  portal_->setConsumerCallback(this);
-
   indexer_verifier_->setReassembly(reassembly_.get());
   reassembly->setIndexer(indexer_verifier_.get());
 }
 
+TransportProtocol::~TransportProtocol() {}
+
 int TransportProtocol::start() {
   // If the protocol is already running, return otherwise set as running
-  if (is_running_) return -1;
-
-  // Get all callbacks references
-  socket_->getSocketOption(ConsumerCallbacksOptions::INTEREST_RETRANSMISSION,
-                           &on_interest_retransmission_);
-  socket_->getSocketOption(ConsumerCallbacksOptions::INTEREST_OUTPUT,
-                           &on_interest_output_);
-  socket_->getSocketOption(ConsumerCallbacksOptions::INTEREST_EXPIRED,
-                           &on_interest_timeout_);
-  socket_->getSocketOption(ConsumerCallbacksOptions::INTEREST_SATISFIED,
-                           &on_interest_satisfied_);
-  socket_->getSocketOption(ConsumerCallbacksOptions::CONTENT_OBJECT_INPUT,
-                           &on_content_object_input_);
-  socket_->getSocketOption(ConsumerCallbacksOptions::STATS_SUMMARY,
-                           &stats_summary_);
-  socket_->getSocketOption(ConsumerCallbacksOptions::READ_CALLBACK,
-                           &on_payload_);
-
-  socket_->getSocketOption(GeneralTransportOptions::ASYNC_MODE, is_async_);
-
-  // Set it is the first time we schedule an interest
-  is_first_ = true;
-
-  // Reset the protocol state machine
-  reset();
-
-  // Schedule next interests
-  scheduleNextInterests();
-
-  is_first_ = false;
-
-  // Set the protocol as running
-  is_running_ = true;
-
-  if (!is_async_) {
-    // Start Event loop
-    portal_->runEventsLoop();
-
-    // Not running anymore
-    is_running_ = false;
+  if (isRunning()) {
+    return -1;
   }
 
-  return 0;
-}
-
-void TransportProtocol::stop() {
-  is_running_ = false;
+  // Start protocol on its own thread
+  portal_->getThread().add([this]() {
+    // Get all callbacks references
+    socket_->getSocketOption(ConsumerCallbacksOptions::INTEREST_RETRANSMISSION,
+                             &on_interest_retransmission_);
+    socket_->getSocketOption(ConsumerCallbacksOptions::INTEREST_OUTPUT,
+                             &on_interest_output_);
+    socket_->getSocketOption(ConsumerCallbacksOptions::INTEREST_EXPIRED,
+                             &on_interest_timeout_);
+    socket_->getSocketOption(ConsumerCallbacksOptions::INTEREST_SATISFIED,
+                             &on_interest_satisfied_);
+    socket_->getSocketOption(ConsumerCallbacksOptions::CONTENT_OBJECT_INPUT,
+                             &on_content_object_input_);
+    socket_->getSocketOption(ConsumerCallbacksOptions::STATS_SUMMARY,
+                             &stats_summary_);
+    socket_->getSocketOption(ConsumerCallbacksOptions::FWD_STRATEGY_CHANGE,
+                             &on_fwd_strategy_);
+    socket_->getSocketOption(ConsumerCallbacksOptions::REC_STRATEGY_CHANGE,
+                             &on_rec_strategy_);
+    socket_->getSocketOption(ConsumerCallbacksOptions::READ_CALLBACK,
+                             &on_payload_);
+
+    socket_->getSocketOption(GeneralTransportOptions::ASYNC_MODE, is_async_);
+
+    std::string fec_type_str = "";
+    socket_->getSocketOption(GeneralTransportOptions::FEC_TYPE, fec_type_str);
+    if (fec_type_str != "") {
+      fec_type_ = fec::FECUtils::fecTypeFromString(fec_type_str.c_str());
+    }
+
+    // Set it is the first time we schedule an interest
+    is_first_ = true;
+
+    // Reset the protocol state machine
+    reset();
+
+    // Set this transport protocol as portal's consumer callback
+    portal_->registerTransportCallback(this);
+
+    // Schedule next interests
+    scheduleNextInterests();
+
+    is_first_ = false;
+
+    // Set the protocol as running
+    setRunning();
+  });
 
-  if (!is_async_) {
-    portal_->stopEventsLoop();
-  } else {
-    portal_->clear();
-  }
+  return 0;
 }
 
 void TransportProtocol::resume() {
   if (isRunning()) return;
 
-  is_running_ = true;
+  setRunning();
 
-  scheduleNextInterests();
-
-  if (!is_async_) {
-    // Start Event loop
-    portal_->runEventsLoop();
-
-    // Not running anymore
-    is_running_ = false;
-  }
+  portal_->getThread().tryRunHandlerNow([this]() { scheduleNextInterests(); });
 }
 
 void TransportProtocol::reset() {
@@ -130,7 +123,7 @@ void TransportProtocol::reset() {
   }
 }
 
-void TransportProtocol::onContentReassembled(std::error_code ec) {
+void TransportProtocol::onContentReassembled(const std::error_code &ec) {
   stop();
 
   if (!on_payload_) {
@@ -153,7 +146,12 @@ void TransportProtocol::sendInterest(
     uint32_t len) {
   DLOG_IF(INFO, VLOG_IS_ON(3)) << "Sending interest for name " << interest_name;
 
-  auto interest = core::PacketManager<>::getInstance().getPacket<Interest>();
+  Packet::Format format;
+  socket_->getSocketOption(interface::GeneralTransportOptions::PACKET_FORMAT,
+                           format);
+
+  auto interest =
+      core::PacketManager<>::getInstance().getPacket<Interest>(format);
   interest->setName(interest_name);
 
   for (uint32_t i = 0; i < len; i++) {
@@ -176,6 +174,14 @@ void TransportProtocol::sendInterest(
   portal_->sendInterest(std::move(interest));
 }
 
+void TransportProtocol::onError(const std::error_code &ec) {
+  // error from portal: stop socket
+  stop();
+
+  // signal error to application
+  on_payload_->readError(ec);
+}
+
 void TransportProtocol::onTimeout(Interest::Ptr &i, const Name &n) {
   if (TRANSPORT_EXPECT_FALSE(!isRunning())) {
     return;
diff --git a/libtransport/src/protocols/transport_protocol.h b/libtransport/src/protocols/transport_protocol.h
index 1008a238b..ad8cf0346 100644
--- a/libtransport/src/protocols/transport_protocol.h
+++ b/libtransport/src/protocols/transport_protocol.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -19,10 +19,10 @@
 #include <hicn/transport/interfaces/socket_consumer.h>
 #include <hicn/transport/interfaces/statistics.h>
 #include <hicn/transport/utils/object_pool.h>
-#include <implementation/socket.h>
 #include <protocols/data_processing_events.h>
 #include <protocols/fec_base.h>
 #include <protocols/indexer.h>
+#include <protocols/protocol.h>
 #include <protocols/reassembly.h>
 
 #include <array>
@@ -38,8 +38,10 @@ class IndexVerificationManager;
 
 using ReadCallback = interface::ConsumerSocket::ReadCallback;
 
-class TransportProtocol : public core::Portal::ConsumerCallback,
-                          public ContentObjectProcessingEventCallback {
+class TransportProtocol
+    : public ContentObjectProcessingEventCallback,
+      public Protocol,
+      public std::enable_shared_from_this<TransportProtocol> {
   static constexpr std::size_t interest_pool_size = 4096;
 
   friend class ManifestIndexManager;
@@ -48,13 +50,11 @@ class TransportProtocol : public core::Portal::ConsumerCallback,
   TransportProtocol(implementation::ConsumerSocket *icn_socket,
                     Indexer *indexer, Reassembly *reassembly);
 
-  virtual ~TransportProtocol() = default;
-
-  TRANSPORT_ALWAYS_INLINE bool isRunning() { return is_running_; }
+  virtual ~TransportProtocol();
 
   virtual int start();
 
-  virtual void stop();
+  using Protocol::stop;
 
   virtual void resume();
 
@@ -69,7 +69,7 @@ class TransportProtocol : public core::Portal::ConsumerCallback,
   virtual void scheduleNextInterests() = 0;
 
   // Events generated by the indexing
-  virtual void onContentReassembled(std::error_code ec);
+  virtual void onContentReassembled(const std::error_code &ec);
   virtual void onPacketDropped(Interest &interest,
                                ContentObject &content_object,
                                const std::error_code &ec) override = 0;
@@ -90,7 +90,8 @@ class TransportProtocol : public core::Portal::ConsumerCallback,
                  AllocatorHandler &&allocator_handler) {
     if (!fec_decoder_) {
       // Try to get FEC from environment
-      if (const char *fec_str = std::getenv("TRANSPORT_FEC_TYPE")) {
+      const char *fec_str = std::getenv("TRANSPORT_FEC_TYPE");
+      if (fec_str && (fec_type_ == fec::FECType::UNKNOWN)) {
         LOG(INFO) << "Using FEC " << fec_str;
         fec_type_ = fec::FECUtils::fecTypeFromString(fec_str);
       }
@@ -114,14 +115,13 @@ class TransportProtocol : public core::Portal::ConsumerCallback,
   // Consumer Callback
   void onContentObject(Interest &i, ContentObject &c) override;
   void onTimeout(Interest::Ptr &i, const Name &n) override;
-  void onError(std::error_code ec) override {}
+  void onError(const std::error_code &ec) override;
 
  protected:
   implementation::ConsumerSocket *socket_;
   std::unique_ptr<Indexer> indexer_verifier_;
   std::unique_ptr<Reassembly> reassembly_;
   std::unique_ptr<fec::ConsumerFEC> fec_decoder_;
-  std::shared_ptr<core::Portal> portal_;
   // True if it si the first time we schedule an interest
   std::atomic<bool> is_first_;
   interface::TransportStatistics *stats_;
@@ -134,14 +134,13 @@ class TransportProtocol : public core::Portal::ConsumerCallback,
   interface::ConsumerContentObjectCallback *on_content_object_input_;
   interface::ConsumerContentObjectCallback *on_content_object_;
   interface::ConsumerTimerCallback *stats_summary_;
+  interface::StrategyCallback *on_fwd_strategy_;
+  interface::StrategyCallback *on_rec_strategy_;
   ReadCallback *on_payload_;
 
   bool is_async_;
 
   fec::FECType fec_type_;
-
- private:
-  std::atomic<bool> is_running_;
 };
 
 }  // end namespace protocol
diff --git a/libtransport/src/test/CMakeLists.txt b/libtransport/src/test/CMakeLists.txt
index 26fe7aee1..e7018ceed 100644
--- a/libtransport/src/test/CMakeLists.txt
+++ b/libtransport/src/test/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,42 +11,68 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-include(BuildMacros)
-
+##############################################################
+# Test sources
+##############################################################
 list(APPEND TESTS_SRC
   main.cc
+  test_aggregated_header.cc
   test_auth.cc
-  test_consumer_producer_rtc.cc
+  # test_consumer_producer_rtc.cc
   test_core_manifest.cc
-  test_event_thread.cc
+  # test_event_thread.cc
+  test_fec_base_rs.cc
   test_fec_reedsolomon.cc
+  test_fixed_block_allocator.cc
   test_indexer.cc
   test_interest.cc
   test_packet.cc
+  test_packet_allocator.cc
+  test_quality_score.cc
+  test_sessions.cc
+  test_thread_pool.cc
 )
 
 if (ENABLE_RELY)
   list(APPEND TESTS_SRC
     test_fec_rely_wrapper.cc
+    test_fec_base_rely.cc
+  )
+endif()
+
+if (UNIX AND NOT APPLE)
+  list(APPEND TESTS_SRC
+    test_memif_connector.cc
   )
 endif()
 
-build_executable(unit_tests
+
+##############################################################
+# Link libraries
+##############################################################
+set(MEMIF_MODULE_LIBRARIES
+  ${LIBRARIES}
+  ${LIBTRANSPORT_SHARED}
+  ${GTEST_LIBRARIES}
+)
+
+
+##############################################################
+# Build single unit test executable and add it to test list
+##############################################################
+build_executable(libtransport_tests
     NO_INSTALL
     SOURCES ${TESTS_SRC}
     LINK_LIBRARIES
-      ${LIBRARIES}
-      ${LIBTRANSPORT_STATIC}
-      ${GTEST_LIBRARIES}
+      ${MEMIF_MODULE_LIBRARIES}
     INCLUDE_DIRS
-      ${LIBTRANSPORT_INCLUDE_DIRS}
-      ${LIBHICN_INCLUDE_DIRS}
-      ${LIBTRANSPORT_INTERNAL_INCLUDE_DIRS}
+      $<TARGET_PROPERTY:${LIBTRANSPORT_SHARED},INCLUDE_DIRECTORIES>
       ${GTEST_INCLUDE_DIRS}
     DEPENDS gtest ${LIBTRANSPORT_SHARED}
     COMPONENT ${LIBTRANSPORT_COMPONENT}
-    DEFINITIONS "${COMPILER_DEFINITIONS}"
+    DEFINITIONS ${COMPILER_DEFINITIONS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS}
     LINK_FLAGS ${LINK_FLAGS}
 )
 
-add_test_internal(unit_tests)
+add_test_internal(libtransport_tests)
diff --git a/libtransport/src/test/main.cc b/libtransport/src/test/main.cc
index a4d7ce1b3..591ed0d5b 100644
--- a/libtransport/src/test/main.cc
+++ b/libtransport/src/test/main.cc
@@ -16,7 +16,6 @@
 #include <gtest/gtest.h>
 
 int main(int argc, char **argv) {
-  srand(time(0));
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
\ No newline at end of file
diff --git a/libtransport/src/test/test_aggregated_header.cc b/libtransport/src/test/test_aggregated_header.cc
new file mode 100644
index 000000000..0d88af5ab
--- /dev/null
+++ b/libtransport/src/test/test_aggregated_header.cc
@@ -0,0 +1,622 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <hicn/transport/errors/not_implemented_exception.h>
+#include <protocols/rtc/rtc_packet.h>
+#include <test/packet_samples.h>
+
+#include <climits>
+#include <random>
+#include <vector>
+
+namespace transport {
+
+namespace core {
+
+namespace {
+// The fixture for testing class Foo.
+class AggregatedPktHeaderTest : public ::testing::Test {
+ protected:
+  AggregatedPktHeaderTest() {
+    // You can do set-up work for each test here.
+  }
+
+  virtual ~AggregatedPktHeaderTest() {
+    // You can do clean-up work that doesn't throw exceptions here.
+  }
+
+  // If the constructor and destructor are not enough for setting up
+  // and cleaning up each test, you can define the following methods:
+
+  virtual void SetUp() {
+    // Code here will be called immediately after the constructor (right
+    // before each test).
+  }
+
+  virtual void TearDown() {
+    // Code here will be called immediately after each test (right
+    // before the destructor).
+  }
+};
+
+}  // namespace
+
+TEST_F(AggregatedPktHeaderTest, Add2Packets8bit) {
+  uint8_t buf[1500];
+  std::vector<uint8_t> pkt1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
+  uint16_t pkt1_len = 14;
+
+  std::vector<uint8_t> pkt2 = {11, 12, 13, 14, 15, 16, 17};
+  uint16_t pkt2_len = 7;
+
+  for (uint16_t i = 0; i < 1500; i++) {
+    buf[i] = 0;
+  }
+
+  // skip protocol::rtc::DATA_HEADER_SIZE that will be the rtc header
+  protocol::rtc::AggrPktHeader hdr(buf + protocol::rtc::DATA_HEADER_SIZE,
+                                   pkt1_len, 2);
+  hdr.addPacketToHeader(0, pkt1_len);
+  hdr.addPacketToHeader(1, pkt2_len);
+  uint8_t* ptr = hdr.getPayloadAppendPtr();
+
+  // copy packet 1
+  for (uint16_t i = 0; i < pkt1_len; i++) {
+    *(ptr + i) = pkt1[i];
+  }
+
+  // copy packet 2
+  for (uint16_t i = 0; i < pkt2_len; i++) {
+    *(ptr + i + pkt1_len) = pkt2[i];
+  }
+
+  // print
+  // for (uint16_t i = 0; i < 40; i++){
+  //  std::cout << (int) i << " " << (int) buf[i] << std::endl;
+  //}
+
+  uint8_t* pkt_ptr = nullptr;
+  uint16_t pkt_len = 0;
+
+  hdr.getPointerToPacket(0, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt1_len);
+  for (uint16_t i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt1[i]);
+  }
+
+  hdr.getPointerToPacket(1, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt2_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt2[i]);
+  }
+}
+
+TEST_F(AggregatedPktHeaderTest, Add2Packets8bit255) {
+  uint8_t buf[1500];
+
+  std::vector<uint8_t> pkt1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
+  uint16_t pkt1_len = 14;
+
+  std::vector<uint8_t> pkt2 = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 20
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 40
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 60
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 80
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 100
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 120
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 140
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 160
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 180
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 200
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 220
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 240
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14};  // 255
+  uint16_t pkt2_len = 255;
+
+  for (uint16_t i = 0; i < 1500; i++) {
+    buf[i] = 0;
+  }
+
+  // skip protocol::rtc::DATA_HEADER_SIZE that will be the rtc header
+  protocol::rtc::AggrPktHeader hdr(buf + protocol::rtc::DATA_HEADER_SIZE,
+                                   pkt2_len, 2);
+  hdr.addPacketToHeader(0, pkt1_len);
+  hdr.addPacketToHeader(1, pkt2_len);
+  uint8_t* ptr = hdr.getPayloadAppendPtr();
+
+  // copy packet 1
+  for (uint16_t i = 0; i < pkt1_len; i++) {
+    *(ptr + i) = pkt1[i];
+  }
+
+  // copy packet 2
+  for (uint16_t i = 0; i < pkt2_len; i++) {
+    *(ptr + i + pkt1_len) = pkt2[i];
+  }
+
+  uint8_t* pkt_ptr = nullptr;
+  uint16_t pkt_len = 0;
+
+  hdr.getPointerToPacket(0, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt1_len);
+  for (uint16_t i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt1[i]);
+  }
+
+  hdr.getPointerToPacket(1, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt2_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt2[i]);
+  }
+}
+
+TEST_F(AggregatedPktHeaderTest, Add2Packets8bit256) {
+  uint8_t buf[1500];
+
+  std::vector<uint8_t> pkt1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
+  uint16_t pkt1_len = 14;
+
+  std::vector<uint8_t> pkt2 = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 20
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 40
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 60
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 80
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 100
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 120
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 140
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 160
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 180
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 200
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 220
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 240
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15};  // 256
+  uint16_t pkt2_len = 256;
+
+  for (uint16_t i = 0; i < 1500; i++) {
+    buf[i] = 0;
+  }
+
+  // skip protocol::rtc::DATA_HEADER_SIZE that will be the rtc header
+  protocol::rtc::AggrPktHeader hdr(buf + protocol::rtc::DATA_HEADER_SIZE,
+                                   pkt2_len, 2);
+  hdr.addPacketToHeader(0, pkt1_len);
+  hdr.addPacketToHeader(1, pkt2_len);
+  uint8_t* ptr = hdr.getPayloadAppendPtr();
+
+  // copy packet 1
+  for (uint16_t i = 0; i < pkt1_len; i++) {
+    *(ptr + i) = pkt1[i];
+  }
+
+  // copy packet 2
+  for (uint16_t i = 0; i < pkt2_len; i++) {
+    *(ptr + i + pkt1_len) = pkt2[i];
+  }
+
+  uint8_t* pkt_ptr = nullptr;
+  uint16_t pkt_len = 0;
+
+  hdr.getPointerToPacket(0, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt1_len);
+  for (uint16_t i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt1[i]);
+  }
+
+  hdr.getPointerToPacket(1, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt2_len);
+  for (uint16_t i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt2[i]);
+  }
+}
+
+TEST_F(AggregatedPktHeaderTest, Add4Packets8bit) {
+  uint8_t buf[1500];
+
+  std::vector<uint8_t> pkt1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
+  uint16_t pkt1_len = 14;
+
+  std::vector<uint8_t> pkt2 = {11, 12, 13, 14, 15, 16, 17};
+  uint16_t pkt2_len = 7;
+
+  std::vector<uint8_t> pkt3 = {21, 22, 23, 24, 25, 26, 27, 28, 29, 30};
+  uint16_t pkt3_len = 10;
+
+  std::vector<uint8_t> pkt4 = {100, 110};
+  uint16_t pkt4_len = 2;
+
+  for (uint16_t i = 0; i < 1500; i++) {
+    buf[i] = 0;
+  }
+
+  // skip protocol::rtc::DATA_HEADER_SIZE that will be the rtc header
+  protocol::rtc::AggrPktHeader hdr(buf + protocol::rtc::DATA_HEADER_SIZE,
+                                   pkt1_len, 4);
+  hdr.addPacketToHeader(0, pkt1_len);
+  hdr.addPacketToHeader(1, pkt2_len);
+  hdr.addPacketToHeader(2, pkt3_len);
+  hdr.addPacketToHeader(3, pkt4_len);
+  uint8_t* ptr = hdr.getPayloadAppendPtr();
+
+  // copy packet 1
+  for (uint16_t i = 0; i < pkt1_len; i++) {
+    *(ptr + i) = pkt1[i];
+  }
+
+  // copy packet 2
+  for (uint16_t i = 0; i < pkt2_len; i++) {
+    *(ptr + i + pkt1_len) = pkt2[i];
+  }
+
+  // copy packet 3
+  for (uint16_t i = 0; i < pkt3_len; i++) {
+    *(ptr + i + pkt1_len + pkt2_len) = pkt3[i];
+  }
+
+  // copy packet 2
+  for (uint16_t i = 0; i < pkt4_len; i++) {
+    *(ptr + i + pkt1_len + pkt2_len + pkt3_len) = pkt4[i];
+  }
+
+  uint8_t* pkt_ptr = nullptr;
+  uint16_t pkt_len = 0;
+
+  hdr.getPointerToPacket(0, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt1_len);
+  for (uint16_t i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt1[i]);
+  }
+
+  hdr.getPointerToPacket(1, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt2_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt2[i]);
+  }
+
+  hdr.getPointerToPacket(2, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt3_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt3[i]);
+  }
+
+  hdr.getPointerToPacket(3, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt4_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt4[i]);
+  }
+}
+
+TEST_F(AggregatedPktHeaderTest, Add4Packets16bit) {
+  uint8_t buf[1500];
+
+  std::vector<uint8_t> pkt1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
+  uint16_t pkt1_len = 14;
+
+  std::vector<uint8_t> pkt2 = {11, 12, 13, 14, 15, 16, 17};
+  uint16_t pkt2_len = 7;
+
+  std::vector<uint8_t> pkt3 = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 20
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 40
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 60
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 80
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 100
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 120
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 140
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 160
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 180
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 200
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 220
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 240
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19};  // 260
+  uint16_t pkt3_len = 260;
+
+  std::vector<uint8_t> pkt4 = {100, 110};
+  uint16_t pkt4_len = 2;
+
+  for (uint16_t i = 0; i < 1500; i++) {
+    buf[i] = 0;
+  }
+
+  // skip protocol::rtc::DATA_HEADER_SIZE that will be the rtc header
+  protocol::rtc::AggrPktHeader hdr(buf + protocol::rtc::DATA_HEADER_SIZE,
+                                   pkt3_len, 4);
+  hdr.addPacketToHeader(0, pkt1_len);
+  hdr.addPacketToHeader(1, pkt2_len);
+  hdr.addPacketToHeader(2, pkt3_len);
+  hdr.addPacketToHeader(3, pkt4_len);
+  uint8_t* ptr = hdr.getPayloadAppendPtr();
+
+  // copy packet 1
+  for (uint16_t i = 0; i < pkt1_len; i++) {
+    *(ptr + i) = pkt1[i];
+  }
+
+  // copy packet 2
+  for (uint16_t i = 0; i < pkt2_len; i++) {
+    *(ptr + i + pkt1_len) = pkt2[i];
+  }
+
+  // copy packet 3
+  for (uint16_t i = 0; i < pkt3_len; i++) {
+    *(ptr + i + pkt1_len + pkt2_len) = pkt3[i];
+  }
+
+  // copy packet 2
+  for (uint16_t i = 0; i < pkt4_len; i++) {
+    *(ptr + i + pkt1_len + pkt2_len + pkt3_len) = pkt4[i];
+  }
+
+  uint8_t* pkt_ptr = nullptr;
+  uint16_t pkt_len = 0;
+
+  hdr.getPointerToPacket(0, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt1_len);
+  for (uint16_t i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt1[i]);
+  }
+
+  hdr.getPointerToPacket(1, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt2_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt2[i]);
+  }
+
+  hdr.getPointerToPacket(2, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt3_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt3[i]);
+  }
+
+  hdr.getPointerToPacket(3, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt4_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt4[i]);
+  }
+}
+
+TEST_F(AggregatedPktHeaderTest, Defrag4Packets8bit) {
+  uint8_t buf[1500];
+
+  std::vector<uint8_t> pkt1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
+  uint16_t pkt1_len = 14;
+
+  std::vector<uint8_t> pkt2 = {11, 12, 13, 14, 15, 16, 17};
+  uint16_t pkt2_len = 7;
+
+  std::vector<uint8_t> pkt3 = {21, 22, 23, 24, 25, 26, 27, 28, 29, 30};
+  uint16_t pkt3_len = 10;
+
+  std::vector<uint8_t> pkt4 = {100, 110};
+  uint16_t pkt4_len = 2;
+
+  for (uint16_t i = 0; i < 1500; i++) {
+    buf[i] = 0;
+  }
+
+  // skip protocol::rtc::DATA_HEADER_SIZE that will be the rtc header
+  protocol::rtc::AggrPktHeader hdr(buf + protocol::rtc::DATA_HEADER_SIZE,
+                                   pkt1_len, 4);
+  hdr.addPacketToHeader(0, pkt1_len);
+  hdr.addPacketToHeader(1, pkt2_len);
+  hdr.addPacketToHeader(2, pkt3_len);
+  hdr.addPacketToHeader(3, pkt4_len);
+
+  uint16_t offset = protocol::rtc::DATA_HEADER_SIZE + 8;  // 8 = aggr hdr
+
+  // copy packet 1
+  for (uint16_t i = 0; i < pkt1_len; i++) {
+    buf[i + offset] = pkt1[i];
+  }
+  offset += pkt1_len;
+
+  // copy packet 2
+  for (uint16_t i = 0; i < pkt2_len; i++) {
+    buf[i + offset] = pkt2[i];
+  }
+  offset += pkt2_len;
+
+  // copy packet 3
+  for (uint16_t i = 0; i < pkt3_len; i++) {
+    buf[i + offset] = pkt3[i];
+  }
+  offset += pkt3_len;
+
+  // copy packet 2
+  for (uint16_t i = 0; i < pkt4_len; i++) {
+    buf[i + offset] = pkt4[i];
+  }
+
+  protocol::rtc::AggrPktHeader hdr2(buf + protocol::rtc::DATA_HEADER_SIZE);
+
+  uint8_t* pkt_ptr = nullptr;
+  uint16_t pkt_len = 0;
+
+  uint8_t packet_number = hdr2.getNumberOfPackets();
+  EXPECT_EQ(packet_number, 4);
+
+  hdr2.getPointerToPacket(0, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt1_len);
+  for (uint16_t i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt1[i]);
+  }
+
+  hdr2.getPointerToPacket(1, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt2_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt2[i]);
+  }
+
+  hdr2.getPointerToPacket(2, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt3_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt3[i]);
+  }
+
+  hdr2.getPointerToPacket(3, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt4_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt4[i]);
+  }
+}
+
+TEST_F(AggregatedPktHeaderTest, Defrag4Packets16bit) {
+  uint8_t buf[1500];
+
+  std::vector<uint8_t> pkt1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
+  uint16_t pkt1_len = 14;
+
+  std::vector<uint8_t> pkt2 = {11, 12, 13, 14, 15, 16, 17};
+  uint16_t pkt2_len = 7;
+
+  std::vector<uint8_t> pkt3 = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 20
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 40
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 60
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 80
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 100
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 120
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 140
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 160
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 180
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 200
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 220
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  // 240
+                               0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                               10, 11, 12, 13, 14, 15, 16, 17, 18, 19};  // 260
+  uint16_t pkt3_len = 260;
+
+  std::vector<uint8_t> pkt4 = {100, 110};
+  uint16_t pkt4_len = 2;
+
+  for (uint16_t i = 0; i < 1500; i++) {
+    buf[i] = 0;
+  }
+
+  // skip protocol::rtc::DATA_HEADER_SIZE that will be the rtc header
+  protocol::rtc::AggrPktHeader hdr(buf + protocol::rtc::DATA_HEADER_SIZE,
+                                   pkt3_len, 4);
+  hdr.addPacketToHeader(0, pkt1_len);
+  hdr.addPacketToHeader(1, pkt2_len);
+  hdr.addPacketToHeader(2, pkt3_len);
+  hdr.addPacketToHeader(3, pkt4_len);
+
+  uint16_t offset = protocol::rtc::DATA_HEADER_SIZE + 12;  // 12 = aggr hdr
+
+  // copy packet 1
+  for (uint16_t i = 0; i < pkt1_len; i++) {
+    buf[i + offset] = pkt1[i];
+  }
+  offset += pkt1_len;
+
+  // copy packet 2
+  for (uint16_t i = 0; i < pkt2_len; i++) {
+    buf[i + offset] = pkt2[i];
+  }
+  offset += pkt2_len;
+
+  // copy packet 3
+  for (uint16_t i = 0; i < pkt3_len; i++) {
+    buf[i + offset] = pkt3[i];
+  }
+  offset += pkt3_len;
+
+  // copy packet 2
+  for (uint16_t i = 0; i < pkt4_len; i++) {
+    buf[i + offset] = pkt4[i];
+  }
+
+  protocol::rtc::AggrPktHeader hdr2(buf + protocol::rtc::DATA_HEADER_SIZE);
+
+  uint8_t* pkt_ptr = nullptr;
+  uint16_t pkt_len = 0;
+
+  uint8_t packet_number = hdr2.getNumberOfPackets();
+  EXPECT_EQ(packet_number, 4);
+
+  hdr2.getPointerToPacket(0, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt1_len);
+  for (uint16_t i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt1[i]);
+  }
+
+  hdr2.getPointerToPacket(1, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt2_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt2[i]);
+  }
+
+  hdr2.getPointerToPacket(2, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt3_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt3[i]);
+  }
+
+  hdr2.getPointerToPacket(3, &pkt_ptr, &pkt_len);
+  EXPECT_EQ(pkt_len, pkt4_len);
+  for (int i = 0; i < pkt_len; i++) {
+    EXPECT_EQ(*(pkt_ptr + i), pkt4[i]);
+  }
+}
+
+}  // namespace core
+}  // namespace transport
diff --git a/libtransport/src/test/test_auth.cc b/libtransport/src/test/test_auth.cc
index db1c3b52f..d7fd55433 100644
--- a/libtransport/src/test/test_auth.cc
+++ b/libtransport/src/test/test_auth.cc
@@ -15,10 +15,15 @@
 
 #include <gtest/gtest.h>
 #include <hicn/transport/auth/crypto_hash.h>
-#include <hicn/transport/auth/identity.h>
 #include <hicn/transport/auth/signer.h>
 #include <hicn/transport/auth/verifier.h>
 #include <hicn/transport/core/content_object.h>
+#include <openssl/rand.h>
+
+using BN_ptr = std::unique_ptr<BIGNUM, decltype(&::BN_free)>;
+using RSA_ptr = std::unique_ptr<RSA, decltype(&::RSA_free)>;
+using EC_KEY_ptr = std::unique_ptr<EC_KEY, decltype(&::EC_KEY_free)>;
+using DSA_ptr = std::unique_ptr<DSA, decltype(&::DSA_free)>;
 
 namespace transport {
 namespace auth {
@@ -50,11 +55,23 @@ TEST_F(AuthTest, VoidVerifier) {
 }
 
 TEST_F(AuthTest, AsymmetricRSA) {
-  // Create the RSA signer from an Identity object
-  Identity identity("test_rsa.p12", PASSPHRASE, CryptoSuite::RSA_SHA256, 1024u,
-                    30, "RSAVerifier");
-
-  std::shared_ptr<Signer> signer = identity.getSigner();
+  // Create the RSA keys
+  std::shared_ptr<EVP_PKEY> privateKey(EVP_PKEY_new(), EVP_PKEY_free);
+  std::shared_ptr<EVP_PKEY> pubKey(EVP_PKEY_new(), EVP_PKEY_free);
+  RSA_ptr rsa(RSA_new(), ::RSA_free);
+  BN_ptr pub_exp(BN_new(), ::BN_free);
+
+  BN_set_word(pub_exp.get(), RSA_F4);
+  if (1 != RSA_generate_key_ex(rsa.get(), 2048u, pub_exp.get(), NULL))
+    throw errors::RuntimeException("can't generate the key");
+  RSA_ptr rsa_pub(RSAPublicKey_dup(rsa.get()), ::RSA_free);
+  RSA_ptr rsa_priv(RSAPrivateKey_dup(rsa.get()), ::RSA_free);
+  if (1 != EVP_PKEY_set1_RSA(pubKey.get(), rsa_pub.get()))
+    throw errors::RuntimeException("can't generate the key");
+  if (1 != EVP_PKEY_set1_RSA(privateKey.get(), rsa_priv.get()))
+    throw errors::RuntimeException("can't generate the key");
+  std::shared_ptr<AsymmetricSigner> signer = std::make_shared<AsymmetricSigner>(
+      CryptoSuite::RSA_SHA256, privateKey, pubKey);
 
   // Create a content object
   core::ContentObject packet(HF_INET6_TCP_AH, signer->getSignatureSize());
@@ -68,61 +85,112 @@ TEST_F(AuthTest, AsymmetricRSA) {
 
   // Create the RSA verifier
   std::shared_ptr<Verifier> verifier =
-      std::make_shared<AsymmetricVerifier>(identity.getCertificate());
+      std::make_shared<AsymmetricVerifier>(pubKey);
 
   EXPECT_EQ(packet.getFormat(), HF_INET6_TCP_AH);
   EXPECT_EQ(signer->getHashType(), CryptoHashType::SHA256);
   EXPECT_EQ(signer->getSuite(), CryptoSuite::RSA_SHA256);
-  EXPECT_EQ(signer->getSignatureSize(), 128u);
+  EXPECT_EQ(signer->getSignatureSize(), 256u);
   EXPECT_EQ(verifier->verifyPackets(&packet), VerificationPolicy::ACCEPT);
 }
 
 TEST_F(AuthTest, AsymmetricBufferRSA) {
-  // Create the RSA signer from an Identity object
-  Identity identity("test_rsa.p12", PASSPHRASE, CryptoSuite::RSA_SHA256, 1024u,
-                    30, "RSAVerifier");
+  // Create the RSA keys
+  std::shared_ptr<EVP_PKEY> privateKey(EVP_PKEY_new(), EVP_PKEY_free);
+  std::shared_ptr<EVP_PKEY> pubKey(EVP_PKEY_new(), EVP_PKEY_free);
+  RSA_ptr rsa(RSA_new(), ::RSA_free);
+  BN_ptr pub_exp(BN_new(), ::BN_free);
+
+  BN_set_word(pub_exp.get(), RSA_F4);
+  if (1 != RSA_generate_key_ex(rsa.get(), 2048u, pub_exp.get(), NULL))
+    throw errors::RuntimeException("can't generate the key");
+  RSA_ptr rsa_pub(RSAPublicKey_dup(rsa.get()), ::RSA_free);
+  RSA_ptr rsa_priv(RSAPrivateKey_dup(rsa.get()), ::RSA_free);
+  if (1 != EVP_PKEY_set1_RSA(pubKey.get(), rsa_pub.get()))
+    throw errors::RuntimeException("can't generate the key");
+  if (1 != EVP_PKEY_set1_RSA(privateKey.get(), rsa_priv.get()))
+    throw errors::RuntimeException("can't generate the key");
+  std::shared_ptr<AsymmetricSigner> signer = std::make_shared<AsymmetricSigner>(
+      CryptoSuite::RSA_SHA256, privateKey, pubKey);
 
-  std::shared_ptr<AsymmetricSigner> signer = identity.getSigner();
   std::string payload = "bonjour";
 
   std::vector<uint8_t> buffer(payload.begin(), payload.end());
   signer->signBuffer(buffer);
   std::vector<uint8_t> sig = signer->getSignature();
 
-  std::shared_ptr<X509> cert = identity.getCertificate();
-  AsymmetricVerifier verif(cert);
-  bool res = verif.verifyBuffer(
+  std::shared_ptr<AsymmetricVerifier> verif =
+      std::make_shared<AsymmetricVerifier>(pubKey);
+  bool res = verif->verifyBuffer(
       buffer, std::vector<uint8_t>(sig.data(), sig.data() + sig.size()),
       CryptoHashType::SHA256);
   EXPECT_EQ(res, true);
 }
 
 TEST_F(AuthTest, AsymmetricBufferDSA) {
-  // Create the DSA signer from an Identity object
-  Identity identity("test_dsa.p12", PASSPHRASE, CryptoSuite::DSA_SHA256, 1024u,
-                    30, "DSAVerifier");
+  // Create the DSA keys
+
+  std::shared_ptr<EVP_PKEY> privateKey(EVP_PKEY_new(), EVP_PKEY_free);
+
+  DSA_ptr dsa(DSA_new(), ::DSA_free);
+  unsigned char buf[32];
+  if (RAND_bytes(buf, sizeof(buf)) != 1) {
+    throw errors::RuntimeException("can't generate the key");
+  }
+  if (DSA_generate_parameters_ex(dsa.get(), 1024u, buf, sizeof(buf), NULL, NULL,
+                                 NULL) != 1)
+    throw errors::RuntimeException("can't generate the key");
+  if (DSA_generate_key(dsa.get()) != 1)
+    throw errors::RuntimeException("can't generate the key");
+  if (EVP_PKEY_set1_DSA(privateKey.get(), dsa.get()) != 1)
+    throw errors::RuntimeException("can't generate the key");
+  if (1 != EVP_PKEY_set1_DSA(privateKey.get(), dsa.get()))
+    throw errors::RuntimeException("can't generate the key");
+
+  std::shared_ptr<X509> cert(X509_new(), ::X509_free);
+  X509_set_pubkey(cert.get(), privateKey.get());
+  std::shared_ptr<EVP_PKEY> pubKey(X509_get_pubkey(cert.get()), EVP_PKEY_free);
+  std::shared_ptr<AsymmetricSigner> signer = std::make_shared<AsymmetricSigner>(
+      CryptoSuite::DSA_SHA256, privateKey, pubKey);
 
-  std::shared_ptr<AsymmetricSigner> signer = identity.getSigner();
   std::string payload = "bonjour";
 
   std::vector<uint8_t> buffer(payload.begin(), payload.end());
   signer->signBuffer(buffer);
   std::vector<uint8_t> sig = signer->getSignature();
 
-  std::shared_ptr<X509> cert = identity.getCertificate();
-  AsymmetricVerifier verif(cert);
-  bool res = verif.verifyBuffer(
+  std::shared_ptr<AsymmetricVerifier> verif =
+      std::make_shared<AsymmetricVerifier>(pubKey);
+  bool res = verif->verifyBuffer(
       buffer, std::vector<uint8_t>(sig.data(), sig.data() + sig.size()),
       CryptoHashType::SHA256);
   EXPECT_EQ(res, true);
 }
 
 TEST_F(AuthTest, AsymmetricVerifierDSA) {
-  // Create the DSA signer from an Identity object
-  Identity identity("test_dsa.p12", PASSPHRASE, CryptoSuite::DSA_SHA256, 1024u,
-                    30, "DSAVerifier");
+  // Create the DSA keys
+  std::shared_ptr<EVP_PKEY> privateKey(EVP_PKEY_new(), EVP_PKEY_free);
 
-  std::shared_ptr<Signer> signer = identity.getSigner();
+  DSA_ptr dsa(DSA_new(), ::DSA_free);
+  unsigned char buf[32];
+  if (RAND_bytes(buf, sizeof(buf)) != 1) {
+    throw errors::RuntimeException("can't generate the key");
+  }
+  if (DSA_generate_parameters_ex(dsa.get(), 1024u, buf, sizeof(buf), NULL, NULL,
+                                 NULL) != 1)
+    throw errors::RuntimeException("can't generate the key");
+  if (DSA_generate_key(dsa.get()) != 1)
+    throw errors::RuntimeException("can't generate the key");
+  if (EVP_PKEY_set1_DSA(privateKey.get(), dsa.get()) != 1)
+    throw errors::RuntimeException("can't generate the key");
+  if (1 != EVP_PKEY_set1_DSA(privateKey.get(), dsa.get()))
+    throw errors::RuntimeException("can't generate the key");
+
+  std::shared_ptr<X509> cert(X509_new(), ::X509_free);
+  X509_set_pubkey(cert.get(), privateKey.get());
+  std::shared_ptr<EVP_PKEY> pubKey(X509_get_pubkey(cert.get()), EVP_PKEY_free);
+  std::shared_ptr<AsymmetricSigner> signer = std::make_shared<AsymmetricSigner>(
+      CryptoSuite::DSA_SHA256, privateKey, pubKey);
 
   // Create a content object
   core::ContentObject packet(HF_INET6_TCP_AH, signer->getSignatureSize());
@@ -134,7 +202,7 @@ TEST_F(AuthTest, AsymmetricVerifierDSA) {
   // EXPECT_EQ(signer->getSignatureSize(), 256u);
   signer->signPacket(&packet);
   std::shared_ptr<Verifier> verifier =
-      std::make_shared<AsymmetricVerifier>(identity.getCertificate());
+      std::make_shared<AsymmetricVerifier>(cert);
 
   EXPECT_EQ(packet.getFormat(), HF_INET6_TCP_AH);
   EXPECT_EQ(signer->getHashType(), CryptoHashType::SHA256);
@@ -143,33 +211,59 @@ TEST_F(AuthTest, AsymmetricVerifierDSA) {
 }
 
 TEST_F(AuthTest, AsymmetricBufferECDSA) {
-  // Create the ECDSA signer from an Identity object
-  Identity identity("test_ecdsa.p12", PASSPHRASE, CryptoSuite::ECDSA_SHA256,
-                    256u, 30, "ECDSAVerifier");
+  // Create the ECDSA keys
+  std::shared_ptr<EVP_PKEY> privateKey(EVP_PKEY_new(), EVP_PKEY_free);
+  std::shared_ptr<EVP_PKEY> pubKey(EVP_PKEY_new(), EVP_PKEY_free);
+  EC_KEY_ptr ec_priv(EC_KEY_new_by_curve_name(NID_secp256k1), ::EC_KEY_free);
+  EC_KEY_ptr ec_pub(EC_KEY_new(), ::EC_KEY_free);
+  EC_KEY_set_asn1_flag(ec_priv.get(), OPENSSL_EC_NAMED_CURVE);
+  if (EC_KEY_generate_key(ec_priv.get()) == 0)
+    throw errors::RuntimeException("can't generate the ecdsa key");
+  if (1 != EVP_PKEY_set1_EC_KEY(privateKey.get(), ec_priv.get()))
+    throw errors::RuntimeException("can't generate the key");
+  EC_KEY_set_group(ec_pub.get(), EC_KEY_get0_group(ec_priv.get()));
+  EC_KEY_set_public_key(ec_pub.get(), EC_KEY_get0_public_key(ec_priv.get()));
+  if (1 != EVP_PKEY_set1_EC_KEY(pubKey.get(), ec_pub.get()))
+    throw errors::RuntimeException("can't generate the key");
+
+  std::shared_ptr<AsymmetricSigner> signer = std::make_shared<AsymmetricSigner>(
+      CryptoSuite::ECDSA_SHA256, privateKey, pubKey);
 
-  std::shared_ptr<AsymmetricSigner> signer = identity.getSigner();
   std::string payload = "bonjour";
 
   std::vector<uint8_t> buffer(payload.begin(), payload.end());
   signer->signBuffer(buffer);
   std::vector<uint8_t> sig = signer->getSignature();
 
-  std::shared_ptr<X509> cert = identity.getCertificate();
-  AsymmetricVerifier verif(cert);
-  bool res = verif.verifyBuffer(
+  std::shared_ptr<AsymmetricVerifier> verif =
+      std::make_shared<AsymmetricVerifier>(pubKey);
+  bool res = verif->verifyBuffer(
       buffer, std::vector<uint8_t>(sig.data(), sig.data() + sig.size()),
       CryptoHashType::SHA256);
   EXPECT_EQ(res, true);
-}
+}  // namespace auth
 
 TEST_F(AuthTest, AsymmetricVerifierECDSA) {
-  Identity identity("test_ecdsa.p12", PASSPHRASE, CryptoSuite::ECDSA_SHA256,
-                    256u, 30, "ECDSAVerifier");
-
-  std::shared_ptr<Signer> signer = identity.getSigner();
-  std::shared_ptr<Verifier> verifier =
-      std::make_shared<AsymmetricVerifier>(identity.getCertificate());
-  // Create a content object
+  // Create the ECDSA keys
+  std::shared_ptr<EVP_PKEY> privateKey(EVP_PKEY_new(), EVP_PKEY_free);
+  std::shared_ptr<EVP_PKEY> pubKey(EVP_PKEY_new(), EVP_PKEY_free);
+  EC_KEY_ptr ec_priv(EC_KEY_new_by_curve_name(NID_secp256k1), ::EC_KEY_free);
+  EC_KEY_ptr ec_pub(EC_KEY_new(), ::EC_KEY_free);
+  EC_KEY_set_asn1_flag(ec_priv.get(), OPENSSL_EC_NAMED_CURVE);
+  if (EC_KEY_generate_key(ec_priv.get()) == 0)
+    throw errors::RuntimeException("can't generate the ecdsa key");
+  if (1 != EVP_PKEY_set1_EC_KEY(privateKey.get(), ec_priv.get()))
+    throw errors::RuntimeException("can't generate the key");
+  EC_KEY_set_group(ec_pub.get(), EC_KEY_get0_group(ec_priv.get()));
+  EC_KEY_set_public_key(ec_pub.get(), EC_KEY_get0_public_key(ec_priv.get()));
+  if (1 != EVP_PKEY_set1_EC_KEY(pubKey.get(), ec_pub.get()))
+    throw errors::RuntimeException("can't generate the key");
+
+  std::shared_ptr<AsymmetricSigner> signer = std::make_shared<AsymmetricSigner>(
+      CryptoSuite::ECDSA_SHA256, privateKey, pubKey);
+
+  std::shared_ptr<AsymmetricVerifier> verifier =
+      std::make_shared<AsymmetricVerifier>(pubKey);
   for (int i = 0; i < 100; i++) {
     core::ContentObject packet(HF_INET6_TCP_AH, signer->getSignatureSize());
 
diff --git a/libtransport/src/test/test_consumer_producer_rtc.cc b/libtransport/src/test/test_consumer_producer_rtc.cc
index 8541a9e1a..b11a6a388 100644
--- a/libtransport/src/test/test_consumer_producer_rtc.cc
+++ b/libtransport/src/test/test_consumer_producer_rtc.cc
@@ -41,7 +41,7 @@ class ConsumerProducerTest : public ::testing::Test,
         rtc_timer_(io_service_),
         stop_timer_(io_service_),
         consumer_(TransportProtocolAlgorithms::RTC, io_service_),
-        producer_(ProductionProtocolAlgorithms::RTC_PROD, io_service_),
+        producer_(ProductionProtocolAlgorithms::RTC_PROD, thread_),
         producer_prefix_(prefix),
         consumer_name_(name),
         packets_sent_(0),
@@ -120,14 +120,13 @@ class ConsumerProducerTest : public ::testing::Test,
 
   size_t maxBufferSize() const override { return receive_buffer_size; }
 
-  void readError(const std::error_code ec) noexcept override {
-    FAIL() << "Error while reading from RTC socket";
+  void readError(const std::error_code &ec) noexcept override {
     io_service_.stop();
+    FAIL() << "Error while reading from RTC socket";
   }
 
   void readSuccess(std::size_t total_size) noexcept override {
     packets_received_++;
-    std::cout << "Received something" << std::endl;
   }
 
   asio::io_service io_service_;
diff --git a/libtransport/src/test/test_core_manifest.cc b/libtransport/src/test/test_core_manifest.cc
index 93f4e87cb..23fd5e342 100644
--- a/libtransport/src/test/test_core_manifest.cc
+++ b/libtransport/src/test/test_core_manifest.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -17,6 +17,8 @@
 #include <core/manifest_inline.h>
 #include <gtest/gtest.h>
 #include <hicn/transport/auth/crypto_hash.h>
+#include <hicn/transport/auth/signer.h>
+#include <hicn/transport/auth/verifier.h>
 #include <test/packet_samples.h>
 
 #include <climits>
@@ -33,7 +35,7 @@ class ManifestTest : public ::testing::Test {
  protected:
   using ContentObjectManifest = ManifestInline<ContentObject, Fixed>;
 
-  ManifestTest() : name_("b001::123|321"), manifest1_(name_) {
+  ManifestTest() : name_("b001::123|321"), manifest1_(HF_INET6_TCP_AH, name_) {
     // You can do set-up work for each test here.
   }
 
@@ -97,8 +99,8 @@ TEST_F(ManifestTest, MoveConstructor) {
 TEST_F(ManifestTest, SetLastManifest) {
   manifest1_.clear();
 
-  manifest1_.setFinalManifest(true);
-  bool fcn = manifest1_.isFinalManifest();
+  manifest1_.setIsLast(true);
+  bool fcn = manifest1_.getIsLast();
 
   ASSERT_TRUE(fcn == true);
 }
@@ -109,13 +111,13 @@ TEST_F(ManifestTest, SetManifestType) {
   ManifestType type1 = ManifestType::INLINE_MANIFEST;
   ManifestType type2 = ManifestType::FLIC_MANIFEST;
 
-  manifest1_.setManifestType(type1);
-  ManifestType type_returned1 = manifest1_.getManifestType();
+  manifest1_.setType(type1);
+  ManifestType type_returned1 = manifest1_.getType();
 
   manifest1_.clear();
 
-  manifest1_.setManifestType(type2);
-  ManifestType type_returned2 = manifest1_.getManifestType();
+  manifest1_.setType(type2);
+  ManifestType type_returned2 = manifest1_.getType();
 
   ASSERT_EQ(type1, type_returned1);
   ASSERT_EQ(type2, type_returned2);
@@ -146,17 +148,80 @@ TEST_F(ManifestTest, SetHashAlgorithm) {
   ASSERT_EQ(hash3, type_returned3);
 }
 
-TEST_F(ManifestTest, SetNextSegmentCalculationStrategy) {
+TEST_F(ManifestTest, setParamsBytestream) {
   manifest1_.clear();
 
-  NextSegmentCalculationStrategy strategy1 =
-      NextSegmentCalculationStrategy::INCREMENTAL;
+  ParamsBytestream params{
+      .final_segment = 1,
+  };
+
+  manifest1_.setParamsBytestream(params);
+  manifest1_.encode();
+
+  ContentObjectManifest manifest(manifest1_);
+  manifest.decode();
+
+  ASSERT_EQ(interface::ProductionProtocolAlgorithms::BYTE_STREAM,
+            manifest.getTransportType());
+  ASSERT_EQ(params, manifest.getParamsBytestream());
+}
+
+TEST_F(ManifestTest, SetParamsRTC) {
+  manifest1_.clear();
+
+  ParamsRTC params{
+      .timestamp = 1,
+      .prod_rate = 2,
+      .prod_seg = 3,
+      .support_fec = 1,
+  };
+
+  manifest1_.setParamsRTC(params);
+  manifest1_.encode();
 
-  manifest1_.setNextSegmentCalculationStrategy(strategy1);
-  NextSegmentCalculationStrategy type_returned1 =
-      manifest1_.getNextSegmentCalculationStrategy();
+  ContentObjectManifest manifest(manifest1_);
+  manifest.decode();
+
+  ASSERT_EQ(interface::ProductionProtocolAlgorithms::RTC_PROD,
+            manifest.getTransportType());
+  ASSERT_EQ(params, manifest.getParamsRTC());
+}
 
-  ASSERT_EQ(strategy1, type_returned1);
+TEST_F(ManifestTest, SignManifest) {
+  Name name("b001::", 0);
+  auto signer = std::make_shared<auth::SymmetricSigner>(
+      auth::CryptoSuite::HMAC_SHA256, "hunter2");
+  auto verifier = std::make_shared<auth::SymmetricVerifier>("hunter2");
+  std::shared_ptr<ContentObjectManifest> manifest;
+
+  // Instantiate Manifest
+  manifest.reset(ContentObjectManifest::createManifest(
+      HF_INET6_TCP_AH, name, ManifestVersion::VERSION_1,
+      ManifestType::INLINE_MANIFEST, false, name, signer->getHashType(),
+      signer->getSignatureFieldSize()));
+
+  // Add Manifest entry
+  auth::CryptoHash hash(signer->getHashType());
+  hash.computeDigest(std::vector<uint8_t>{0x01, 0x02, 0x03, 0x04});
+  manifest->addSuffixHash(1, hash);
+
+  // Encode manifest
+  manifest->encode();
+
+  // Sign manifest
+  signer->signPacket(manifest.get());
+
+  // Check size
+  ASSERT_EQ(manifest->payloadSize(), manifest->estimateManifestSize());
+  ASSERT_EQ(manifest->length(),
+            manifest->headerSize() + manifest->payloadSize());
+  ASSERT_EQ(ContentObjectManifest::manifestHeaderSize(
+                interface::ProductionProtocolAlgorithms::UNKNOWN),
+            manifest->manifestHeaderSize());
+
+  // Verify manifest
+  auth::VerificationPolicy policy = verifier->verifyPackets(manifest.get());
+  ASSERT_EQ(auth::VerificationPolicy::ACCEPT, policy);
 }
 
 TEST_F(ManifestTest, SetBaseName) {
@@ -198,23 +263,8 @@ TEST_F(ManifestTest, SetSuffixList) {
   }
 
   manifest1_.setBaseName(base_name);
-
   core::Name ret_name = manifest1_.getBaseName();
 
-  // auto & hash_list = manifest1_.getSuffixHashList();
-
-  // bool cond;
-  // int i = 0;
-
-  // for (auto & item : manifest1_.getSuffixList()) {
-  //   auto hash = manifest1_.getHash(suffixes[i]);
-  //   cond = auth::CryptoHash::compareBinaryDigest(hash,
-  //                                               entries[i].second.getDigest<uint8_t>().data(),
-  //                                               entries[i].second.getType());
-  //   ASSERT_TRUE(cond);
-  //   i++;
-  // }
-
   ASSERT_EQ(base_name, ret_name);
 
   delete[] entries;
diff --git a/libtransport/src/test/test_event_thread.cc b/libtransport/src/test/test_event_thread.cc
index 549ff9c1a..324250717 100644
--- a/libtransport/src/test/test_event_thread.cc
+++ b/libtransport/src/test/test_event_thread.cc
@@ -14,6 +14,7 @@
  */
 
 #include <gtest/gtest.h>
+#include <hicn/transport/utils/chrono_typedefs.h>
 #include <hicn/transport/utils/event_thread.h>
 
 #include <cmath>
@@ -48,7 +49,7 @@ class EventThreadTest : public ::testing::Test {
   utils::EventThread event_thread_;
 };
 
-double average(const unsigned long samples[], int size) {
+inline double average(const unsigned long samples[], int size) {
   double sum = 0;
 
   for (int i = 0; i < size; i++) {
@@ -58,7 +59,7 @@ double average(const unsigned long samples[], int size) {
   return sum / size;
 }
 
-double stdDeviation(const unsigned long samples[], int size) {
+inline double stdDeviation(const unsigned long samples[], int size) {
   double avg = average(samples, size);
   double var = 0;
 
@@ -72,26 +73,23 @@ double stdDeviation(const unsigned long samples[], int size) {
 }  // namespace
 
 TEST_F(EventThreadTest, DISABLED_SchedulingDelay) {
-  using namespace std::chrono;
-  const size_t size = 1000000;
-  std::vector<unsigned long> samples(size);
-
-  for (unsigned int i = 0; i < size; i++) {
-    auto t0 = steady_clock::now();
-    event_thread_.add([t0, &samples, i]() {
-      auto t1 = steady_clock::now();
-      samples[i] = duration_cast<nanoseconds>(t1 - t0).count();
-    });
-  }
+  // using namespace std::chrono;
+  // const size_t size = 1000000;
+  // std::vector<unsigned long> samples(size);
+
+  // for (unsigned int i = 0; i < size; i++) {
+  //   event_thread_.add([t0, &samples, i]() {
+  //   });
+  // }
 
-  event_thread_.stop();
+  // event_thread_.stop();
 
-  auto avg = average(&samples[0], size);
-  auto sd = stdDeviation(&samples[0], size);
-  (void)sd;
+  // auto avg = average(&samples[0], size);
+  // auto sd = stdDeviation(&samples[0], size);
+  // (void)sd;
 
-  // Expect average to be less that 1 ms
-  EXPECT_LT(avg, 1000000);
+  // // Expect average to be less that 1 ms
+  // EXPECT_LT(avg, 1000000);
 }
 
 }  // namespace utils
diff --git a/libtransport/src/test/test_fec_base_rely.cc b/libtransport/src/test/test_fec_base_rely.cc
new file mode 100644
index 000000000..41e1eae49
--- /dev/null
+++ b/libtransport/src/test/test_fec_base_rely.cc
@@ -0,0 +1,453 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <hicn/transport/core/content_object.h>
+#include <hicn/transport/core/global_object_pool.h>
+#include <protocols/fec_base.h>
+#include <protocols/fec_utils.h>
+#include <protocols/rtc/rtc_consts.h>
+
+#include <algorithm>
+#include <iostream>
+#include <queue>
+#include <random>
+
+namespace transport {
+namespace protocol {
+
+class PacketFactory {
+ public:
+  PacketFactory(){};
+
+  ~PacketFactory(){};
+
+  std::shared_ptr<transport::core::ContentObject> createData(
+      core::Name &name, uint32_t suffix, uint32_t payload_size,
+      uint32_t payload_filler) {
+    auto &packet_manager = core::PacketManager<>::getInstance();
+
+    // create payload
+    auto buff = packet_manager.getMemBuf();
+    buff->append(payload_size);
+    std::fill(buff->writableData(), buff->writableTail(), payload_filler);
+
+    // create data packet
+    auto data = packet_manager.getPacket<transport::core::ContentObject>(
+        HF_INET6_TCP, 0);
+    struct rtc::data_packet_t header;
+    header.setTimestamp(1000);
+    header.setProductionRate(1);
+    data->appendPayload((const uint8_t *)&header, rtc::DATA_HEADER_SIZE);
+    data->appendPayload(buff->data(), buff->length());
+    data->setName(name.setSuffix(suffix));
+    data->setLifetime(500);
+    data->setPathLabel(12);
+
+    return data;
+  }
+
+  std::shared_ptr<transport::core::ContentObject> createData(
+      core::Name &name, uint32_t suffix, fec::buffer payload) {
+    auto &packet_manager = core::PacketManager<>::getInstance();
+
+    auto data = packet_manager.getPacket<transport::core::ContentObject>(
+        HF_INET6_TCP, 0);
+    struct rtc::data_packet_t header;
+    header.setTimestamp(1000);
+    header.setProductionRate(1);
+    data->appendPayload((const uint8_t *)&header, rtc::DATA_HEADER_SIZE);
+    data->appendPayload(payload->data(), payload->length());
+    data->setName(name.setSuffix(suffix));
+    data->setLifetime(500);
+    data->setPathLabel(12);
+
+    return data;
+  }
+};
+
+class Encoder {
+ public:
+  Encoder(std::string fec_str) {
+    fec_type_ = fec::FECUtils::fecTypeFromString(fec_str.c_str());
+    if (fec_type_ == fec::FECType::UNKNOWN)
+      std::cout << "x" << fec_str << "x" << std::endl;
+    encoder_ = fec::FECUtils::getEncoder(fec_type_, 1);
+    encoder_->setFECCallback(
+        std::bind(&Encoder::onFecPackets, this, std::placeholders::_1));
+    encoder_->setBufferCallback(
+        std::bind(&Encoder::getBuffer, this, std::placeholders::_1));
+  };
+
+  ~Encoder(){};
+
+  void onFecPackets(fec::BufferArray &packets) {
+    for (auto &packet : packets) {
+      fec_packets_.push(packet.getBuffer());
+    }
+  }
+
+  fec::buffer getBuffer(std::size_t size) {
+    auto ret = core::PacketManager<>::getInstance()
+                   .getPacket<transport::core::ContentObject>(HF_INET6_TCP, 0);
+    ret->updateLength(rtc::DATA_HEADER_SIZE + size);
+    ret->append(rtc::DATA_HEADER_SIZE + size);
+    ret->trimStart(ret->headerSize() + rtc::DATA_HEADER_SIZE);
+
+    return ret;
+  }
+
+  void onPacketProduced(core::ContentObject &content_object, uint32_t offset,
+                        uint32_t metadata) {
+    encoder_->onPacketProduced(content_object, offset, metadata);
+  }
+
+ public:
+  std::queue<fec::buffer> fec_packets_;
+
+ private:
+  std::unique_ptr<fec::ProducerFEC> encoder_;
+  fec::FECType fec_type_;
+};
+
+class Decoder {
+ public:
+  Decoder(std::string fec_str) {
+    fec_type_ = fec::FECUtils::fecTypeFromString(fec_str.c_str());
+    decoder_ = fec::FECUtils::getDecoder(fec_type_, 1);
+    decoder_->setFECCallback(
+        std::bind(&Decoder::onFecPackets, this, std::placeholders::_1));
+    decoder_->setBufferCallback(fec::FECBase::BufferRequested(0));
+  };
+
+  ~Decoder(){};
+
+  void onFecPackets(fec::BufferArray &packets) {
+    for (auto &packet : packets) {
+      hicn_packet_dump(packet.getBuffer()->data(),
+                       packet.getBuffer()->length());
+      recovered_packets_.push(packet.getBuffer());
+    }
+  }
+
+  void onPacketReceived(core::ContentObject &content_object, uint32_t offset) {
+    decoder_->onDataPacket(content_object, offset);
+  }
+
+ public:
+  std::queue<fec::buffer> recovered_packets_;
+
+ private:
+  std::unique_ptr<fec::ConsumerFEC> decoder_;
+  fec::FECType fec_type_;
+};
+
+TEST(FECtestRely, RelyTestInOrder1) {
+  // use Rely k = 2 N = 6
+  std::string fec_str = "Rely_K2_N6";
+  Encoder encoder(fec_str);
+  Decoder decoder(fec_str);
+
+  PacketFactory pf;
+
+  core::Name name("b001::");
+
+  auto data1 = pf.createData(name, 1, 50, 1);
+  // we cannot use the original data 1 to check it we recovered the packet
+  // correclty because Rely modifies the packet so here we create a copy
+  auto data1_copy = pf.createData(name, 1, 50, 1);
+
+  auto data2 = pf.createData(name, 2, 45, 2);
+
+  // encoding
+  uint32_t metadata = static_cast<uint32_t>(data1->getPayloadType());
+  encoder.onPacketProduced(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+  encoder.onPacketProduced(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+
+  // create fec packet
+  auto data3 = pf.createData(name, 3, encoder.fec_packets_.front());
+
+  // decode in order, data 1 is lost
+  decoder.onPacketReceived(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data3, data3->headerSize() + rtc::DATA_HEADER_SIZE);
+
+  // check recovered packet
+  EXPECT_EQ(decoder.recovered_packets_.size(), (size_t)2);
+  auto recovered = pf.createData(name, 1, decoder.recovered_packets_.front());
+
+  bool eq_len = (data1_copy->length() == recovered->length());
+  EXPECT_TRUE(eq_len);
+  int ret = -1;
+  if (eq_len)
+    ret = memcmp(data1_copy->data(), recovered->data(), recovered->length());
+  EXPECT_EQ(ret, (int)0);
+}
+
+TEST(FECtestRely, RelyTestInOrder2) {
+  // use Rely k = 2 N = 6
+  std::string fec_str = "Rely_K2_N6";
+  Encoder encoder(fec_str);
+  Decoder decoder(fec_str);
+
+  PacketFactory pf;
+
+  core::Name name("b001::");
+
+  auto data1 = pf.createData(name, 1, 50, 1);
+
+  auto data2 = pf.createData(name, 2, 45, 2);
+  auto data2_copy = pf.createData(name, 2, 45, 2);
+
+  // encoding
+  uint32_t metadata = static_cast<uint32_t>(data1->getPayloadType());
+  encoder.onPacketProduced(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+  encoder.onPacketProduced(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+
+  // create fec packet
+  auto data3 = pf.createData(name, 3, encoder.fec_packets_.front());
+
+  // decode in order, data 2 is lost
+  decoder.onPacketReceived(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data3, data3->headerSize() + rtc::DATA_HEADER_SIZE);
+
+  // check recovered packet
+  EXPECT_EQ(decoder.recovered_packets_.size(), (size_t)2);
+  decoder.recovered_packets_.pop();  // pop data 1
+  auto recovered = pf.createData(name, 2, decoder.recovered_packets_.front());
+
+  bool eq_len = (data2_copy->length() == recovered->length());
+  EXPECT_TRUE(eq_len);
+  int ret = -1;
+  if (eq_len)
+    ret = memcmp(data2_copy->data(), recovered->data(), recovered->length());
+  EXPECT_EQ(ret, (int)0);
+}
+
+#if 0
+TEST(FECtestRely, RelyTestOutOfOrder1) {
+  //use Rely k = 2 N = 6
+  std::string fec_str = "Rely_K2_N6";
+  Encoder encoder(fec_str);
+  Decoder decoder(fec_str);
+
+  PacketFactory pf;
+
+  core::Name name("b001::");
+
+  auto data1 = pf.createData(name, 1, 50, 1);
+  auto data1_copy = pf.createData(name, 1, 50, 1);
+
+  auto data2 = pf.createData(name, 2, 45, 2);
+
+  std::cout << "dump packet 2" << std::endl;
+  hicn_packet_dump(data2->data(), data2->length());
+
+  // encoding
+  uint32_t metadata = static_cast<uint32_t>(data1->getPayloadType());
+  encoder.onPacketProduced(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE,
+                            metadata);
+  encoder.onPacketProduced(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE,
+                            metadata);
+
+  // create fec packet
+  auto data3 = pf.createData(name, 3, encoder.fec_packets_.front());
+
+  std::cout << "dump packet 2" << std::endl;
+  hicn_packet_dump(data2->data(), data2->length());
+
+  std::cout << "dump packet 3" << std::endl;
+  hicn_packet_dump(data3->data(), data3->length());
+
+  // decoding ooo packets. data 1 is lost.
+  decoder.onPacketReceived(*data3, data3->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE);
+
+  // get recovered packet
+  EXPECT_EQ(decoder.recovered_packets_.size(), (size_t) 2);
+  auto recovered = pf.createData(name, 1, decoder.recovered_packets_.front());
+  bool eq_len = (data1_copy->length() == recovered->length());
+  EXPECT_TRUE(eq_len);
+  int ret = -1;
+  if(eq_len)
+    ret = memcmp(data1_copy->data(), recovered->data(), recovered->length());
+  EXPECT_EQ(ret, (int) 0);
+}
+#endif
+
+TEST(FECtestRely, RelyTestOutOfOrder2) {
+  // use Rely k = 2 N = 6
+  std::string fec_str = "Rely_K2_N6";
+  Encoder encoder(fec_str);
+  Decoder decoder(fec_str);
+
+  PacketFactory pf;
+
+  core::Name name("b001::");
+
+  auto data1 = pf.createData(name, 1, 50, 1);
+
+  auto data2 = pf.createData(name, 2, 45, 2);
+  auto data2_copy = pf.createData(name, 2, 45, 2);
+
+  // encoding
+  uint32_t metadata = static_cast<uint32_t>(data1->getPayloadType());
+  encoder.onPacketProduced(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+  encoder.onPacketProduced(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+
+  // create fec packet
+  auto data3 = pf.createData(name, 3, encoder.fec_packets_.front());
+
+  // decoding ooo packets. data 2 is lost.
+  decoder.onPacketReceived(*data3, data3->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data1, data2->headerSize() + rtc::DATA_HEADER_SIZE);
+
+  // get recovered packet
+  EXPECT_EQ(decoder.recovered_packets_.size(), (size_t)2);
+  decoder.recovered_packets_.pop();  // pop data 1
+  auto recovered = pf.createData(name, 2, decoder.recovered_packets_.front());
+  bool eq_len = (data2_copy->length() == recovered->length());
+  EXPECT_TRUE(eq_len);
+  int ret = -1;
+  if (eq_len)
+    ret = memcmp(data2_copy->data(), recovered->data(), recovered->length());
+  EXPECT_EQ(ret, (int)0);
+}
+
+TEST(FECtestRely, RelyTestLargerBlocks) {
+  // use Rely k = 4 N = 7
+  std::string fec_str = "Rely_K4_N7";
+  Encoder encoder(fec_str);
+  Decoder decoder(fec_str);
+
+  PacketFactory pf;
+
+  core::Name name("b001::");
+
+  auto data1 = pf.createData(name, 1, 50, 1);
+
+  auto data2 = pf.createData(name, 2, 45, 2);
+
+  auto data3 = pf.createData(name, 3, 12, 3);
+  auto data3_copy = pf.createData(name, 3, 12, 3);
+
+  auto data4 = pf.createData(name, 4, 20, 4);
+  auto data4_copy = pf.createData(name, 4, 20, 4);
+
+  // encoding
+  uint32_t metadata = static_cast<uint32_t>(data1->getPayloadType());
+  encoder.onPacketProduced(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+  encoder.onPacketProduced(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+  encoder.onPacketProduced(*data3, data3->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+  encoder.onPacketProduced(*data4, data4->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+
+  // create fec packet
+  auto data5 = pf.createData(name, 5, encoder.fec_packets_.front());
+  encoder.fec_packets_.pop();  // pop 5
+  encoder.fec_packets_.pop();  // pop 6
+  auto data7 = pf.createData(name, 7, encoder.fec_packets_.front());
+
+  // decoding packets: lost data 3 and data 4
+  decoder.onPacketReceived(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data7, data7->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data5, data5->headerSize() + rtc::DATA_HEADER_SIZE);
+
+  // get recovered packet
+  EXPECT_EQ(decoder.recovered_packets_.size(), (size_t)4);
+  decoder.recovered_packets_.pop();  // pop data 1
+  decoder.recovered_packets_.pop();  // pop data 2
+  auto recovered3 = pf.createData(name, 3, decoder.recovered_packets_.front());
+  decoder.recovered_packets_.pop();
+  auto recovered4 = pf.createData(name, 4, decoder.recovered_packets_.front());
+
+  bool eq_len = (data3_copy->length() == recovered3->length());
+  EXPECT_TRUE(eq_len);
+  int ret = -1;
+  if (eq_len)
+    ret = memcmp(data3_copy->data(), recovered3->data(), recovered3->length());
+  EXPECT_EQ(ret, (int)0);
+
+  eq_len = (data4_copy->length() == recovered4->length());
+  EXPECT_TRUE(eq_len);
+  ret = -1;
+  if (eq_len)
+    ret = memcmp(data4_copy->data(), recovered4->data(), recovered4->length());
+  EXPECT_EQ(ret, (int)0);
+}
+
+TEST(FECtestRely, RelyTestK1_N3) {
+  // use Rely k = 1 N = 3
+  std::string fec_str = "Rely_K1_N3";
+  Encoder encoder(fec_str);
+  Decoder decoder1(fec_str);  // recv 2
+  Decoder decoder2(fec_str);  // recv 3
+
+  PacketFactory pf;
+
+  core::Name name("b001::");
+
+  auto data1 = pf.createData(name, 1, 50, 1);
+  auto data1_copy = pf.createData(name, 1, 50, 1);
+
+  // encoding
+  uint32_t metadata = static_cast<uint32_t>(data1->getPayloadType());
+  encoder.onPacketProduced(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+
+  // create fec packets
+  EXPECT_TRUE(encoder.fec_packets_.size() == 2);
+  auto data2 = pf.createData(name, 2, encoder.fec_packets_.front());
+  encoder.fec_packets_.pop();  // pop 2
+  auto data3 = pf.createData(name, 3, encoder.fec_packets_.front());
+
+  // test1: recv data 2
+  decoder1.onPacketReceived(*data2,
+                            data2->headerSize() + rtc::DATA_HEADER_SIZE);
+  EXPECT_EQ(decoder1.recovered_packets_.size(), (size_t)1);
+
+  auto recovered = pf.createData(name, 1, decoder1.recovered_packets_.front());
+  bool eq_len = (data1_copy->length() == recovered->length());
+  EXPECT_TRUE(eq_len);
+  int ret = -1;
+  if (eq_len)
+    ret = memcmp(data1_copy->data(), recovered->data(), recovered->length());
+  EXPECT_EQ(ret, (int)0);
+
+  // test2: recv data 3
+  decoder2.onPacketReceived(*data3,
+                            data3->headerSize() + rtc::DATA_HEADER_SIZE);
+  EXPECT_EQ(decoder2.recovered_packets_.size(), (size_t)1);
+
+  recovered = pf.createData(name, 1, decoder2.recovered_packets_.front());
+  eq_len = (data1_copy->length() == recovered->length());
+  EXPECT_TRUE(eq_len);
+  ret = -1;
+  if (eq_len)
+    ret = memcmp(data1_copy->data(), recovered->data(), recovered->length());
+  EXPECT_EQ(ret, (int)0);
+}
+
+}  // namespace protocol
+}  // namespace transport
diff --git a/libtransport/src/test/test_fec_base_rs.cc b/libtransport/src/test/test_fec_base_rs.cc
new file mode 100644
index 000000000..7d7bcebc3
--- /dev/null
+++ b/libtransport/src/test/test_fec_base_rs.cc
@@ -0,0 +1,412 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <hicn/transport/core/content_object.h>
+#include <hicn/transport/core/global_object_pool.h>
+#include <protocols/fec_base.h>
+#include <protocols/fec_utils.h>
+#include <protocols/rtc/rtc_consts.h>
+
+#include <algorithm>
+#include <iostream>
+#include <queue>
+#include <random>
+
+namespace transport {
+namespace protocol {
+
+class PacketFactory {
+ public:
+  PacketFactory(){};
+
+  ~PacketFactory(){};
+
+  std::shared_ptr<transport::core::ContentObject> createData(
+      core::Name &name, uint32_t suffix, uint32_t payload_size,
+      uint32_t payload_filler) {
+    auto &packet_manager = core::PacketManager<>::getInstance();
+
+    // create payload
+    auto buff = packet_manager.getMemBuf();
+    buff->append(payload_size);
+    std::fill(buff->writableData(), buff->writableTail(), payload_filler);
+
+    // create data packet
+    auto data = packet_manager.getPacket<transport::core::ContentObject>(
+        HF_INET6_TCP, 0);
+    struct rtc::data_packet_t header;
+    header.setTimestamp(1000);
+    header.setProductionRate(1);
+    data->appendPayload((const uint8_t *)&header, rtc::DATA_HEADER_SIZE);
+    data->appendPayload(buff->data(), buff->length());
+    data->setName(name.setSuffix(suffix));
+    data->setLifetime(500);
+    data->setPathLabel(12);
+
+    return data;
+  }
+
+  std::shared_ptr<transport::core::ContentObject> createData(
+      core::Name &name, uint32_t suffix, fec::buffer payload) {
+    auto &packet_manager = core::PacketManager<>::getInstance();
+
+    auto data = packet_manager.getPacket<transport::core::ContentObject>(
+        HF_INET6_TCP, 0);
+    struct rtc::data_packet_t header;
+    header.setTimestamp(1000);
+    header.setProductionRate(1);
+    data->appendPayload((const uint8_t *)&header, rtc::DATA_HEADER_SIZE);
+    data->appendPayload(payload->data(), payload->length());
+    data->setName(name.setSuffix(suffix));
+    data->setLifetime(500);
+    data->setPathLabel(12);
+
+    return data;
+  }
+};
+
+class Encoder {
+ public:
+  Encoder(std::string fec_str) {
+    fec_type_ = fec::FECUtils::fecTypeFromString(fec_str.c_str());
+    encoder_ = fec::FECUtils::getEncoder(fec_type_, 1);
+    encoder_->setFECCallback(
+        std::bind(&Encoder::onFecPackets, this, std::placeholders::_1));
+    encoder_->setBufferCallback(
+        std::bind(&Encoder::getBuffer, this, std::placeholders::_1));
+  };
+
+  ~Encoder(){};
+
+  void onFecPackets(fec::BufferArray &packets) {
+    for (auto &packet : packets) {
+      fec_packets_.push(packet.getBuffer());
+    }
+  }
+
+  fec::buffer getBuffer(std::size_t size) {
+    auto ret = core::PacketManager<>::getInstance()
+                   .getPacket<transport::core::ContentObject>(HF_INET6_TCP, 0);
+    ret->updateLength(rtc::DATA_HEADER_SIZE + size);
+    ret->append(rtc::DATA_HEADER_SIZE + size);
+    ret->trimStart(ret->headerSize() + rtc::DATA_HEADER_SIZE);
+
+    return ret;
+  }
+
+  void onPacketProduced(core::ContentObject &content_object, uint32_t offset,
+                        uint32_t metadata) {
+    encoder_->onPacketProduced(content_object, offset, metadata);
+  }
+
+ public:
+  std::queue<fec::buffer> fec_packets_;
+
+ private:
+  std::unique_ptr<fec::ProducerFEC> encoder_;
+  fec::FECType fec_type_;
+};
+
+class Decoder {
+ public:
+  Decoder(std::string fec_str) {
+    fec_type_ = fec::FECUtils::fecTypeFromString(fec_str.c_str());
+    decoder_ = fec::FECUtils::getDecoder(fec_type_, 1);
+    decoder_->setFECCallback(
+        std::bind(&Decoder::onFecPackets, this, std::placeholders::_1));
+    decoder_->setBufferCallback(fec::FECBase::BufferRequested(0));
+  };
+
+  ~Decoder(){};
+
+  void onFecPackets(fec::BufferArray &packets) {
+    for (auto &packet : packets) {
+      recovered_packets_.push(packet.getBuffer());
+    }
+  }
+
+  void onPacketReceived(core::ContentObject &content_object, uint32_t offset) {
+    decoder_->onDataPacket(content_object, offset);
+  }
+
+ public:
+  std::queue<fec::buffer> recovered_packets_;
+
+ private:
+  std::unique_ptr<fec::ConsumerFEC> decoder_;
+  fec::FECType fec_type_;
+};
+
+TEST(FECtestRS, RSTestInOrder1) {
+  // use RS k = 2 N = 6
+  std::string fec_str = "RS_K2_N6";
+  Encoder encoder(fec_str);
+  Decoder decoder(fec_str);
+
+  PacketFactory pf;
+
+  core::Name name("b001::");
+
+  auto data1 = pf.createData(name, 1, 50, 1);
+  const uint8_t *data1_ptr = data1->data();
+
+  auto data2 = pf.createData(name, 2, 45, 2);
+  const uint8_t *data2_ptr = data2->data();
+
+  // encoding
+  uint32_t metadata = static_cast<uint32_t>(data1->getPayloadType());
+  encoder.onPacketProduced(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+  encoder.onPacketProduced(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+
+  // create fec packet
+  auto data3 = pf.createData(name, 3, encoder.fec_packets_.front());
+
+  // decode in order, data 1 is lost
+  decoder.onPacketReceived(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data3, data3->headerSize() + rtc::DATA_HEADER_SIZE);
+
+  // test payload pointers off the original packets
+  EXPECT_EQ((const uint8_t *)data1->data(), data1_ptr);
+  EXPECT_EQ((const uint8_t *)data2->data(), data2_ptr);
+
+  // check recovered packet
+  EXPECT_EQ(decoder.recovered_packets_.size(), (size_t)2);
+  auto recovered = pf.createData(name, 1, decoder.recovered_packets_.front());
+  bool eq_len = (data1->length() == recovered->length());
+  EXPECT_TRUE(eq_len);
+  int ret = -1;
+  if (eq_len)
+    ret = memcmp(data1->data(), recovered->data(), recovered->length());
+  EXPECT_EQ(ret, (int)0);
+}
+
+TEST(FECtestRS, RSTestInOrder2) {
+  // use RS k = 2 N = 6
+  std::string fec_str = "RS_K2_N6";
+  Encoder encoder(fec_str);
+  Decoder decoder(fec_str);
+
+  PacketFactory pf;
+
+  core::Name name("b001::");
+
+  auto data1 = pf.createData(name, 1, 50, 1);
+  const uint8_t *data1_ptr = data1->data();
+
+  auto data2 = pf.createData(name, 2, 45, 2);
+  const uint8_t *data2_ptr = data2->data();
+
+  // encoding
+  uint32_t metadata = static_cast<uint32_t>(data1->getPayloadType());
+  encoder.onPacketProduced(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+  encoder.onPacketProduced(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+
+  // create fec packet
+  auto data3 = pf.createData(name, 3, encoder.fec_packets_.front());
+
+  // decode in order, data 2 is lost
+  decoder.onPacketReceived(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data3, data3->headerSize() + rtc::DATA_HEADER_SIZE);
+
+  // test payload pointers off the original packets
+  EXPECT_EQ((const uint8_t *)data1->data(), data1_ptr);
+  EXPECT_EQ((const uint8_t *)data2->data(), data2_ptr);
+
+  // check recovered packet
+  EXPECT_EQ(decoder.recovered_packets_.size(), (size_t)2);
+  decoder.recovered_packets_.pop();  // pop data packet 1
+  auto recovered = pf.createData(name, 2, decoder.recovered_packets_.front());
+
+  bool eq_len = (data2->length() == recovered->length());
+  EXPECT_TRUE(eq_len);
+  int ret = -1;
+  if (eq_len)
+    ret = memcmp(data2->data(), recovered->data(), recovered->length());
+  EXPECT_EQ(ret, (int)0);
+}
+
+TEST(FECtestRS, RSTestOutOfOrder1) {
+  // use RS k = 2 N = 6
+  std::string fec_str = "RS_K2_N6";
+  Encoder encoder(fec_str);
+  Decoder decoder(fec_str);
+
+  PacketFactory pf;
+
+  core::Name name("b001::");
+
+  auto data1 = pf.createData(name, 1, 50, 1);
+  const uint8_t *data1_ptr = data1->data();
+
+  auto data2 = pf.createData(name, 2, 45, 2);
+  const uint8_t *data2_ptr = data2->data();
+
+  // encoding
+  uint32_t metadata = static_cast<uint32_t>(data1->getPayloadType());
+  encoder.onPacketProduced(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+  encoder.onPacketProduced(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+
+  // create fec packet
+  auto data3 = pf.createData(name, 3, encoder.fec_packets_.front());
+
+  // decoding ooo packets. data 1 is lost.
+  decoder.onPacketReceived(*data3, data3->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE);
+
+  // test payload pointers off the original packets
+  EXPECT_EQ((const uint8_t *)data1->data(), data1_ptr);
+  EXPECT_EQ((const uint8_t *)data2->data(), data2_ptr);
+
+  // get recovered packet
+  EXPECT_EQ(decoder.recovered_packets_.size(), (size_t)2);
+  auto recovered = pf.createData(name, 1, decoder.recovered_packets_.front());
+  bool eq_len = (data1->length() == recovered->length());
+  EXPECT_TRUE(eq_len);
+  int ret = -1;
+  if (eq_len)
+    ret = memcmp(data1->data(), recovered->data(), recovered->length());
+  EXPECT_EQ(ret, (int)0);
+}
+
+TEST(FECtestRS, RSTestOutOfOrder2) {
+  // use RS k = 2 N = 6
+  std::string fec_str = "RS_K2_N6";
+  Encoder encoder(fec_str);
+  Decoder decoder(fec_str);
+
+  PacketFactory pf;
+
+  core::Name name("b001::");
+
+  auto data1 = pf.createData(name, 1, 50, 1);
+  const uint8_t *data1_ptr = data1->data();
+
+  auto data2 = pf.createData(name, 2, 45, 2);
+  const uint8_t *data2_ptr = data2->data();
+
+  // encoding
+  uint32_t metadata = static_cast<uint32_t>(data1->getPayloadType());
+  encoder.onPacketProduced(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+  encoder.onPacketProduced(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+
+  // create fec packet
+  auto data3 = pf.createData(name, 3, encoder.fec_packets_.front());
+
+  // decoding ooo packets. data 2 is lost.
+  decoder.onPacketReceived(*data3, data3->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data1, data2->headerSize() + rtc::DATA_HEADER_SIZE);
+
+  // test payload pointers off the original packets
+  EXPECT_EQ((const uint8_t *)data1->data(), data1_ptr);
+  EXPECT_EQ((const uint8_t *)data2->data(), data2_ptr);
+
+  // get recovered packet
+  EXPECT_EQ(decoder.recovered_packets_.size(), (size_t)2);
+  decoder.recovered_packets_.pop();  // pop data packet 1
+
+  auto recovered = pf.createData(name, 2, decoder.recovered_packets_.front());
+  bool eq_len = (data2->length() == recovered->length());
+  EXPECT_TRUE(eq_len);
+  int ret = -1;
+  if (eq_len)
+    ret = memcmp(data2->data(), recovered->data(), recovered->length());
+  EXPECT_EQ(ret, (int)0);
+}
+
+TEST(FECtestRS, RSTestLargerBlocks) {
+  // use RS k = 4 N = 7
+  std::string fec_str = "RS_K4_N7";
+  Encoder encoder(fec_str);
+  Decoder decoder(fec_str);
+
+  PacketFactory pf;
+
+  core::Name name("b001::");
+
+  auto data1 = pf.createData(name, 1, 50, 1);
+  const uint8_t *data1_ptr = data1->data();
+
+  auto data2 = pf.createData(name, 2, 45, 2);
+  const uint8_t *data2_ptr = data2->data();
+
+  auto data3 = pf.createData(name, 3, 12, 3);
+  const uint8_t *data3_ptr = data3->data();
+
+  auto data4 = pf.createData(name, 4, 20, 4);
+  const uint8_t *data4_ptr = data4->data();
+
+  // encoding
+  uint32_t metadata = static_cast<uint32_t>(data1->getPayloadType());
+  encoder.onPacketProduced(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+  encoder.onPacketProduced(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+  encoder.onPacketProduced(*data3, data3->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+  encoder.onPacketProduced(*data4, data4->headerSize() + rtc::DATA_HEADER_SIZE,
+                           metadata);
+
+  // create fec packet
+  auto data5 = pf.createData(name, 5, encoder.fec_packets_.front());
+  encoder.fec_packets_.pop();  // pop 5
+  encoder.fec_packets_.pop();  // pop 6
+  auto data7 = pf.createData(name, 7, encoder.fec_packets_.front());
+
+  // decoding packets: lost data 3 and data 4
+  decoder.onPacketReceived(*data2, data2->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data7, data7->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data1, data1->headerSize() + rtc::DATA_HEADER_SIZE);
+  decoder.onPacketReceived(*data5, data5->headerSize() + rtc::DATA_HEADER_SIZE);
+
+  // test payload pointers off the original packets
+  EXPECT_EQ((const uint8_t *)data1->data(), data1_ptr);
+  EXPECT_EQ((const uint8_t *)data2->data(), data2_ptr);
+  EXPECT_EQ((const uint8_t *)data3->data(), data3_ptr);
+  EXPECT_EQ((const uint8_t *)data4->data(), data4_ptr);
+
+  // get recovered packet
+  EXPECT_EQ(decoder.recovered_packets_.size(), (size_t)4);
+  decoder.recovered_packets_.pop();  // pop data 1
+  decoder.recovered_packets_.pop();  // pop data 2
+  auto recovered3 = pf.createData(name, 3, decoder.recovered_packets_.front());
+  decoder.recovered_packets_.pop();  // pop data 3
+  auto recovered4 = pf.createData(name, 4, decoder.recovered_packets_.front());
+
+  bool eq_len = (data3->length() == recovered3->length());
+  EXPECT_TRUE(eq_len);
+  int ret = -1;
+  if (eq_len)
+    ret = memcmp(data3->data(), recovered3->data(), recovered3->length());
+  EXPECT_EQ(ret, (int)0);
+
+  eq_len = (data4->length() == recovered4->length());
+  EXPECT_TRUE(eq_len);
+  ret = -1;
+  if (eq_len)
+    ret = memcmp(data4->data(), recovered4->data(), recovered4->length());
+  EXPECT_EQ(ret, (int)0);
+}
+
+}  // namespace protocol
+}  // namespace transport
diff --git a/libtransport/src/test/test_fec_reedsolomon.cc b/libtransport/src/test/test_fec_reedsolomon.cc
index c7e10d111..0973069b1 100644
--- a/libtransport/src/test/test_fec_reedsolomon.cc
+++ b/libtransport/src/test/test_fec_reedsolomon.cc
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <glog/logging.h>
 #include <gtest/gtest.h>
 #include <hicn/transport/core/content_object.h>
 #include <hicn/transport/core/global_object_pool.h>
@@ -30,28 +31,35 @@ double ReedSolomonTest(int k, int n, int seq_offset, int size) {
   fec::RSEncoder encoder(k, n, seq_offset);
   fec::RSDecoder decoder(k, n, seq_offset);
 
-  std::vector<fec::buffer> tx_block(k);
-  std::vector<fec::buffer> rx_block(k);
+  using BufferMetadata = std::pair<fec::buffer, uint32_t>;
+
+  std::vector<BufferMetadata> tx_block(k);
+  std::vector<BufferMetadata> rx_block(k);
   int count = 0;
   int run = 0;
 
+  // Setup random engine
+  std::random_device
+      rd;  // Will be used to obtain a seed for the random number engine
+  std::mt19937 gen(rd());  // Standard mersenne_twister_engine seeded with rd()
+  std::uniform_int_distribution<> dis(0, 99);
+
   int iterations = 100;
   auto &packet_manager = core::PacketManager<>::getInstance();
 
-  encoder.setFECCallback(
-      [&tx_block](
-          std::vector<std::pair<uint32_t, fec::buffer>> &repair_packets) {
-        for (auto &p : repair_packets) {
-          // Append repair symbols to tx_block
-          tx_block.emplace_back(std::move(p).second);
-        }
-      });
+  encoder.setFECCallback([&tx_block](fec::BufferArray &repair_packets) {
+    for (auto &p : repair_packets) {
+      // Append repair symbols to tx_block
+      tx_block.emplace_back(p.getBuffer(), p.getMetadata());
+    }
+  });
 
   decoder.setFECCallback(
-      [&](std::vector<std::pair<uint32_t, fec::buffer>> &source_packets) {
+      [&tx_block, &count, &k](fec::BufferArray &source_packets) {
         for (int i = 0; i < k; i++) {
           // Compare decoded source packets with original transmitted packets.
-          if (*tx_block[i] != *source_packets[i].second) {
+          if (*tx_block[i].first != *source_packets[i].getBuffer() ||
+              tx_block[i].second != source_packets[i].getMetadata()) {
             count++;
           }
         }
@@ -60,7 +68,7 @@ double ReedSolomonTest(int k, int n, int seq_offset, int size) {
   do {
     // Discard eventual packet appended in previous callback call
     tx_block.erase(tx_block.begin() + k, tx_block.end());
-    auto _seq_offet = seq_offset;
+    uint32_t _seq_offset = seq_offset;
 
     // Initialization. Feed encoder with first k source packets
     for (int i = 0; i < k; i++) {
@@ -69,45 +77,46 @@ double ReedSolomonTest(int k, int n, int seq_offset, int size) {
 
       // Let's append a bit less than size, so that the FEC class will take care
       // of filling the rest with zeros
-      auto cur_size = size - (rand() % 100);
+      auto cur_size = size - dis(gen);
 
       // Set payload, saving 2 bytes at the beginning of the buffer for encoding
       // the length
       packet->append(cur_size);
-      packet->trimStart(2);
-      std::generate(packet->writableData(), packet->writableTail(), rand);
       std::fill(packet->writableData(), packet->writableTail(), i + 1);
 
       // Set first byte of payload to seq_offset, to reorder at receiver side
-      packet->writableData()[0] = uint8_t(_seq_offet++);
+      uint32_t *pkt_head = (uint32_t *)packet->writableData();
+      *pkt_head = _seq_offset++;
+
+      // Set a metadata integer
+      uint32_t metadata = dis(gen);
 
       // Store packet in tx buffer and clear rx buffer
-      tx_block[i] = std::move(packet);
+      tx_block[i] = std::make_pair(std::move(packet), metadata);
     }
 
     // Create the repair packets
     for (auto &tx : tx_block) {
-      encoder.consume(tx, tx->writableBuffer()[0]);
+      encoder.consume(tx.first, tx.first->writableBuffer()[0], 0, tx.second);
     }
 
     // Simulate transmission on lossy channel
-    unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
     std::vector<bool> losses(n, false);
     for (int i = 0; i < n - k; i++) losses[i] = true;
 
     int rxi = 0;
-    std::shuffle(losses.begin(), losses.end(),
-                 std::default_random_engine(seed));
+    std::shuffle(losses.begin(), losses.end(), gen);
     for (int i = 0; i < n && rxi < k; i++)
       if (losses[i] == false) {
         rx_block[rxi++] = tx_block[i];
         if (i < k) {
           // Source packet
-          decoder.consumeSource(rx_block[rxi - 1],
-                                rx_block[rxi - 1]->data()[0]);
+          uint32_t index = *((uint32_t *)rx_block[rxi - 1].first->data());
+          decoder.consumeSource(rx_block[rxi - 1].first, index, 0,
+                                rx_block[rxi - 1].second);
         } else {
           // Repair packet
-          decoder.consumeRepair(rx_block[rxi - 1]);
+          decoder.consumeRepair(rx_block[rxi - 1].first);
         }
       }
 
@@ -126,6 +135,12 @@ void ReedSolomonMultiBlockTest(int n_sourceblocks) {
   fec::RSEncoder encoder(k, n);
   fec::RSDecoder decoder(k, n);
 
+  // Setup random engine
+  std::random_device
+      rd;  // Will be used to obtain a seed for the random number engine
+  std::mt19937 gen(rd());  // Standard mersenne_twister_engine seeded with rd()
+  std::uniform_int_distribution<> dis(0, 99);
+
   auto &packet_manager = core::PacketManager<>::getInstance();
 
   std::vector<std::pair<fec::buffer, uint32_t>> tx_block;
@@ -136,33 +151,39 @@ void ReedSolomonMultiBlockTest(int n_sourceblocks) {
   // Receiver will receive packet for n_sourceblocks in a random order.
   int total_packets = n * n_sourceblocks;
   int tx_packets = k * n_sourceblocks;
-  unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
 
-  encoder.setFECCallback(
-      [&](std::vector<std::pair<uint32_t, fec::buffer>> &repair_packets) {
-        for (auto &p : repair_packets) {
-          // Append repair symbols to tx_block
-          tx_block.emplace_back(std::move(p.second), ++i);
-        }
+  encoder.setFECCallback([&tx_block, &rx_block, &i, &n, &k,
+                          &encoder](fec::BufferArray &repair_packets) {
+    for (auto &p : repair_packets) {
+      // Append repair symbols to tx_block
+      ++i;
+      tx_block.emplace_back(std::move(p.getBuffer()), i);
+    }
 
-        EXPECT_EQ(tx_block.size(), size_t(n));
+    EXPECT_EQ(tx_block.size(), size_t(n));
 
-        // Select k packets to send, including at least one symbol. We start
-        // from the end for this reason.
-        for (int j = n - 1; j > n - k - 1; j--) {
-          rx_block.emplace_back(std::move(tx_block[j]));
-        }
+    // Select k packets to send, including at least one symbol. We start
+    // from the end for this reason.
+    for (int j = n - 1; j > n - k - 1; j--) {
+      rx_block.emplace_back(std::move(tx_block[j]));
+    }
 
-        // Clear tx block for next source block
-        tx_block.clear();
-        encoder.clear();
-      });
+    // Clear tx block for next source block
+    tx_block.clear();
+    encoder.clear();
+  });
 
   // The decode callback must be called exactly n_sourceblocks times
-  decoder.setFECCallback(
-      [&](std::vector<std::pair<uint32_t, fec::buffer>> &source_packets) {
-        count++;
-      });
+  decoder.setFECCallback([&count](fec::BufferArray &source_packets) {
+    // Check buffers
+    for (auto &packet : source_packets) {
+      auto packet_index = ((uint32_t *)packet.getBuffer()->writableData())[0];
+      EXPECT_EQ(packet_index, packet.getIndex())
+          << "Packet index: " << packet_index
+          << " --  FEC Index: " << packet.getIndex();
+    }
+    count++;
+  });
 
   // Produce n * n_sourceblocks
   //  - (  k  ) * n_sourceblocks source packets
@@ -173,7 +194,7 @@ void ReedSolomonMultiBlockTest(int n_sourceblocks) {
 
     // Let's append a bit less than size, so that the FEC class will take care
     // of filling the rest with zeros
-    auto cur_size = size - (rand() % 100);
+    auto cur_size = size - dis(gen);
 
     // Set payload, saving 2 bytes at the beginning of the buffer for encoding
     // the length
@@ -182,7 +203,7 @@ void ReedSolomonMultiBlockTest(int n_sourceblocks) {
     std::fill(packet->writableData(), packet->writableTail(), i + 1);
 
     // Set first byte of payload to i, to reorder at receiver side
-    packet->writableData()[0] = uint8_t(i);
+    ((uint32_t *)packet->writableData())[0] = uint32_t(i);
 
     // Store packet in tx buffer
     tx_block.emplace_back(packet, i);
@@ -195,8 +216,7 @@ void ReedSolomonMultiBlockTest(int n_sourceblocks) {
   EXPECT_EQ(size_t(tx_packets), size_t(rx_block.size()));
 
   // Lets shuffle the rx_block before starting feeding the decoder.
-  std::shuffle(rx_block.begin(), rx_block.end(),
-               std::default_random_engine(seed));
+  std::shuffle(rx_block.begin(), rx_block.end(), gen);
 
   for (auto &p : rx_block) {
     int index = p.second % n;
@@ -231,7 +251,7 @@ foreach_rs_fec_type
 #undef _
 
 TEST(ReedSolomonMultiBlockTest, RSMB10) {
-  int blocks = 10;
+  int blocks = 1;
   ReedSolomonMultiBlockTest(blocks);
 }
 
diff --git a/libtransport/src/test/test_fec_rely_wrapper.cc b/libtransport/src/test/test_fec_rely_wrapper.cc
index c5b73f8d2..764e4dd2d 100644
--- a/libtransport/src/test/test_fec_rely_wrapper.cc
+++ b/libtransport/src/test/test_fec_rely_wrapper.cc
@@ -13,18 +13,23 @@
  * limitations under the License.
  */
 
+#include <glog/logging.h>
 #include <gtest/gtest.h>
 #include <hicn/transport/core/global_object_pool.h>
+#include <hicn/transport/interfaces/socket_options_default_values.h>
 #include <hicn/transport/utils/log.h>
 #include <protocols/fec/rely.h>
 
 #include <queue>
+#include <random>
 
 namespace transport {
 namespace protocol {
 
-std::string printMissing(
-    const std::map<uint32_t, core::ContentObject::Ptr> &missing) {
+using SavedPacketMap =
+    std::map<uint32_t, std::pair<core::ContentObject::Ptr, uint32_t>>;
+
+std::string printMissing(const SavedPacketMap &missing) {
   std::stringstream stream;
 
   for (auto &[seq, packet] : missing) {
@@ -48,14 +53,15 @@ std::string printMissing(
  * @param loss_rate The loss rate
  */
 void testRelyEncoderDecoder(uint32_t k, uint32_t n, size_t max_packet_size,
-                            int64_t timeout, uint32_t max_iterations,
+                            int64_t /* timeout */, uint32_t max_iterations,
                             int loss_rate) {
   // Create 1 encoder and 1 decoder
   fec::RelyEncoder _encoder(k, n);
   fec::RelyDecoder _decoder(k, n);
 
   // Seed the pseudo-random with known value to always get same loss pattern
-  srand(k * n);
+  std::mt19937 gen(k *
+                   n);  // Standard mersenne_twister_engine seeded with rd();
 
   // We will interact with rely encoder/decoder using the interface
   fec::ProducerFEC &encoder = _encoder;
@@ -68,73 +74,78 @@ void testRelyEncoderDecoder(uint32_t k, uint32_t n, size_t max_packet_size,
   auto &packet_manager = core::PacketManager<>::getInstance();
 
   // Store packets to verify them in the decoder callback
-  std::map<uint32_t, core::ContentObject::Ptr> saved_packets;
+  SavedPacketMap saved_packets;
 
   // Save repair packets here in encoder callback
   std::queue<fec::buffer> pending_repair_packets;
 
   // Set callback called by encoder when a buffer is required.
-  encoder.setBufferCallback([](std::size_t size) -> fec::buffer {
+  encoder.setBufferCallback([](std::size_t size) {
     auto ret =
-        core::PacketManager<>::getInstance().getPacket<core::ContentObject>();
+        core::PacketManager<>::getInstance().getPacket<core::ContentObject>(
+            transport::interface::default_values::packet_format);
     ret->updateLength(size);
     ret->append(size);
     ret->trimStart(ret->headerSize());
-    assert(ret->length() >= size);
+    DCHECK(ret->length() >= size);
 
     return ret;
   });
 
   // Set callback to be called by encoder when repair packets are ready
-  encoder.setFECCallback(
-      [&](std::vector<std::pair<uint32_t, fec::buffer>> &packets) {
-        // We must get n - k symbols
-        EXPECT_EQ(packets.size(), n - k);
-        // TRANSPORT_LOGD("Got %zu symbols", packets.size());
-
-        // Save symbols in pending_repair_packets queue and increment iterations
-        for (auto &packet : packets) {
-          ++iterations;
-          pending_repair_packets.push(packet.second);
-        }
-      });
+  encoder.setFECCallback([&iterations, &pending_repair_packets, &n,
+                          &k](fec::BufferArray &packets) {
+    // We must get n - k symbols
+    EXPECT_EQ(packets.size(), n - k);
+    DLOG_IF(INFO, VLOG_IS_ON(3)) << "Got " << packets.size() << " symbols";
+
+    // Save symbols in pending_repair_packets queue and increment iterations
+    for (auto &packet : packets) {
+      ++iterations;
+      pending_repair_packets.push(packet.getBuffer());
+    }
+  });
 
   // Set callback to be called when decoder recover a packet
-  decoder.setFECCallback(
-      [&](std::vector<std::pair<uint32_t, fec::buffer>> &packets) {
-        for (auto &packet : packets) {
-          // TRANSPORT_LOGD("Recovering packet %u", packet.first);
+  decoder.setFECCallback([&saved_packets](fec::BufferArray &packets) {
+    for (auto &packet : packets) {
+      DLOG_IF(INFO, VLOG_IS_ON(3)) << "Recovering packet " << packet.getIndex();
+
+      // Ensure recovered packet is in packets actually produced by encoder
+      auto original = saved_packets.find(packet.getIndex());
+      ASSERT_TRUE(original != saved_packets.end());
+      auto &original_packet = *original->second.first;
 
-          // Ensure recovered packet is in packets actually produced by encoder
-          auto original = saved_packets.find(packet.first);
-          ASSERT_TRUE(original != saved_packets.end());
-          auto &original_packet = *original->second;
+      // Remove additional headers at the beginning of the packet. This may
+      // change in the future.
+      original_packet.trimStart(60 /* Ip + TCP */ + 32 /* Rely header */ +
+                                4 /* Packet size */);
 
-          // Remove additional headers at the beginning of the packet. This may
-          // change in the future.
-          original_packet.trimStart(60 /* Ip + TCP */ + 28 /* Rely header */ +
-                                    4 /* Packet size */);
+      // Recovered packet should be equal to the original one
+      EXPECT_TRUE(original_packet == *packet.getBuffer());
 
-          // Recovered packet should be equal to the original one
-          EXPECT_TRUE(original_packet == *packet.second);
+      // Also metadata should correspond
+      EXPECT_TRUE(original->second.second == packet.getMetadata());
 
-          // Restore removed headers
-          original_packet.prepend(60 + 28 + 4);
+      // Restore removed headers
+      original_packet.prepend(60 + 32 + 4);
 
-          // Erase packet from saved packet list
-          saved_packets.erase(original);
-        }
-      });
+      // Erase packet from saved packet list
+      saved_packets.erase(original);
+    }
+  });
 
   // Send max_iterations packets from encoder to decoder
+  std::uniform_int_distribution<> dis(0, 1299);
   while (iterations < max_iterations) {
     // Create a payload, the size is between 50 and 1350 bytes.
-    auto payload_size = 50 + (rand() % 1300);
+    auto payload_size = 50 + (dis(gen));
     uint8_t payload[max_packet_size];
-    std::generate(payload, payload + payload_size, rand);
+    std::generate(payload, payload + payload_size, gen);
 
     // Get a packet from global pool and set name
-    auto buffer = packet_manager.getPacket<core::ContentObject>();
+    auto buffer = packet_manager.getPacket<core::ContentObject>(
+        transport::interface::default_values::packet_format);
     buffer->setName(core::Name("b001::abcd", iterations));
 
     // Get offset
@@ -145,20 +156,23 @@ void testRelyEncoderDecoder(uint32_t k, uint32_t n, size_t max_packet_size,
     // its own header).
     buffer->appendPayload(payload, payload_size);
 
+    // Set an u32 metadata to pass altogether with the buffer
+    uint32_t metadata = dis(gen);
+
     // Save packet in the saving_packets list
-    // TRANSPORT_LOGD("Saving packet with index %lu", iterations);
-    saved_packets.emplace(iterations, buffer);
+    DLOG_IF(INFO, VLOG_IS_ON(3)) << "Saving packet with index " << iterations;
+    saved_packets.emplace(iterations, std::make_pair(buffer, metadata));
 
     // Feed buffer into the encoder. This will eventually trigger a call to the
     // FEC callback as soon as k packets are fed into the endocer.
-    encoder.onPacketProduced(*buffer, offset);
+    encoder.onPacketProduced(*buffer, offset, metadata);
 
     // Check returned packet. We calculate the difference in size and we compare
     // only the part of the returned packet corresponding to the original
     // payload. Rely should only add a header and should not modify the actual
     // payload content. If it does it, this check will fail.
     auto diff = buffer->length() - payload_size - offset;
-    // TRANSPORT_LOGD("Difference is %zu", diff);
+    DLOG_IF(INFO, VLOG_IS_ON(3)) << "Difference is " << diff;
     auto cmp =
         std::memcmp(buffer->data() + offset + diff, payload, payload_size);
     EXPECT_FALSE(cmp);
@@ -170,29 +184,33 @@ void testRelyEncoderDecoder(uint32_t k, uint32_t n, size_t max_packet_size,
     // using future packets that are not created in the test. For this reason,
     // we ensure the test ends without losses.
 #define DROP_CONDITION(loss_rate, max_iterations) \
-  (rand() % 100) >= loss_rate || iterations >= max_iterations * 0.9
+  (dis(gen)) >= loss_rate || iterations >= max_iterations * 0.9
 
     // Handle the source packet to the decoder, id drop condition returns true
     if (DROP_CONDITION(loss_rate, max_iterations)) {
       // Pass packet to decoder
-      // TRANSPORT_LOGD("Passing packet %u to decoder",
-      //                buffer->getName().getSuffix());
-      decoder.onDataPacket(*buffer, offset);
+      DLOG_IF(INFO, VLOG_IS_ON(3))
+          << "Passing packet " << buffer->getName().getSuffix()
+          << " to decoder";
+      decoder.onDataPacket(*buffer, offset, metadata);
     } else {
-      // TRANSPORT_LOGD("Packet %u, dropped", buffer->getName().getSuffix());
+      DLOG_IF(INFO, VLOG_IS_ON(3))
+          << "Packet " << buffer->getName().getSuffix() << " dropped";
     }
 
-    // Check if previous call to encoder.consumer() generated repair packets,
+    // Check if previous call to encoder.consume() generated repair packets,
     // and if yes, feed them to the decoder.
     while (pending_repair_packets.size()) {
       // Also repair packets can be lost
       if (DROP_CONDITION(loss_rate, max_iterations)) {
         auto &packet = pending_repair_packets.front();
-        // TRANSPORT_LOGD("Passing packet %u to decoder", iterations);
+        DLOG_IF(INFO, VLOG_IS_ON(3))
+            << "Passing packet " << iterations << " to decoder";
         core::ContentObject &co = (core::ContentObject &)(*packet);
         decoder.onDataPacket(co, 0);
       } else {
-        // TRANSPORT_LOGD("Packet (repair) %u dropped", iterations);
+        DLOG_IF(INFO, VLOG_IS_ON(3))
+            << "Packet (repair) " << iterations << " dropped";
       }
 
       // Remove packet from the queue
@@ -206,9 +224,6 @@ void testRelyEncoderDecoder(uint32_t k, uint32_t n, size_t max_packet_size,
   // 0.001 residual losses
   EXPECT_LE(saved_packets.size(), iterations * 0.001)
       << printMissing(saved_packets);
-
-  // Reset seed
-  srand(time(0));
 }
 
 /**
diff --git a/libtransport/src/test/test_fixed_block_allocator.cc b/libtransport/src/test/test_fixed_block_allocator.cc
new file mode 100644
index 000000000..33e048031
--- /dev/null
+++ b/libtransport/src/test/test_fixed_block_allocator.cc
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <hicn/transport/core/global_object_pool.h>
+#include <hicn/transport/utils/event_thread.h>
+#include <hicn/transport/utils/fixed_block_allocator.h>
+
+namespace utils {
+
+class FixedBlockAllocatorTest : public ::testing::Test {
+ protected:
+  static inline const std::size_t default_size = 2048;
+  static inline const std::size_t default_n_buffer = 1024;
+
+  // Get fixed block allocator_ of 1024 buffers of size 2048 bytes
+  FixedBlockAllocatorTest()
+      : allocator_(
+            ::utils::FixedBlockAllocator<default_size,
+                                         default_n_buffer>::getInstance()) {
+    // You can do set-up work for each test here.
+  }
+
+  virtual ~FixedBlockAllocatorTest() {
+    // You can do clean-up work that doesn't throw exceptions here.
+  }
+
+  // If the constructor and destructor are not enough for setting up
+  // and cleaning up each test, you can define the following methods:
+
+  virtual void SetUp() {
+    // Code here will be called immediately after the constructor (right
+    // before each test).
+    allocator_.reset();
+  }
+
+  virtual void TearDown() {
+    // Code here will be called immediately after each test (right
+    // before the destructor).
+    allocator_.reset();
+  }
+
+  static bool pointerIsAligned(const void *pointer, size_t byte_count) {
+    // Sanity check
+    EXPECT_THAT(reinterpret_cast<std::uintptr_t>(pointer) &
+                    (alignof(std::max_align_t) - 1),
+                testing::Eq(std::uintptr_t(0)));
+
+    return uintptr_t(pointer) % byte_count == 0;
+  }
+
+  ::utils::FixedBlockAllocator<default_size, default_n_buffer> &allocator_;
+};
+
+TEST_F(FixedBlockAllocatorTest, DefaultChecks) {
+  EXPECT_EQ(allocator_.blockSize(), default_size);
+  EXPECT_EQ(allocator_.blockCount(), default_n_buffer);
+  EXPECT_EQ(allocator_.allocations(), 0UL);
+  EXPECT_EQ(allocator_.deallocations(), 0UL);
+  EXPECT_EQ(allocator_.blocksInUse(), 0UL);
+
+  // Allocate one single block of memory
+  auto block = allocator_.allocateBlock();
+
+  ASSERT_THAT(block, testing::NotNull());
+
+  // Check statistics
+  EXPECT_EQ(allocator_.allocations(), 1UL);
+  EXPECT_EQ(allocator_.deallocations(), 0UL);
+  EXPECT_EQ(allocator_.blocksInUse(), 1UL);
+
+  // Deallocate it
+  allocator_.deallocateBlock(block);
+
+  // check statistics
+  EXPECT_EQ(allocator_.allocations(), 1UL);
+  EXPECT_EQ(allocator_.deallocations(), 1UL);
+  EXPECT_EQ(allocator_.blocksInUse(), 0UL);
+
+  // Test reset
+  allocator_.reset();
+
+  EXPECT_EQ(allocator_.blockSize(), default_size);
+  EXPECT_EQ(allocator_.blockCount(), default_n_buffer);
+  EXPECT_EQ(allocator_.allocations(), 0UL);
+  EXPECT_EQ(allocator_.deallocations(), 0UL);
+  EXPECT_EQ(allocator_.blocksInUse(), 0UL);
+}
+
+TEST_F(FixedBlockAllocatorTest, CheckMemoryIsReused) {
+  // Get one block. As it is the first one, it will be retrieved from the pool
+  auto block = allocator_.allocateBlock();
+
+  // Make sure block is valid
+  ASSERT_THAT(block, testing::NotNull());
+
+  // Release block
+  allocator_.deallocateBlock(block);
+
+  // Get same memory block again
+  auto block2 = allocator_.allocateBlock();
+
+  // Make sure memory is reused
+  ASSERT_EQ(block, block2);
+
+  // Get a third block
+  auto block3 = allocator_.allocateBlock();
+
+  // Make sure is different memory
+  ASSERT_NE(block2, block3);
+
+  // Deallocate both and check we get back the laso one
+  allocator_.deallocateBlock(block2);
+  allocator_.deallocateBlock(block3);
+
+  auto block4 = allocator_.allocateBlock();
+  ASSERT_EQ(block3, block4);
+}
+
+TEST_F(FixedBlockAllocatorTest, CheckMemoryIsContiguous) {
+  // Get one block. As it is the first one, it will be retrieved from the pool
+  auto block = reinterpret_cast<uint8_t *>(allocator_.allocateBlock());
+
+  // Make sure block is valid
+  ASSERT_THAT(block, testing::NotNull());
+
+  // Get another block
+  auto block2 = reinterpret_cast<uint8_t *>(allocator_.allocateBlock());
+
+  // Make sure block is valid
+  ASSERT_THAT(block2, testing::NotNull());
+
+  // Check the 2 blocks come from contiguous memory
+  ASSERT_THAT(std::size_t(block2 - block), testing::Eq(default_size));
+}
+
+TEST_F(FixedBlockAllocatorTest, CheckPoolExpansion) {
+  // Get all the blocks we setup when constructing the allocator
+  std::array<uint8_t *, default_n_buffer> blocks;
+  blocks[0] = reinterpret_cast<uint8_t *>(allocator_.allocateBlock());
+  for (std::size_t i = 1; i < default_n_buffer; i++) {
+    blocks[i] = reinterpret_cast<uint8_t *>(allocator_.allocateBlock());
+    ASSERT_THAT(std::size_t(blocks[i] - blocks[i - 1]),
+                testing::Eq(default_size));
+  }
+
+  ASSERT_THAT(allocator_.blockCount(), testing::Eq(default_n_buffer));
+
+  // We should have finished all the blocks belonging to first pool. Let's get
+  // one additional block
+  auto new_block = reinterpret_cast<uint8_t *>(allocator_.allocateBlock());
+
+  // Make sure the block count doubled its size
+  ASSERT_THAT(allocator_.blockCount(), testing::Eq(2 * default_n_buffer));
+
+  // Check the new block is not contiguous with respect last block in blocks
+  ASSERT_THAT(std::size_t(new_block - blocks[default_n_buffer - 1]),
+              testing::Ne(default_size));
+}
+
+TEST_F(FixedBlockAllocatorTest, CheckMemoryIsAligned) {
+  for (std::size_t i = 0; i < default_n_buffer; i++) {
+    auto block = reinterpret_cast<uint8_t *>(allocator_.allocateBlock());
+    ASSERT_THAT(pointerIsAligned(block, alignof(std::max_align_t)),
+                testing::IsTrue);
+  }
+}
+
+TEST_F(FixedBlockAllocatorTest, Multithreading) {
+  // Create 4 threads
+  utils::EventThread threads[4];
+  ::utils::FixedBlockAllocator<default_size, default_n_buffer>
+      *allocator_addresses[4] = {nullptr, nullptr, nullptr, nullptr};
+  int i = 0;
+  for (auto &t : threads) {
+    t.add([&allocator_addresses, i]() {
+      auto &allocator =
+          ::utils::FixedBlockAllocator<default_size,
+                                       default_n_buffer>::getInstance();
+      allocator_addresses[i] = &allocator;
+    });
+    i++;
+  }
+
+  // Stop threads
+  for (auto &t : threads) {
+    t.stop();
+  }
+
+  // Check the instance of allocator was different for each thread
+  for (int i = 0; i < 4; i++) {
+    for (int j = i + 1; j < 4; j++) {
+      ASSERT_NE(allocator_addresses[i], allocator_addresses[j]);
+    }
+  }
+}
+
+}  // namespace utils
\ No newline at end of file
diff --git a/libtransport/src/test/test_interest.cc b/libtransport/src/test/test_interest.cc
index 8853563b0..d9c535881 100644
--- a/libtransport/src/test/test_interest.cc
+++ b/libtransport/src/test/test_interest.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -30,7 +30,7 @@ namespace {
 // The fixture for testing class Foo.
 class InterestTest : public ::testing::Test {
  protected:
-  InterestTest() : name_("b001::123|321"), interest_() {
+  InterestTest() : name_("b001::123|321"), interest_(HF_INET6_TCP) {
     // You can do set-up work for each test here.
   }
 
@@ -108,7 +108,7 @@ TEST_F(InterestTest, ConstructorWithName) {
   Name n("b001::1|123");
 
   try {
-    Interest interest(n);
+    Interest interest(HF_INET6_TCP, n);
   } catch (...) {
     FAIL() << "ERROR: Unexpected exception thrown";
   }
@@ -176,27 +176,27 @@ TEST_F(InterestTest, SetGetLocator) {
   auto l = interest.getLocator();
 
   ip_address_t address;
-  ip_address_pton("b006::ab:cdab:cdef", &address);
-  auto ret = !std::memcmp(&l, &address, sizeof(address));
+  inet_pton(AF_INET6, "b006::ab:cdab:cdef", &address);
+  auto ret = !ip_address_cmp(&l, &address, AF_INET6);
 
   EXPECT_TRUE(ret);
 
   // Set different locator
-  ip_address_pton("2001::1234::4321::abcd::", &address);
+  inet_pton(AF_INET6, "2001::1234::4321::abcd::", &address);
 
   // Set it on interest
   interest.setLocator(address);
 
   // Check it was set
   l = interest.getLocator();
-  ret = !std::memcmp(&l, &address, sizeof(address));
+  ret = !ip_address_cmp(&l, &address, AF_INET6);
 
   EXPECT_TRUE(ret);
 }
 
 TEST_F(InterestTest, SetGetLifetime) {
   // Create interest from buffer
-  Interest interest;
+  Interest interest(HF_INET6_TCP);
   const constexpr uint32_t lifetime = 10000;
 
   // Set lifetime
@@ -211,7 +211,7 @@ TEST_F(InterestTest, SetGetLifetime) {
 
 TEST_F(InterestTest, HasManifest) {
   // Create interest from buffer
-  Interest interest;
+  Interest interest(HF_INET6_TCP);
 
   // Let's expect anexception here
   try {
@@ -232,7 +232,7 @@ TEST_F(InterestTest, HasManifest) {
 
 TEST_F(InterestTest, AppendSuffixesEncodeAndIterate) {
   // Create interest from buffer
-  Interest interest;
+  Interest interest(HF_INET6_TCP);
 
   // Appenad some suffixes, with some duplicates
   interest.appendSuffix(1);
diff --git a/libtransport/src/test/test_memif_connector.cc b/libtransport/src/test/test_memif_connector.cc
new file mode 100644
index 000000000..562a12c88
--- /dev/null
+++ b/libtransport/src/test/test_memif_connector.cc
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2022 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <core/memif_connector.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <hicn/transport/core/global_object_pool.h>
+#include <hicn/transport/utils/chrono_typedefs.h>
+
+namespace transport {
+namespace core {
+
+namespace {
+
+using namespace std::placeholders;
+
+/**
+ * Master memif connector
+ */
+template <int Master>
+class Memif {
+  static inline std::size_t counter = 256;
+  static inline std::size_t total_packets = counter * 4096;
+  static inline std::size_t packet_size = 64;
+
+ public:
+  Memif(asio::io_service &io_service)
+      : io_service_(io_service),
+        memif_connector_(std::make_shared<MemifConnector>(
+            std::bind(&Memif::onPacketReceived, this, _1, _2, _3),
+            std::bind(&Memif::onPacketSent, this, _1, _2),
+            std::bind(&Memif::onClose, this, _1),
+            std::bind(&Memif::onReconnect, this, _1, _2), io_service_,
+            Master ? "test_master" : "test_slave")),
+        recv_counter_(0),
+        sent_counter_(0) {
+    memif_connector_->connect(0 /* Memif ID */, Master /* Is Master */,
+                              "@hicntransport/test/memif");
+  }
+
+  void setStart() { t0_ = utils::SteadyTime::now(); }
+
+  void startTest() {
+    if constexpr (!Master) {
+      auto &packet_manager = core::PacketManager<>::getInstance();
+
+      // Send in busrt of 256 packet per time
+      for (std::size_t i = 0; i < counter; i++) {
+        auto packet = packet_manager.getMemBuf();
+        packet->append(packet_size);
+        memif_connector_->send(packet);
+        sent_counter_++;
+      }
+
+      if (sent_counter_ < total_packets) {
+        asio::post(io_service_, std::bind(&Memif::startTest, this));
+      }
+    } else {
+      setStart();
+    }
+  }
+
+  auto getRecvCounter() { return recv_counter_; }
+  auto getSentCounter() { return sent_counter_; }
+
+ private:
+  void onPacketReceived(Connector *c,
+                        const std::vector<utils::MemBuf::Ptr> &buffers,
+                        const std::error_code &ec) {
+    if constexpr (Master) {
+      recv_counter_ += buffers.size();
+      if (recv_counter_ == total_packets) {
+        auto t1 = utils::SteadyTime::now();
+        auto delta = utils::SteadyTime::getDurationS(t0_, t1);
+        auto rate = recv_counter_ / delta.count();
+        LOG(INFO) << "rate: " << rate << " packets/s";
+        io_service_.stop();
+      }
+    } else {
+      FAIL() << "Slave should not receive packets";
+    }
+  }
+  void onPacketSent(Connector *c, const std::error_code &ec) {}
+  void onClose(Connector *c) {}
+  void onReconnect(Connector *c, const std::error_code &ec) {}
+
+ private:
+  asio::io_service &io_service_;
+  std::shared_ptr<MemifConnector> memif_connector_;
+  std::size_t recv_counter_;
+  std::size_t sent_counter_;
+  utils::SteadyTime::TimePoint t0_;
+};
+
+using MemifMaster = Memif<1>;
+using MemifSlave = Memif<0>;
+
+}  // namespace
+
+class MemifTest : public ::testing::Test {
+ protected:
+  MemifTest() : io_service_(), master_(io_service_), slave_(io_service_) {
+    // You can do set-up work for each test here.
+  }
+
+  void run() {
+    asio::post(io_service_, std::bind(&MemifSlave::startTest, &slave_));
+    master_.startTest();
+    io_service_.run();
+
+    EXPECT_THAT(master_.getRecvCounter(),
+                ::testing::Eq(slave_.getSentCounter()));
+  }
+
+  virtual ~MemifTest() {
+    // You can do clean-up work that doesn't throw exceptions here.
+  }
+
+  // If the constructor and destructor are not enough for setting up
+  // and cleaning up each test, you can define the following methods:
+
+  virtual void SetUp() {
+    // Code here will be called immediately after the constructor (right
+    // before each test).
+  }
+
+  virtual void TearDown() {
+    // Code here will be called immediately after each test (right
+    // before the destructor).
+  }
+
+ protected:
+  asio::io_service io_service_;
+  MemifMaster master_;
+  MemifSlave slave_;
+};
+
+TEST_F(MemifTest, Test) { run(); }
+}  // namespace core
+}  // namespace transport
diff --git a/libtransport/src/test/test_packet.cc b/libtransport/src/test/test_packet.cc
index 76ad352d6..ca20cdfb7 100644
--- a/libtransport/src/test/test_packet.cc
+++ b/libtransport/src/test/test_packet.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,6 +16,7 @@
 #include <gtest/gtest.h>
 #include <hicn/transport/core/packet.h>
 #include <hicn/transport/errors/not_implemented_exception.h>
+#include <hicn/transport/utils/chrono_typedefs.h>
 #include <test/packet_samples.h>
 
 #include <climits>
@@ -33,7 +34,7 @@ namespace core {
 class PacketForTest : public Packet {
  public:
   template <typename... Args>
-  PacketForTest(Args &&... args) : Packet(std::forward<Args>(args)...) {}
+  PacketForTest(Args &&...args) : Packet(std::forward<Args>(args)...) {}
 
   virtual ~PacketForTest() {}
 
@@ -302,7 +303,7 @@ TEST_F(PacketTest, ConstructorWithNew) {
   auto &_packet = raw_packets_[HF_INET6_TCP];
   auto packet_ptr = new PacketForTest(Packet::WRAP_BUFFER, &_packet[0],
                                       _packet.size(), _packet.size());
-  (void)packet_ptr;
+  delete packet_ptr;
 }
 
 TEST_F(PacketTest, ConstructorWithRawBufferInet6Tcp) {
@@ -682,9 +683,7 @@ TEST_F(PacketTest, SetGetTestSignatureTimestamp) {
   // Let's try to set the signature timestamp in a packet without AH header. We
   // expect an exception.
   using namespace std::chrono;
-  uint64_t now =
-      duration_cast<milliseconds>(system_clock::now().time_since_epoch())
-          .count();
+  uint64_t now = utils::SteadyTime::nowMs().count();
 
   try {
     packet.setSignatureTimestamp(now);
diff --git a/libtransport/src/test/test_packet_allocator.cc b/libtransport/src/test/test_packet_allocator.cc
new file mode 100644
index 000000000..b63ddde8d
--- /dev/null
+++ b/libtransport/src/test/test_packet_allocator.cc
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <glog/logging.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <hicn/transport/core/content_object.h>
+#include <hicn/transport/core/interest.h>
+#define ALLOCATION_CHECKS
+#include <hicn/transport/core/global_object_pool.h>
+#undef ALLOCATION_CHECKS
+#include <hicn/transport/utils/event_thread.h>
+
+namespace transport {
+namespace core {
+
+class PacketAllocatorTest : public ::testing::Test {
+ protected:
+  static inline const std::size_t default_size = 2048;
+  static inline const std::size_t default_n_buffer = 1024;
+
+  // Get fixed block allocator_ of 1024 buffers of size 2048 bytes
+  PacketAllocatorTest() : allocator_(PacketManager<>::getInstance()) {
+    // You can do set-up work for each test here.
+  }
+
+  virtual ~PacketAllocatorTest() {
+    // You can do clean-up work that doesn't throw exceptions here.
+  }
+
+  // If the constructor and destructor are not enough for setting up
+  // and cleaning up each test, you can define the following methods:
+
+  virtual void SetUp() {}
+
+  virtual void TearDown() {}
+
+  static bool pointerIsAligned(const void *pointer, size_t byte_count) {
+    return uintptr_t(pointer) % byte_count == 0;
+  }
+
+  template <typename T, typename... Args>
+  void allocationTest(Args &&...args) {
+    // Create packet
+    auto packet = allocator_.getPacket<T>(std::forward<Args>(args)...);
+
+    // Check boundaries
+    LOG(INFO) << "packet size: " << sizeof(*packet) + sizeof(packet)
+              << std::endl;
+    EXPECT_LE(sizeof(*packet) + sizeof(packet) + sizeof(std::max_align_t),
+              sizeof(PacketManager<>::PacketStorage::packet_and_shared_ptr));
+  }
+
+  PacketManager<> &allocator_;
+};
+
+TEST_F(PacketAllocatorTest, ContentObjectAllocation) {
+  allocationTest<core::ContentObject>(HF_INET_TCP);
+}
+
+TEST_F(PacketAllocatorTest, InterestAllocation) {
+  allocationTest<core::Interest>(HF_INET_TCP);
+}
+
+// TEST_F(PacketAllocatorTest, MemBufAllocation) {
+//   allocationTest<::utils::MemBuf>();
+// }
+
+TEST_F(PacketAllocatorTest, CheckAllocationIsCorrect) {
+  // Create packet
+  auto packet = allocator_.getPacket<core::ContentObject>(HF_INET_TCP);
+
+  // Address of actual buffer
+  uint8_t *buffer_address = packet->writableData();
+
+  // Address of packet
+  uint8_t *packet_address = reinterpret_cast<uint8_t *>(packet.get());
+
+  uint8_t *start_address =
+      buffer_address -
+      sizeof(PacketManager<>::PacketStorage::packet_and_shared_ptr);
+
+  // Check memory was allocated on correct positions
+  EXPECT_TRUE(pointerIsAligned(start_address, alignof(std::max_align_t)));
+  EXPECT_TRUE(packet_address > start_address &&
+              packet_address < buffer_address);
+  EXPECT_TRUE(pointerIsAligned(buffer_address, alignof(std::max_align_t)));
+  EXPECT_THAT(std::size_t(buffer_address - start_address),
+              testing::Eq(sizeof(
+                  PacketManager<>::PacketStorage::packet_and_shared_ptr)));
+}
+
+}  // namespace core
+}  // namespace transport
\ No newline at end of file
diff --git a/libtransport/src/test/test_quality_score.cc b/libtransport/src/test/test_quality_score.cc
new file mode 100644
index 000000000..9513c94a6
--- /dev/null
+++ b/libtransport/src/test/test_quality_score.cc
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <hicn/transport/utils/rtc_quality_score.h>
+
+#include <climits>
+#include <random>
+#include <vector>
+
+namespace transport {
+
+namespace protocol {
+
+namespace rtc {
+
+TEST(QualityScoreTest, testQS) {
+  RTCQualityScore qs;
+  uint8_t score;
+
+  // 0 losses
+  score = qs.getQualityScore(0, 0);
+  EXPECT_EQ(score, (uint8_t)5);
+
+  score = qs.getQualityScore(98, 0);
+  EXPECT_EQ(score, (uint8_t)5);
+
+  score = qs.getQualityScore(188, 0);
+  EXPECT_EQ(score, (uint8_t)5);
+
+  score = qs.getQualityScore(398, 0);
+  EXPECT_EQ(score, (uint8_t)4);
+
+  score = qs.getQualityScore(400, 0);
+  EXPECT_EQ(score, (uint8_t)3);
+
+  score = qs.getQualityScore(598, 0);
+  EXPECT_EQ(score, (uint8_t)3);
+
+  score = qs.getQualityScore(600, 0);
+  EXPECT_EQ(score, (uint8_t)1);
+
+  score = qs.getQualityScore(700, 0);
+  EXPECT_EQ(score, (uint8_t)1);
+
+  score = qs.getQualityScore(50000, 0);
+  EXPECT_EQ(score, (uint8_t)1);
+
+  // 0 delay
+  score = qs.getQualityScore(0, 2);
+  EXPECT_EQ(score, (uint8_t)5);
+
+  score = qs.getQualityScore(0, 9);
+  EXPECT_EQ(score, (uint8_t)5);
+
+  score = qs.getQualityScore(0, 29);
+  EXPECT_EQ(score, (uint8_t)5);
+
+  score = qs.getQualityScore(0, 30);
+  EXPECT_EQ(score, (uint8_t)4);
+
+  score = qs.getQualityScore(0, 39);
+  EXPECT_EQ(score, (uint8_t)4);
+
+  score = qs.getQualityScore(0, 40);
+  EXPECT_EQ(score, (uint8_t)3);
+
+  score = qs.getQualityScore(0, 50);
+  EXPECT_EQ(score, (uint8_t)1);
+
+  score = qs.getQualityScore(0, 5000);
+  EXPECT_EQ(score, (uint8_t)1);
+
+  // loss < 10
+  score = qs.getQualityScore(0, 3);
+  EXPECT_EQ(score, (uint8_t)5);
+
+  score = qs.getQualityScore(98, 9);
+  EXPECT_EQ(score, (uint8_t)4);
+
+  score = qs.getQualityScore(100, 9);
+  EXPECT_EQ(score, (uint8_t)3);
+
+  score = qs.getQualityScore(398, 5);
+  EXPECT_EQ(score, (uint8_t)2);
+
+  score = qs.getQualityScore(400, 5);
+  EXPECT_EQ(score, (uint8_t)1);
+
+  score = qs.getQualityScore(4000, 5);
+  EXPECT_EQ(score, (uint8_t)1);
+
+  // loss < 20
+  score = qs.getQualityScore(0, 10);
+  EXPECT_EQ(score, (uint8_t)5);
+
+  score = qs.getQualityScore(30, 10);
+  EXPECT_EQ(score, (uint8_t)3);
+
+  score = qs.getQualityScore(198, 15);
+  EXPECT_EQ(score, (uint8_t)2);
+
+  score = qs.getQualityScore(200, 19);
+  EXPECT_EQ(score, (uint8_t)1);
+
+  score = qs.getQualityScore(300, 10);
+  EXPECT_EQ(score, (uint8_t)1);
+
+  // loss < 30
+
+  score = qs.getQualityScore(0, 29);
+  EXPECT_EQ(score, (uint8_t)5);
+
+  score = qs.getQualityScore(10, 29);
+  EXPECT_EQ(score, (uint8_t)2);
+
+  score = qs.getQualityScore(0, 100);
+  EXPECT_EQ(score, (uint8_t)1);
+}
+
+}  // namespace rtc
+}  // namespace protocol
+}  // namespace transport
diff --git a/libtransport/src/test/test_sessions.cc b/libtransport/src/test/test_sessions.cc
new file mode 100644
index 000000000..d2e8c27bb
--- /dev/null
+++ b/libtransport/src/test/test_sessions.cc
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <hicn/transport/interfaces/global_conf_interface.h>
+#include <hicn/transport/interfaces/socket_consumer.h>
+#include <hicn/transport/interfaces/socket_options_keys.h>
+#include <hicn/transport/interfaces/socket_producer.h>
+
+namespace transport {
+namespace interface {
+
+class SessionsTest : public ::testing::Test {
+ protected:
+  static inline const std::size_t default_size = 2048;
+  static inline const std::size_t default_n_buffer = 1024;
+
+  // Get fixed block allocator_ of 1024 buffers of size 2048 bytes
+  SessionsTest() {
+    // You can do set-up work for each test here.
+    // Set io_module to local forwarder with no external connections
+    global_config::IoModuleConfiguration config;
+    config.name = "forwarder_module";
+    config.set();
+  }
+
+  virtual ~SessionsTest() {
+    // You can do clean-up work that doesn't throw exceptions here.
+  }
+
+  // If the constructor and destructor are not enough for setting up
+  // and cleaning up each test, you can define the following methods:
+
+  virtual void SetUp() {
+    // Code here will be called immediately after the constructor (right
+    // before each test).
+  }
+
+  virtual void TearDown() {
+    // Code here will be called immediately after each test (right
+    // before the destructor).
+  }
+
+  std::vector<ConsumerSocket> consumers_;
+  std::vector<ProducerSocket> producers_;
+};
+
+TEST_F(SessionsTest, SessionAllocations) {
+  // Create 1000 consumer sockets and 1000 producer sockets
+  int cprotocol = TransportProtocolAlgorithms::RAAQM;
+  int pprotocol = ProductionProtocolAlgorithms::BYTE_STREAM;
+  int offset = 0;
+
+  for (int i = 0; i < 1000; i++) {
+    auto &c = consumers_.emplace_back(cprotocol + (offset % 3));
+    auto &p = producers_.emplace_back(pprotocol + (offset % 2));
+    c.connect();
+    p.connect();
+    offset++;
+  }
+}
+
+}  // namespace interface
+}  // namespace transport
\ No newline at end of file
diff --git a/libtransport/src/test/test_thread_pool.cc b/libtransport/src/test/test_thread_pool.cc
new file mode 100644
index 000000000..1b6b4cc81
--- /dev/null
+++ b/libtransport/src/test/test_thread_pool.cc
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <hicn/transport/utils/thread_pool.h>
+
+namespace utils {
+
+class ThreadPoolTest : public ::testing::Test {
+ protected:
+  ThreadPoolTest() : thread_pool_() {
+    // You can do set-up work for each test here.
+  }
+
+  virtual ~ThreadPoolTest() {
+    // You can do clean-up work that doesn't throw exceptions here.
+  }
+
+  // If the constructor and destructor are not enough for setting up
+  // and cleaning up each test, you can define the following methods:
+
+  virtual void SetUp() {
+    // Code here will be called immediately after the constructor (right
+    // before each test).
+  }
+
+  virtual void TearDown() {
+    // Code here will be called immediately after each test (right
+    // before the destructor).
+  }
+
+  ::utils::ThreadPool thread_pool_;
+};
+
+TEST_F(ThreadPoolTest, DefaultConstructor) {
+  // EXPECT_EQ(thread_pool_.GetNumThreads(), 0);
+  // EXPECT_EQ(thread_pool_.GetNumIdleThreads(), 0);
+  // EXPECT_EQ(thread_pool_.GetNumBusyThreads(), 0);
+}
+
+TEST_F(ThreadPoolTest, GetNThreads) {
+  auto n_threads = thread_pool_.getNThreads();
+  EXPECT_GT(n_threads, std::size_t(0));
+  EXPECT_EQ(n_threads, std::thread::hardware_concurrency());
+
+  ::utils::ThreadPool pool(64);
+  n_threads = pool.getNThreads();
+  EXPECT_GT(n_threads, std::size_t(0));
+  EXPECT_NE(n_threads, std::thread::hardware_concurrency());
+  EXPECT_EQ(n_threads, std::size_t(64));
+
+  // EXPECT_EQ(thread_pool_.GetNumThreads(), 0);
+  // EXPECT_EQ(thread_pool_.GetNumIdleThreads(), 0);
+  // EXPECT_EQ(thread_pool_.GetNumBusyThreads(), 0);
+}
+
+}  // namespace utils
\ No newline at end of file
diff --git a/libtransport/src/transport.config b/libtransport/src/transport.config
index 89db204d5..d5c2918a6 100644
--- a/libtransport/src/transport.config
+++ b/libtransport/src/transport.config
@@ -17,7 +17,7 @@ forwarder = {
       remote_port = 33436;
     }
   };
-  
+
   listeners = {
     l0 = {
       local_address = "127.0.0.1";
diff --git a/libtransport/src/utils/CMakeLists.txt b/libtransport/src/utils/CMakeLists.txt
index a85ab16bf..5bb76303a 100644
--- a/libtransport/src/utils/CMakeLists.txt
+++ b/libtransport/src/utils/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -23,6 +23,7 @@ list(APPEND SOURCE_FILES
 list(APPEND HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/event_reactor.h
   ${CMAKE_CURRENT_SOURCE_DIR}/min_filter.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/max_filter.h
   ${CMAKE_CURRENT_SOURCE_DIR}/stream_buffer.h
   ${CMAKE_CURRENT_SOURCE_DIR}/suffix_strategy.h
   ${CMAKE_CURRENT_SOURCE_DIR}/content_store.h
@@ -34,10 +35,6 @@ if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
     ${CMAKE_CURRENT_SOURCE_DIR}/epoll_event_reactor.h
     ${CMAKE_CURRENT_SOURCE_DIR}/fd_deadline_timer.h
   )
-
-  list(APPEND SOURCE_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/epoll_event_reactor.cc
-  )
 endif()
 
 if(NOT WIN32)
diff --git a/libtransport/src/utils/content_store.cc b/libtransport/src/utils/content_store.cc
index 8ae7fd4d4..d9d4147f7 100644
--- a/libtransport/src/utils/content_store.cc
+++ b/libtransport/src/utils/content_store.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -17,6 +17,7 @@
 #include <hicn/transport/core/content_object.h>
 #include <hicn/transport/core/interest.h>
 #include <hicn/transport/core/name.h>
+#include <hicn/transport/utils/chrono_typedefs.h>
 #include <utils/content_store.h>
 
 namespace utils {
@@ -56,7 +57,7 @@ void ContentStore::insert(
   fifo_list_.push_front(std::cref(content_object->getName()));
   auto pos = fifo_list_.begin();
   content_store_hash_table_[content_object->getName()] = ContentStoreEntry(
-      ObjectTimeEntry(content_object, std::chrono::steady_clock::now()), pos);
+      ObjectTimeEntry(content_object, utils::SteadyTime::now()), pos);
 }
 
 std::shared_ptr<ContentObject> ContentStore::find(const Name &name) {
@@ -67,8 +68,8 @@ std::shared_ptr<ContentObject> ContentStore::find(const Name &name) {
   if (it != content_store_hash_table_.end()) {
     auto content_lifetime = it->second.first.first->getLifetime();
     auto time_passed_since_creation =
-        std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now() - it->second.first.second)
+        utils::SteadyTime::getDurationMs(it->second.first.second,
+                                         utils::SteadyTime::now())
             .count();
 
     if (time_passed_since_creation > content_lifetime) {
diff --git a/libtransport/src/utils/content_store.h b/libtransport/src/utils/content_store.h
index abe5e7f6c..ecd62cc2c 100644
--- a/libtransport/src/utils/content_store.h
+++ b/libtransport/src/utils/content_store.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -35,8 +35,7 @@ using Name = transport::core::Name;
 using ContentObject = transport::core::ContentObject;
 using Interest = transport::core::Interest;
 
-typedef std::pair<std::shared_ptr<ContentObject>,
-                  std::chrono::steady_clock::time_point>
+typedef std::pair<std::shared_ptr<ContentObject>, utils::SteadyTime::TimePoint>
     ObjectTimeEntry;
 typedef std::pair<ObjectTimeEntry,
                   std::list<std::reference_wrapper<const Name>>::iterator>
diff --git a/libtransport/src/utils/daemonizator.cc b/libtransport/src/utils/daemonizator.cc
index 6cb7d16ba..4c17aa96b 100644
--- a/libtransport/src/utils/daemonizator.cc
+++ b/libtransport/src/utils/daemonizator.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/utils/deadline_timer.h b/libtransport/src/utils/deadline_timer.h
index 5187754f0..6c105ed3d 100644
--- a/libtransport/src/utils/deadline_timer.h
+++ b/libtransport/src/utils/deadline_timer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -22,61 +22,6 @@
 #include <cstring>
 #include <utility>
 
-namespace std {
-namespace chrono {
-namespace detail {
-
-template <typename From, typename To>
-struct posix_duration_cast;
-
-// chrono -> timespec caster
-template <typename Rep, typename Period>
-struct posix_duration_cast<std::chrono::duration<Rep, Period>,
-                           struct timespec> {
-  static struct timespec cast(std::chrono::duration<Rep, Period> const &d) {
-    struct timespec tv;
-
-    std::chrono::seconds const sec =
-        std::chrono::duration_cast<std::chrono::seconds>(d);
-
-    tv.tv_sec = sec.count();
-    tv.tv_nsec =
-        std::chrono::duration_cast<std::chrono::nanoseconds>(d - sec).count();
-
-    return tv;
-  }
-};
-
-// timespec -> chrono caster
-template <typename Rep, typename Period>
-struct posix_duration_cast<struct timespec,
-                           std::chrono::duration<Rep, Period>> {
-  static std::chrono::duration<Rep, Period> cast(struct timespec const &tv) {
-    return std::chrono::duration_cast<std::chrono::duration<Rep, Period>>(
-        std::chrono::seconds(tv.tv_sec) + std::chrono::nanoseconds(tv.tv_nsec));
-  }
-};
-
-}  // namespace detail
-
-// chrono -> timespec
-template <typename T, typename Rep, typename Period>
-auto duration_cast(std::chrono::duration<Rep, Period> const &d) ->
-    typename std::enable_if<std::is_same<T, struct timespec>::value,
-                            struct timespec>::type {
-  return detail::posix_duration_cast<std::chrono::duration<Rep, Period>,
-                                     timespec>::cast(d);
-}
-
-// timespec -> chrono
-template <typename Duration>
-Duration duration_cast(struct timespec const &tv) {
-  return detail::posix_duration_cast<struct timespec, Duration>::cast(tv);
-}
-
-}  // namespace chrono
-}  // namespace std
-
 namespace utils {
 
 template <typename Implementation>
diff --git a/libtransport/src/utils/epoll_event_reactor.cc b/libtransport/src/utils/epoll_event_reactor.cc
deleted file mode 100644
index 457727bbe..000000000
--- a/libtransport/src/utils/epoll_event_reactor.cc
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * 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 <glog/logging.h>
-#include <hicn/transport/utils/branch_prediction.h>
-#include <signal.h>
-#include <unistd.h>
-#include <utils/epoll_event_reactor.h>
-#include <utils/fd_deadline_timer.h>
-
-#include <iostream>
-
-namespace utils {
-
-EpollEventReactor::EpollEventReactor()
-    : epoll_fd_(epoll_create(20000)), run_event_loop_(true) {}
-
-EpollEventReactor::~EpollEventReactor() { close(epoll_fd_); }
-
-int EpollEventReactor::addFileDescriptor(int fd, uint32_t events) {
-  if (TRANSPORT_EXPECT_FALSE(fd < 0)) {
-    LOG(ERROR) << "invalid fd " << fd;
-    return -1;
-  }
-
-  struct epoll_event evt;
-  std::memset(&evt, 0, sizeof(evt));
-  evt.events = events;
-  evt.data.fd = fd;
-
-  if (TRANSPORT_EXPECT_FALSE(epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, fd, &evt) <
-                             0)) {
-    LOG(ERROR) << "epoll_ctl: " << strerror(errno) << " fd " << fd;
-    return -1;
-  }
-
-  return 0;
-}
-
-int EpollEventReactor::modFileDescriptor(int fd, uint32_t events) {
-  if (TRANSPORT_EXPECT_FALSE(fd < 0)) {
-    LOG(ERROR) << "invalid fd " << fd;
-    return -1;
-  }
-
-  struct epoll_event evt;
-  memset(&evt, 0, sizeof(evt));
-  evt.events = events;
-  evt.data.fd = fd;
-
-  if (TRANSPORT_EXPECT_FALSE(epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, fd, &evt) <
-                             0)) {
-    LOG(ERROR) << "epoll_ctl: " << strerror(errno) << " fd " << fd;
-    return -1;
-  }
-
-  return 0;
-}
-
-std::size_t EpollEventReactor::mapSize() { return event_callback_map_.size(); }
-
-int EpollEventReactor::delFileDescriptor(int fd) {
-  if (TRANSPORT_EXPECT_FALSE(fd < 0)) {
-    LOG(ERROR) << "invalid fd " << fd;
-    return -1;
-  }
-
-  struct epoll_event evt;
-  memset(&evt, 0, sizeof(evt));
-
-  if (TRANSPORT_EXPECT_FALSE(epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, fd, &evt) <
-                             0)) {
-    LOG(ERROR) << "epoll_ctl: " << strerror(errno) << " fd " << fd;
-    return -1;
-  }
-
-  utils::SpinLock::Acquire locked(event_callback_map_lock_);
-  event_callback_map_.erase(fd);
-
-  return 0;
-}
-
-void EpollEventReactor::runEventLoop(int timeout) {
-  Event evt[128];
-  int en = 0;
-  EventCallbackMap::iterator it;
-  EventCallback callback;
-
-  // evt.events = EPOLLIN | EPOLLOUT;
-  sigset_t sigset;
-  sigemptyset(&sigset);
-
-  while (run_event_loop_) {
-    memset(&evt, 0, sizeof(evt));
-    en = epoll_pwait(epoll_fd_, evt, 128, timeout, &sigset);
-
-    if (TRANSPORT_EXPECT_FALSE(en < 0)) {
-      LOG(ERROR) << "epoll_pwait: " << strerror(errno);
-      if (errno == EINTR) {
-        continue;
-      } else {
-        return;
-      }
-    }
-
-    for (int i = 0; i < en; i++) {
-      if (evt[i].data.fd > 0) {
-        {
-          utils::SpinLock::Acquire locked(event_callback_map_lock_);
-          it = event_callback_map_.find(evt[i].data.fd);
-        }
-
-        if (TRANSPORT_EXPECT_FALSE(it == event_callback_map_.end())) {
-          LOG(ERROR) << "unexpected event. fd " << evt[i].data.fd;
-        } else {
-          {
-            utils::SpinLock::Acquire locked(event_callback_map_lock_);
-            callback = event_callback_map_[evt[i].data.fd];
-          }
-
-          callback(evt[i]);
-
-          // In the callback the epoll event reactor could have been stopped,
-          // then we need to check whether the event loop is still running.
-          if (TRANSPORT_EXPECT_FALSE(!run_event_loop_)) {
-            return;
-          }
-        }
-      } else {
-        LOG(ERROR) << "unexpected event. fd " << evt[i].data.fd;
-      }
-    }
-  }
-}
-
-void EpollEventReactor::runOneEvent() {
-  Event evt;
-  int en = 0;
-  EventCallbackMap::iterator it;
-  EventCallback callback;
-
-  //  evt.events = EPOLLIN | EPOLLOUT;
-  sigset_t sigset;
-  sigemptyset(&sigset);
-
-  memset(&evt, 0, sizeof(evt));
-
-  en = epoll_pwait(epoll_fd_, &evt, 1, -1, &sigset);
-
-  if (TRANSPORT_EXPECT_FALSE(en < 0)) {
-    LOG(ERROR) << "epoll_pwait: " << strerror(errno);
-    return;
-  }
-
-  if (TRANSPORT_EXPECT_TRUE(evt.data.fd > 0)) {
-    {
-      utils::SpinLock::Acquire locked(event_callback_map_lock_);
-      it = event_callback_map_.find(evt.data.fd);
-    }
-
-    if (TRANSPORT_EXPECT_FALSE(it == event_callback_map_.end())) {
-      LOG(ERROR) << "unexpected event. fd " << evt.data.fd;
-    } else {
-      {
-        utils::SpinLock::Acquire locked(event_callback_map_lock_);
-        callback = event_callback_map_[evt.data.fd];
-      }
-
-      callback(evt);
-    }
-  } else {
-    LOG(ERROR) << "unexpected event. fd " << evt.data.fd;
-  }
-}
-
-void EpollEventReactor::stop() { run_event_loop_ = false; }
-
-}  // namespace utils
\ No newline at end of file
diff --git a/libtransport/src/utils/epoll_event_reactor.h b/libtransport/src/utils/epoll_event_reactor.h
index 9ebfca937..8e7681c20 100644
--- a/libtransport/src/utils/epoll_event_reactor.h
+++ b/libtransport/src/utils/epoll_event_reactor.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -15,6 +15,7 @@
 
 #pragma once
 
+#include <glog/logging.h>
 #include <hicn/transport/utils/spinlock.h>
 #include <sys/epoll.h>
 #include <utils/event_reactor.h>
@@ -35,9 +36,10 @@ typedef std::unordered_map<int, EventCallback> EventCallbackMap;
 
 class EpollEventReactor : public EventReactor {
  public:
-  explicit EpollEventReactor();
+  explicit EpollEventReactor()
+      : epoll_fd_(epoll_create(20000)), run_event_loop_(true) {}
 
-  ~EpollEventReactor();
+  ~EpollEventReactor() { close(epoll_fd_); }
 
   template <typename EventHandler>
   int addFileDescriptor(int fd, uint32_t events, EventHandler &&callback) {
@@ -56,20 +58,163 @@ class EpollEventReactor : public EventReactor {
     return ret;
   }
 
-  int delFileDescriptor(int fd);
+  int delFileDescriptor(int fd) {
+    if (TRANSPORT_EXPECT_FALSE(fd < 0)) {
+      LOG(ERROR) << "invalid fd " << fd;
+      return -1;
+    }
+
+    struct epoll_event evt;
+    memset(&evt, 0, sizeof(evt));
+
+    if (TRANSPORT_EXPECT_FALSE(epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, fd, &evt) <
+                               0)) {
+      return -1;
+    }
+
+    utils::SpinLock::Acquire locked(event_callback_map_lock_);
+    event_callback_map_.erase(fd);
+
+    return 0;
+  }
+
+  int modFileDescriptor(int fd, uint32_t events) {
+    if (TRANSPORT_EXPECT_FALSE(fd < 0)) {
+      LOG(ERROR) << "invalid fd " << fd;
+      return -1;
+    }
+
+    struct epoll_event evt;
+    memset(&evt, 0, sizeof(evt));
+    evt.events = events;
+    evt.data.fd = fd;
+
+    if (TRANSPORT_EXPECT_FALSE(epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, fd, &evt) <
+                               0)) {
+      LOG(ERROR) << "epoll_ctl: " << strerror(errno) << " fd " << fd;
+      return -1;
+    }
+
+    return 0;
+  }
+
+  void runEventLoop(int timeout = -1) override {
+    Event evt[128];
+    int en = 0;
+    EventCallbackMap::iterator it;
+    EventCallback callback;
+
+    // evt.events = EPOLLIN | EPOLLOUT;
+    sigset_t sigset;
+    sigemptyset(&sigset);
+
+    while (run_event_loop_) {
+      memset(&evt, 0, sizeof(evt));
+      en = epoll_pwait(epoll_fd_, evt, 128, timeout, &sigset);
+
+      if (TRANSPORT_EXPECT_FALSE(en < 0)) {
+        LOG(ERROR) << "epoll_pwait: " << strerror(errno);
+        if (errno == EINTR) {
+          continue;
+        } else {
+          return;
+        }
+      }
+
+      for (int i = 0; i < en; i++) {
+        if (evt[i].data.fd > 0) {
+          {
+            utils::SpinLock::Acquire locked(event_callback_map_lock_);
+            it = event_callback_map_.find(evt[i].data.fd);
+          }
+
+          if (TRANSPORT_EXPECT_FALSE(it == event_callback_map_.end())) {
+            LOG(ERROR) << "unexpected event. fd " << evt[i].data.fd;
+          } else {
+            {
+              utils::SpinLock::Acquire locked(event_callback_map_lock_);
+              callback = event_callback_map_[evt[i].data.fd];
+            }
+
+            callback(evt[i]);
+
+            // In the callback the epoll event reactor could have been stopped,
+            // then we need to check whether the event loop is still running.
+            if (TRANSPORT_EXPECT_FALSE(!run_event_loop_)) {
+              return;
+            }
+          }
+        } else {
+          LOG(ERROR) << "unexpected event. fd " << evt[i].data.fd;
+        }
+      }
+    }
+  }
+
+  void runOneEvent() override {
+    Event evt;
+    int en = 0;
+    EventCallbackMap::iterator it;
+    EventCallback callback;
 
-  int modFileDescriptor(int fd, uint32_t events);
+    //  evt.events = EPOLLIN | EPOLLOUT;
+    sigset_t sigset;
+    sigemptyset(&sigset);
 
-  void runEventLoop(int timeout = -1) override;
+    memset(&evt, 0, sizeof(evt));
 
-  void runOneEvent() override;
+    en = epoll_pwait(epoll_fd_, &evt, 1, -1, &sigset);
 
-  void stop() override;
+    if (TRANSPORT_EXPECT_FALSE(en < 0)) {
+      LOG(ERROR) << "epoll_pwait: " << strerror(errno);
+      return;
+    }
+
+    if (TRANSPORT_EXPECT_TRUE(evt.data.fd > 0)) {
+      {
+        utils::SpinLock::Acquire locked(event_callback_map_lock_);
+        it = event_callback_map_.find(evt.data.fd);
+      }
 
-  std::size_t mapSize();
+      if (TRANSPORT_EXPECT_FALSE(it == event_callback_map_.end())) {
+        LOG(ERROR) << "unexpected event. fd " << evt.data.fd;
+      } else {
+        {
+          utils::SpinLock::Acquire locked(event_callback_map_lock_);
+          callback = event_callback_map_[evt.data.fd];
+        }
+
+        callback(evt);
+      }
+    } else {
+      LOG(ERROR) << "unexpected event. fd " << evt.data.fd;
+    }
+  }
+
+  void stop() override { run_event_loop_ = false; }
+
+  std::size_t mapSize() { return event_callback_map_.size(); }
 
  private:
-  int addFileDescriptor(int fd, uint32_t events);
+  int addFileDescriptor(int fd, uint32_t events) {
+    if (TRANSPORT_EXPECT_FALSE(fd < 0)) {
+      LOG(ERROR) << "invalid fd " << fd;
+      return -1;
+    }
+
+    struct epoll_event evt;
+    std::memset(&evt, 0, sizeof(evt));
+    evt.events = events;
+    evt.data.fd = fd;
+
+    if (TRANSPORT_EXPECT_FALSE(epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, fd, &evt) <
+                               0)) {
+      LOG(ERROR) << "epoll_ctl: " << strerror(errno) << " fd " << fd;
+      return -1;
+    }
+
+    return 0;
+  }
 
   int epoll_fd_;
   std::atomic_bool run_event_loop_;
diff --git a/libtransport/src/utils/event_reactor.h b/libtransport/src/utils/event_reactor.h
index 4f8b58296..09af6f84c 100644
--- a/libtransport/src/utils/event_reactor.h
+++ b/libtransport/src/utils/event_reactor.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/utils/fd_deadline_timer.h b/libtransport/src/utils/fd_deadline_timer.h
index 22c13a763..e15cd4d2a 100644
--- a/libtransport/src/utils/fd_deadline_timer.h
+++ b/libtransport/src/utils/fd_deadline_timer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -16,6 +16,7 @@
 #pragma once
 
 #include <hicn/transport/errors/runtime_exception.h>
+#include <hicn/transport/utils/chrono_typedefs.h>
 #include <sys/timerfd.h>
 #include <unistd.h>
 #include <utils/deadline_timer.h>
@@ -37,6 +38,11 @@ class FdDeadlineTimer : public DeadlineTimer<FdDeadlineTimer> {
     }
   }
 
+  FdDeadlineTimer(const FdDeadlineTimer &other)
+      : reactor_(other.reactor_),
+        timer_fd_(other.timer_fd_),
+        flags_(other.flags_) {}
+
   ~FdDeadlineTimer() { close(timer_fd_); }
 
   template <typename WaitHandler>
diff --git a/libtransport/src/utils/log.cc b/libtransport/src/utils/log.cc
index 755d5bafa..44acf4595 100644
--- a/libtransport/src/utils/log.cc
+++ b/libtransport/src/utils/log.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -36,7 +36,7 @@ foreach_log_level
   static constexpr char log_config_section[] = "log";
 #define LOG_NAME                                  \
   "Libhicntransport-" HICNTRANSPORT_VERSION_MAJOR \
-  "." HICNTRANSPORT_VERSION_MINOR "." HICNTRANSPORT_VERSION_REVISION
+  "." HICNTRANSPORT_VERSION_MINOR "." HICNTRANSPORT_VERSION_PATCH
   static constexpr char log_name[] = LOG_NAME;
 
 #define foreach_log_config        \
diff --git a/libtransport/src/utils/max_filter.h b/libtransport/src/utils/max_filter.h
new file mode 100644
index 000000000..7a2c6aace
--- /dev/null
+++ b/libtransport/src/utils/max_filter.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.sudo make instamake install
+ */
+
+#pragma once
+
+#include <deque>
+#include <iostream>
+#include <set>
+#include <type_traits>
+#include <vector>
+
+namespace utils {
+
+template <typename T>
+class MaxFilter {
+ public:
+  MaxFilter(std::size_t size) : size_(size) {}
+
+  std::size_t size() { return by_arrival_.size(); }
+
+  template <typename R>
+  void pushBack(R&& value) {
+    if (by_arrival_.size() >= size_) {
+      by_order_.erase(by_arrival_.back());
+      by_arrival_.pop_back();
+    }
+
+    by_arrival_.push_front(by_order_.insert(std::forward<R>(value)));
+  }
+
+  void clear() {
+    by_arrival_.clear();
+    by_order_.clear();
+  }
+
+  const T& begin() { return *by_order_.crbegin(); }
+
+  const T& rBegin() { return *by_order_.rbegin(); }
+
+ private:
+  std::multiset<T> by_order_;
+  std::deque<typename std::multiset<T>::const_iterator> by_arrival_;
+  std::size_t size_;
+};
+
+}  // namespace utils
diff --git a/libtransport/src/utils/membuf.cc b/libtransport/src/utils/membuf.cc
index 73c45cf6d..952116bb7 100644
--- a/libtransport/src/utils/membuf.cc
+++ b/libtransport/src/utils/membuf.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Copyright 2013-present Facebook, Inc.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@
 #include <hicn/transport/portability/win_portability.h>
 #endif
 
+#include <glog/logging.h>
 #include <hicn/transport/utils/membuf.h>
 
 #include <cassert>
@@ -209,7 +210,7 @@ MemBuf::MemBuf(CopyBufferOp /* op */, const void* buf, std::size_t size,
     : MemBuf(CREATE, headroom + size + min_tailroom) {
   advance(headroom);
   if (size > 0) {
-    assert(buf != nullptr);
+    DCHECK(buf != nullptr);
     memcpy(writableData(), buf, size);
     append(size);
   }
@@ -369,8 +370,8 @@ MemBuf::MemBuf(InternalConstructor, uintptr_t flagsAndSharedInfo, uint8_t* buf,
       length_(length),
       capacity_(capacity),
       flags_and_shared_info_(flagsAndSharedInfo) {
-  assert(data >= buf);
-  assert(data + length <= buf + capacity);
+  DCHECK(data >= buf);
+  DCHECK(data + length <= buf + capacity);
 }
 
 MemBuf::~MemBuf() {
@@ -559,7 +560,7 @@ void MemBuf::unshareOneSlow() {
   // minimum capacity we also maintain at least the same amount of tailroom.
   std::size_t headlen = headroom();
   if (length_ > 0) {
-    assert(data_ != nullptr);
+    DCHECK(data_ != nullptr);
     memcpy(buf + headlen, data_, length_);
   }
 
@@ -576,7 +577,7 @@ void MemBuf::unshareOneSlow() {
 void MemBuf::unshareChained() {
   // unshareChained() should only be called if we are part of a chain of
   // multiple MemBufs.  The caller should have already verified this.
-  assert(isChained());
+  DCHECK(isChained());
 
   MemBuf* current = this;
   while (true) {
@@ -606,7 +607,7 @@ void MemBuf::markExternallyShared() {
 }
 
 void MemBuf::makeManagedChained() {
-  assert(isChained());
+  DCHECK(isChained());
 
   MemBuf* current = this;
   while (true) {
@@ -677,15 +678,15 @@ void MemBuf::coalesceAndReallocate(size_t new_headroom, size_t new_length,
   size_t remaining = new_length;
   do {
     if (current->length_ > 0) {
-      assert(current->length_ <= remaining);
-      assert(current->data_ != nullptr);
+      DCHECK(current->length_ <= remaining);
+      DCHECK(current->data_ != nullptr);
       remaining -= current->length_;
       memcpy(p, current->data_, current->length_);
       p += current->length_;
     }
     current = current->next_;
   } while (current != end);
-  assert(remaining == 0);
+  DCHECK(remaining == 0);
 
   // Point at the new buffer
   decrementRefcount();
@@ -799,7 +800,7 @@ void MemBuf::reserveSlow(std::size_t min_headroom, std::size_t min_tailroom) {
     new_allocated_capacity = goodExtBufferSize(new_capacity);
     new_buffer = static_cast<uint8_t*>(malloc(new_allocated_capacity));
     if (length_ > 0) {
-      assert(data_ != nullptr);
+      DCHECK(data_ != nullptr);
       memcpy(new_buffer + min_headroom, data_, length_);
     }
     if (sharedInfo()) {
diff --git a/libtransport/src/utils/memory_pool_allocator.h b/libtransport/src/utils/memory_pool_allocator.h
index a960b91bb..c2b34e7aa 100644
--- a/libtransport/src/utils/memory_pool_allocator.h
+++ b/libtransport/src/utils/memory_pool_allocator.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/utils/min_filter.h b/libtransport/src/utils/min_filter.h
index 092555ce0..4c7ae81f1 100644
--- a/libtransport/src/utils/min_filter.h
+++ b/libtransport/src/utils/min_filter.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/utils/stream_buffer.h b/libtransport/src/utils/stream_buffer.h
index adfb696f2..dde769a55 100644
--- a/libtransport/src/utils/stream_buffer.h
+++ b/libtransport/src/utils/stream_buffer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/utils/string_tokenizer.cc b/libtransport/src/utils/string_tokenizer.cc
index a280a3c43..cb0a4a3ad 100644
--- a/libtransport/src/utils/string_tokenizer.cc
+++ b/libtransport/src/utils/string_tokenizer.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/utils/suffix_strategy.h b/libtransport/src/utils/suffix_strategy.h
index ee016308e..96eaed662 100644
--- a/libtransport/src/utils/suffix_strategy.h
+++ b/libtransport/src/utils/suffix_strategy.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -15,72 +15,88 @@
 
 #pragma once
 
-#include <core/manifest_format.h>
+#include <hicn/transport/core/name.h>
+#include <hicn/transport/errors/runtime_exception.h>
 
 namespace utils {
 
-using transport::core::NextSegmentCalculationStrategy;
+/**
+ * INCREMENTAL: Manifests will be received inline with the data with no specific
+ * assumption regarding the manifest capacity. Consumers can send interests
+ * using a +1 heuristic.
+ *
+ * MANIFEST_CAPACITY_BASED: manifests with capacity N have a suffix multiple of
+ * N+1: 0, N+1, 2(N+1) etc. Contents have a suffix incremented by 1 except when
+ * it conflicts with a manifest: 1, 2, ..., N, N+2, N+3, ..., 2N+1, 2N+3
+ */
+enum class NextSuffixStrategy : uint8_t {
+  INCREMENTAL = 1,
+};
 
 class SuffixStrategy {
  public:
-  static constexpr uint32_t INVALID_SUFFIX =
-      std::numeric_limits<uint32_t>::max();
+  static constexpr uint32_t MAX_SUFFIX = std::numeric_limits<uint32_t>::max();
+  static constexpr uint8_t MAX_MANIFEST_CAPACITY =
+      std::numeric_limits<uint8_t>::max();
 
-  SuffixStrategy(NextSegmentCalculationStrategy strategy)
+  SuffixStrategy(NextSuffixStrategy strategy, uint32_t offset = 0,
+                 uint32_t manifest_capacity = MAX_MANIFEST_CAPACITY)
       : suffix_stragegy_(strategy),
+        next_suffix_(offset),
+        manifest_capacity_(manifest_capacity),
         total_count_(0),
-        final_suffix_(INVALID_SUFFIX) {}
+        final_suffix_(MAX_SUFFIX) {}
 
   virtual ~SuffixStrategy() = default;
 
-  virtual uint32_t checkNextSuffix() = 0;
-
+  virtual uint32_t checkNextSuffix() const = 0;
   virtual uint32_t getNextSuffix() = 0;
 
-  virtual uint32_t getFinalSuffix() { return final_suffix_; }
-
-  virtual void setFinalSuffix(std::uint32_t final_suffix) {
-    if (final_suffix != INVALID_SUFFIX) {
-      final_suffix_ = final_suffix;
-    }
-  }
-
-  virtual uint32_t checkNextManifestSuffix() = 0;
-
+  virtual uint32_t checkNextManifestSuffix() const = 0;
   virtual uint32_t getNextManifestSuffix() = 0;
 
-  virtual uint32_t checkNextContentSuffix() = 0;
-
+  virtual uint32_t checkNextContentSuffix() const = 0;
   virtual uint32_t getNextContentSuffix() = 0;
 
-  virtual void reset(uint32_t offset = 0) = 0;
+  virtual void reset(uint32_t offset = 0) {
+    next_suffix_ = offset;
+    total_count_ = 0;
+  }
 
-  virtual uint32_t getManifestCapacity() = 0;
+  virtual uint32_t getManifestCapacity() const { return manifest_capacity_; };
 
-  virtual void setManifestCapacity(uint32_t capacity) = 0;
+  virtual void setManifestCapacity(uint8_t capacity) {
+    manifest_capacity_ = capacity;
+  }
 
-  virtual uint32_t getTotalCount() { return total_count_; };
+  virtual uint32_t getFinalSuffix() const { return final_suffix_; }
 
-  NextSegmentCalculationStrategy getSuffixStrategy() {
-    return suffix_stragegy_;
+  virtual void setFinalSuffix(std::uint32_t final_suffix) {
+    if (final_suffix != MAX_SUFFIX) {
+      final_suffix_ = final_suffix;
+    }
   }
 
- protected:
-  inline void incrementTotalCount() { total_count_++; };
+  NextSuffixStrategy getSuffixStrategy() const { return suffix_stragegy_; }
+
+  virtual uint32_t getTotalCount() const { return total_count_; }
 
  protected:
-  NextSegmentCalculationStrategy suffix_stragegy_;
+  NextSuffixStrategy suffix_stragegy_;
+  std::uint32_t next_suffix_;
+  std::uint8_t manifest_capacity_;
   std::uint32_t total_count_;
   std::uint32_t final_suffix_;
+
+  inline void incrementTotalCount() { total_count_++; };
 };
 
 class IncrementalSuffixStrategy : public SuffixStrategy {
  public:
   IncrementalSuffixStrategy(std::uint32_t start_offset)
-      : SuffixStrategy(NextSegmentCalculationStrategy::INCREMENTAL),
-        next_suffix_(start_offset) {}
+      : SuffixStrategy(NextSuffixStrategy::INCREMENTAL, start_offset) {}
 
-  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextSuffix() override {
+  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextSuffix() const override {
     return next_suffix_;
   }
 
@@ -89,7 +105,8 @@ class IncrementalSuffixStrategy : public SuffixStrategy {
     return next_suffix_++;
   }
 
-  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextContentSuffix() override {
+  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextContentSuffix()
+      const override {
     return checkNextSuffix();
   }
 
@@ -97,7 +114,8 @@ class IncrementalSuffixStrategy : public SuffixStrategy {
     return getNextSuffix();
   }
 
-  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextManifestSuffix() override {
+  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextManifestSuffix()
+      const override {
     return checkNextSuffix();
   }
 
@@ -105,90 +123,20 @@ class IncrementalSuffixStrategy : public SuffixStrategy {
     return getNextSuffix();
   }
 
-  uint32_t getManifestCapacity() override {
-    throw errors::RuntimeException(
-        "No manifest capacity in IncrementalSuffixStrategy.");
-  }
-
-  void setManifestCapacity(uint32_t capacity) override {
-    throw errors::RuntimeException(
-        "No manifest capacity in IncrementalSuffixStrategy.");
-  }
-
   void reset(std::uint32_t offset = 0) override { next_suffix_ = offset; }
-
- protected:
-  std::uint32_t next_suffix_;
-};
-
-class CapacityBasedSuffixStrategy : public SuffixStrategy {
- public:
-  CapacityBasedSuffixStrategy(std::uint32_t start_offset,
-                              std::uint32_t manifest_capacity)
-      : SuffixStrategy(NextSegmentCalculationStrategy::INCREMENTAL),
-        next_suffix_(start_offset),
-        segments_in_manifest_(manifest_capacity),
-        current_manifest_iteration_(0) {}
-
-  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextSuffix() override {
-    return next_suffix_;
-  }
-
-  TRANSPORT_ALWAYS_INLINE std::uint32_t getNextSuffix() override {
-    incrementTotalCount();
-    return next_suffix_++;
-  }
-
-  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextContentSuffix() override {
-    return next_suffix_ % segments_in_manifest_ == 0 ? next_suffix_
-                                                     : (next_suffix_ + 1);
-  }
-
-  TRANSPORT_ALWAYS_INLINE std::uint32_t getNextContentSuffix() override {
-    incrementTotalCount();
-    return next_suffix_ % segments_in_manifest_ == 0 ? next_suffix_++
-                                                     : ++next_suffix_;
-  }
-
-  TRANSPORT_ALWAYS_INLINE std::uint32_t checkNextManifestSuffix() override {
-    return (current_manifest_iteration_ + 1) * (segments_in_manifest_ + 1);
-  }
-
-  TRANSPORT_ALWAYS_INLINE std::uint32_t getNextManifestSuffix() override {
-    incrementTotalCount();
-    return (current_manifest_iteration_++) * (segments_in_manifest_ + 1);
-  }
-
-  TRANSPORT_ALWAYS_INLINE uint32_t getManifestCapacity() override {
-    return segments_in_manifest_;
-  }
-
-  TRANSPORT_ALWAYS_INLINE void setManifestCapacity(uint32_t capacity) override {
-    segments_in_manifest_ = capacity;
-  }
-
-  void reset(std::uint32_t offset = 0) override { next_suffix_ = offset; }
-
- protected:
-  std::uint32_t next_suffix_;
-  std::uint32_t segments_in_manifest_;
-  std::uint32_t current_manifest_iteration_;
 };
 
 class SuffixStrategyFactory {
  public:
   static std::unique_ptr<SuffixStrategy> getSuffixStrategy(
-      NextSegmentCalculationStrategy strategy, uint32_t start_offset,
-      uint32_t manifest_capacity = 0) {
+      NextSuffixStrategy strategy, uint32_t start_offset = 0,
+      uint32_t manifest_capacity = SuffixStrategy::MAX_MANIFEST_CAPACITY) {
     switch (strategy) {
-      case NextSegmentCalculationStrategy::INCREMENTAL:
+      case NextSuffixStrategy::INCREMENTAL:
         return std::make_unique<IncrementalSuffixStrategy>(start_offset);
-      case NextSegmentCalculationStrategy::MANIFEST_CAPACITY_BASED:
-        return std::make_unique<CapacityBasedSuffixStrategy>(start_offset,
-                                                             manifest_capacity);
       default:
         throw errors::RuntimeException(
-            "No valid NextSegmentCalculationStrategy specified.");
+            "No valid NextSuffixStrategy specified.");
     }
   }
 };
diff --git a/libtransport/src/utils/test.h b/libtransport/src/utils/test.h
index e3dd619ac..b91c8cb1f 100644
--- a/libtransport/src/utils/test.h
+++ b/libtransport/src/utils/test.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/src/utils/uri.cc b/libtransport/src/utils/uri.cc
index 33eb8b45b..12b11641c 100644
--- a/libtransport/src/utils/uri.cc
+++ b/libtransport/src/utils/uri.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2019 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
diff --git a/libtransport/third-party/CMakeLists.txt b/libtransport/third-party/CMakeLists.txt
index 46a4c0f23..ad7b14ead 100644
--- a/libtransport/third-party/CMakeLists.txt
+++ b/libtransport/third-party/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,8 +11,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-include(FetchContent)
-
 set (THIRD_PARTY_INSTALL_PREFIX ${CMAKE_CURRENT_BINARY_DIR})
 
 option(ENABLE_RELY "Enable download/build of rely library" OFF)
@@ -20,21 +18,34 @@ option(ENABLE_RELY "Enable download/build of rely library" OFF)
 if (ENABLE_RELY)
   ##################################
   # Download librely
-    
-  if(DEFINED ENV{BITBUCKET_USERNAME} AND DEFINED ENV{BITBUCKET_PASSWORD})
-    set(GIT_REPO https://$ENV{BITBUCKET_USERNAME}:$ENV{BITBUCKET_PASSWORD}@bitbucket-eng-gpk1.cisco.com/bitbucket/scm/icn/rely.git)
+
+  if (INTERNAL_ENVIRONMENT)
+    include(SetRelyGitRepo)
+    SetRelyGitRepo()
   else()
-    set(GIT_REPO ssh://git@bitbucket-eng-gpk1.cisco.com:7999/icn/rely.git)
+    if(DEFINED ENV{GITHUB_USERNAME} AND DEFINED ENV{GITHUB_PASSWORD})
+      set(GIT_REPO https://$ENV{GITHUB_USERNAME}:$ENV{GITHUB_PASSWORD}@github.com/steinwurf/rely.git)
+    else()
+      set(GIT_REPO ssh://github.com/steinwurf/rely.git)
+    endif()
   endif()
 
   FetchContent_Declare(
     rely
     GIT_REPOSITORY ${GIT_REPO}
     GIT_TAG release/latest
+    GIT_SHALLOW
+    GIT_PROGRESS
+    EXCLUDE_FROM_ALL
   )
 
   set(ENABLE_PIC ON)
-  FetchContent_MakeAvailable(rely)
+  FetchContent_GetProperties(rely)
+  if(NOT rely_POPULATED)
+    pr("Download and build" "rely")
+    FetchContent_Populate(rely)
+    add_subdirectory(${rely_SOURCE_DIR} ${rely_BINARY_DIR} EXCLUDE_FROM_ALL)
+  endif()
 
   list(APPEND THIRD_PARTY_INCLUDE_DIRS
     ${rely_BINARY_DIR}
@@ -44,7 +55,7 @@ if (ENABLE_RELY)
   # Get rely libraries
   get_property(steinwurf_object_libraries GLOBAL
                PROPERTY steinwurf::object_libraries)
-  
+
   foreach(rely_library ${steinwurf_object_libraries})
     list(APPEND THIRD_PARTY_OBJECT_LIBRARIES
       $<TARGET_OBJECTS:${rely_library}>
@@ -60,9 +71,19 @@ FetchContent_Declare(
   glog
   URL https://github.com/google/glog/archive/refs/tags/v0.5.0.zip
   PATCH_COMMAND patch -p1 CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/glog.patch
+  EXCLUDE_FROM_ALL
 )
 
-FetchContent_MakeAvailable(glog)
+FetchContent_GetProperties(glog)
+if(NOT glog_POPULATED)
+  pr("Download and build" "glog")
+  FetchContent_Populate(glog)
+  option(WITH_GFLAGS OFF)
+  option(WITH_GTEST OFF)
+  option(WITH_UNWIND OFF)
+  option(BUILD_TESTING OFF)
+  add_subdirectory(${glog_SOURCE_DIR} ${glog_BINARY_DIR} EXCLUDE_FROM_ALL)
+endif()
 
 list(APPEND THIRD_PARTY_INCLUDE_DIRS
   ${glog_BINARY_DIR}
@@ -77,6 +98,42 @@ list(APPEND THIRD_PARTY_DEPENDENCIES
   glog
 )
 
+if(UNIX AND (NOT APPLE) AND (NOT ${CMAKE_SYSTEM_NAME} MATCHES Android))
+  ##############################################################
+  # Get memif version
+  ##############################################################
+  list(GET LIBMEMIF_DEFAULT_VERSION 0 MEMIF_VERSION)
+
+  FetchContent_Declare(
+    memif
+    GIT_REPOSITORY https://github.com/FDio/vpp
+    GIT_TAG v${MEMIF_VERSION}
+    GIT_SHALLOW
+    GIT_PROGRESS
+    PATCH_COMMAND git apply ${CMAKE_CURRENT_SOURCE_DIR}/memif.patch
+    EXCLUDE_FROM_ALL
+  )
+
+  FetchContent_GetProperties(memif)
+  if(NOT memif_POPULATED)
+    FetchContent_Populate(memif)
+    add_subdirectory(${memif_SOURCE_DIR}/extras/libmemif ${memif_BINARY_DIR} EXCLUDE_FROM_ALL)
+  endif()
+
+  list(APPEND THIRD_PARTY_INCLUDE_DIRS
+    ${memif_BINARY_DIR}
+    ${memif_SOURCE_DIR}/extras/libmemif/src
+  )
+
+  list(APPEND THIRD_PARTY_OBJECT_LIBRARIES
+    $<TARGET_OBJECTS:memif>
+  )
+
+  list(APPEND THIRD_PARTY_DEPENDENCIES
+    memif
+  )
+endif()
+
 set (THIRD_PARTY_LIBRARIES ${THIRD_PARTY_LIBRARIES} PARENT_SCOPE)
 set (THIRD_PARTY_OBJECT_LIBRARIES ${THIRD_PARTY_OBJECT_LIBRARIES} PARENT_SCOPE)
 set (THIRD_PARTY_INCLUDE_DIRS ${THIRD_PARTY_INCLUDE_DIRS} PARENT_SCOPE)
diff --git a/libtransport/third-party/CMakeLists.txt.orig b/libtransport/third-party/CMakeLists.txt.orig
deleted file mode 100644
index 84db8cb4c..000000000
--- a/libtransport/third-party/CMakeLists.txt.orig
+++ /dev/null
@@ -1,85 +0,0 @@
-# Copyright (c) 2021 Cisco and/or its affiliates.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at:
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-include(FetchContent)
-
-set (THIRD_PARTY_INSTALL_PREFIX ${CMAKE_CURRENT_BINARY_DIR})
-
-option(ENABLE_RELY "Enable download/build of rely library" OFF)
-
-if (ENABLE_RELY)
-  ##################################
-  # Download librely
-    
-  if(DEFINED ENV{BITBUCKET_USERNAME} AND DEFINED ENV{BITBUCKET_PASSWORD})
-    set(GIT_REPO https://$ENV{BITBUCKET_USERNAME}:$ENV{BITBUCKET_PASSWORD}@bitbucket-eng-gpk1.cisco.com/bitbucket/scm/icn/rely.git)
-  else()
-    set(GIT_REPO ssh://git@bitbucket-eng-gpk1.cisco.com:7999/icn/rely.git)
-  endif()
-
-  FetchContent_Declare(
-    rely
-    GIT_REPOSITORY ${GIT_REPO}
-    GIT_TAG release/latest
-    FETCHCONTENT_QUIET
-  )
-
-  set(ENABLE_PIC ON)
-  FetchContent_MakeAvailable(rely)
-
-  list(APPEND THIRD_PARTY_INCLUDE_DIRS
-    ${rely_BINARY_DIR}
-    ${rely_SOURCE_DIR}/src
-  )
-
-  # Get rely libraries
-  get_property(steinwurf_object_libraries GLOBAL
-               PROPERTY steinwurf::object_libraries)
-  
-  foreach(rely_library ${steinwurf_object_libraries})
-    list(APPEND THIRD_PARTY_OBJECT_LIBRARIES
-      $<TARGET_OBJECTS:${rely_library}>
-    )
-  endforeach()
-
-  list(APPEND THIRD_PARTY_DEPENDENCIES
-    rely
-  )
-endif()
-
-FetchContent_Declare(
-  glog
-  URL https://github.com/google/glog/archive/refs/tags/v0.5.0.zip
-  PATCH_COMMAND patch -p1 CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/glog.patch
-  FETCHCONTENT_QUIET
-)
-
-FetchContent_MakeAvailable(glog)
-
-list(APPEND THIRD_PARTY_INCLUDE_DIRS
-  ${glog_BINARY_DIR}
-  ${glog_SOURCE_DIR}/src
-)
-
-list(APPEND THIRD_PARTY_OBJECT_LIBRARIES
-  $<TARGET_OBJECTS:glog>
-)
-
-list(APPEND THIRD_PARTY_DEPENDENCIES
-  glog
-)
-
-set (THIRD_PARTY_LIBRARIES ${THIRD_PARTY_LIBRARIES} PARENT_SCOPE)
-set (THIRD_PARTY_OBJECT_LIBRARIES ${THIRD_PARTY_OBJECT_LIBRARIES} PARENT_SCOPE)
-set (THIRD_PARTY_INCLUDE_DIRS ${THIRD_PARTY_INCLUDE_DIRS} PARENT_SCOPE)
-set (THIRD_PARTY_DEPENDENCIES ${THIRD_PARTY_DEPENDENCIES} PARENT_SCOPE)
diff --git a/libtransport/third-party/CMakeLists.txt.rej b/libtransport/third-party/CMakeLists.txt.rej
deleted file mode 100644
index 4ebaf9061..000000000
--- a/libtransport/third-party/CMakeLists.txt.rej
+++ /dev/null
@@ -1,21 +0,0 @@
---- CMakeLists.txt
-+++ CMakeLists.txt
-@@ -41,9 +41,6 @@ if (NOT WITH_THREADS)
-   set (CMAKE_DISABLE_FIND_PACKAGE_Threads ON)
- endif (NOT WITH_THREADS)
- 
--set (CMAKE_C_VISIBILITY_PRESET hidden)
--set (CMAKE_CXX_VISIBILITY_PRESET hidden)
--set (CMAKE_VISIBILITY_INLINES_HIDDEN 1)
- list (APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
- 
- include (CheckCXXSourceCompiles)
-@@ -570,7 +567,7 @@ if (_glog_CMake_MODULES)
-   )
- endif (_glog_CMake_MODULES)
- 
--add_library (glog
-+add_library (glog OBJECT
-   ${GLOG_SRCS}
-   ${_glog_BINARY_CMake_MODULES}
- )
diff --git a/libtransport/third-party/glog.patch b/libtransport/third-party/glog.patch
index 9d6e46df0..4f4d440eb 100644
--- a/libtransport/third-party/glog.patch
+++ b/libtransport/third-party/glog.patch
@@ -20,4 +20,4 @@ index 62ebbcc..7d92fa5 100644
 +add_library (glog OBJECT
    ${GLOG_SRCS}
    ${_glog_BINARY_CMake_MODULES}
- )
+ )
\ No newline at end of file
diff --git a/libtransport/third-party/memif.patch b/libtransport/third-party/memif.patch
new file mode 100644
index 000000000..0a64513e3
--- /dev/null
+++ b/libtransport/third-party/memif.patch
@@ -0,0 +1,43 @@
+diff --git a/extras/libmemif/CMakeLists.txt b/extras/libmemif/CMakeLists.txt
+index b6b658c2d..28bb8c135 100644
+--- a/extras/libmemif/CMakeLists.txt
++++ b/extras/libmemif/CMakeLists.txt
+@@ -24,7 +24,7 @@ if (NOT CMAKE_BUILD_TYPE)
+   set(CMAKE_BUILD_TYPE "Release")
+ endif ()
+
+-set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g -DMEMIF_DBG -DICMP_DBG")
++set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g -DICMP_DBG")
+ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+ set(CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/lib)
+ set(CMAKE_INSTALL_MESSAGE NEVER)
+diff --git a/extras/libmemif/src/CMakeLists.txt b/extras/libmemif/src/CMakeLists.txt
+index ddb8a52f8..b52566e5c 100644
+--- a/extras/libmemif/src/CMakeLists.txt
++++ b/extras/libmemif/src/CMakeLists.txt
+@@ -32,22 +32,7 @@ list(APPEND MEMIF_SOURCES
+
+ include_directories(${HEADERS_DIR})
+
+-add_library(memif SHARED ${MEMIF_SOURCES})
+-target_link_libraries(memif ${CMAKE_THREAD_LIBS_INIT})
++add_library(memif OBJECT ${MEMIF_SOURCES})
++set_property(TARGET memif PROPERTY POSITION_INDEPENDENT_CODE ON)
+
+-find_library(LIB_BSD bsd)
+-if(LIB_BSD)
+-  add_compile_definitions(HAS_LIB_BSD)
+-  target_link_libraries(memif ${LIB_BSD})
+-endif()
+-
+-foreach(file ${MEMIF_HEADERS})
+-  get_filename_component(dir ${file} DIRECTORY)
+-     install(
+-	FILES ${file}
+-	DESTINATION include/${lib}/${dir}
+-	COMPONENT libmemif-dev
+-      )
+-endforeach()
+-
+-install(TARGETS memif DESTINATION lib COMPONENT libmemif)
++target_link_libraries(memif ${CMAKE_THREAD_LIBS_INIT})
diff --git a/scripts/build-packages.sh b/scripts/build-packages.sh
index bc386c398..d7684e400 100644
--- a/scripts/build-packages.sh
+++ b/scripts/build-packages.sh
@@ -28,21 +28,11 @@ function build_package() {
     echo "*******************************************************************"
 
     # Make the package
-    mkdir -p ${SCRIPT_PATH}/../build && pushd ${SCRIPT_PATH}/../build
-        rm -rf *
+    make -C ${SCRIPT_PATH}/.. INSTALL_PREFIX=/usr test package-release
 
-        cmake -G Ninja -DCMAKE_INSTALL_PREFIX=/usr    \
-                       -DBUILD_HICNPLUGIN=ON          \
-                       -DBUILD_LIBTRANSPORT=ON        \
-                       -DBUILD_APPS=ON                \
-                       -DBUILD_HICNLIGHT=ON           \
-                       -DBUILD_TELEMETRY=ON           \
-                       ${SCRIPT_PATH}/..
-
-        ninja -j8 package
-
-        find . -not -name '*.deb' -not -name '*.rpm' -print0 | xargs -0 rm -rf -- || true
-        rm *Unspecified* *Development* *development* || true
+    pushd ${SCRIPT_PATH}/../build-release-${ID}
+      find . -not -name '*.deb' -not -name '*.rpm' -print0 | xargs -0 rm -rf -- || true
+      rm *Unspecified* *Development* *development* || true
     popd
 
     echo "*******************************************************************"
@@ -57,30 +47,15 @@ build_sphinx() {
     echo "********************* STARTING DOC BUILD **************************"
     echo "*******************************************************************"
 
-    # Make the package
-    pip3 install -r ${SCRIPT_PATH}/../docs/etc/requirements.txt
-    pushd ${SCRIPT_PATH}/../docs
-    make html
-
-    popd
+    make doc
 
     echo "*******************************************************************"
     echo "*****************  BUILD COMPLETED SUCCESSFULLY *******************"
     echo "*******************************************************************"
 }
 
-build_doxygen() {
-    setup
-
-    mkdir -p ${SCRIPT_PATH}/../build-doxygen
-    pushd ${SCRIPT_PATH}/../build-doxygen
-    cmake -DBUILD_HICNPLUGIN=On -DBUILD_HICNLIGHT=OFF -DBUILD_LIBTRANSPORT=OFF -DBUILD_UTILS=OFF -DBUILD_APPS=OFF -DBUILD_CTRL=OFF ..
-    make doc
-    popd
-}
-
 function usage() {
-    echo "Usage: ${0} [sphinx|doxygen|packages]"
+    echo "Usage: ${0} [sphinx|packages]"
     exit 1
 }
 
@@ -92,9 +67,6 @@ case "${1}" in
   sphinx)
     build_sphinx
     ;;
-  doxygen)
-    build_doxygen
-    ;;
   packages)
     build_package
     ;;
diff --git a/scripts/checkstyle.sh b/scripts/checkstyle.sh
index ae775aca9..46cba4507 100644
--- a/scripts/checkstyle.sh
+++ b/scripts/checkstyle.sh
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,4 +11,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-exit 0
\ No newline at end of file
+exit 0
diff --git a/scripts/functions.sh b/scripts/functions.sh
index abb34fb7b..e416ee274 100644
--- a/scripts/functions.sh
+++ b/scripts/functions.sh
@@ -1,4 +1,4 @@
-# Copyright (c) 2020 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -14,121 +14,62 @@
 #!/bin/bash
 set -euxo pipefail
 
-APT_PATH=`which apt-get` || true
+APT_PATH=$(which apt-get) || true
 apt_get=${APT_PATH:-"/usr/local/bin/apt-get"}
 
 # Cmake executable
 CMAKE_INSTALL_DIR="/opt/cmake"
 export PATH=:${CMAKE_INSTALL_DIR}/bin:${PATH}
 
-PACKAGECLOUD_RELEASE_REPO_DEB="https://packagecloud.io/install/repositories/fdio/release/script.deb.sh"
-PACKAGECLOUD_RELEASE_REPO_RPM="https://packagecloud.io/install/repositories/fdio/release/script.rpm.sh"
-PACKAGECLOUD_HICN_REPO_DEB="https://packagecloud.io/install/repositories/fdio/hicn/script.deb.sh"
-PACKAGECLOUD_HICN_REPO_RPM="https://packagecloud.io/install/repositories/fdio/hicn/script.rpm.sh"
-
-VPP_GIT_REPO="https://github.com/FDio/vpp"
-VPP_BRANCH="stable/2005"
-
-    # Figure out what system we are running on
+# Figure out what system we are running on
 if [ -f /etc/os-release ]; then
-    . /etc/os-release
+  . /etc/os-release
 else
-    echo "ERROR: System configuration not recognized. Build failed"
-    exit 1
+  echo "ERROR: System configuration not recognized. Build failed"
+  exit 1
 fi
 
-VERSION_REGEX="s/v([0-9]+).([0-9]+)(.*)?-([0-9]+)-(g[0-9a-f]+)/\1.\2-release/g"
-VPP_VERSION_DEB=$(git describe --long --match "v*" | sed -E ${VERSION_REGEX})
-VPP_VERSION_RPM="${VPP_VERSION_DEB}.x86_64"
-
-DEPS_UBUNTU=("build-essential"
-             "doxygen"
-             "curl"
-             "cmake"
-             "libasio-dev"
-             "libconfig-dev"
-             "libconfig++-dev"
-             "libcurl4-openssl-dev"
-             "libevent-dev"
-             "libssl-dev"
-             "ninja-build"
-             "python3-ply")
-
-DEPS_UBUNTU_PKGCLOUD=("libparc-dev"
-                      "libmemif-dev"
-                      "libmemif"
-                      "vpp=${VPP_VERSION_DEB}"
-                      "vpp-dev=${VPP_VERSION_DEB}"
-                      "libvppinfra=${VPP_VERSION_DEB}"
-                      "libvppinfra-dev=${VPP_VERSION_DEB}"
-                      "vpp-plugin-core=${VPP_VERSION_DEB}"
-                      "libparc-dev")
-
 COLLECTD_SOURCE="https://github.com/collectd/collectd/releases/download/collectd-5.12.0/collectd-5.12.0.tar.bz2"
 
 function install_collectd_headers() {
-    curl -OL ${COLLECTD_SOURCE}
-    tar -xf collectd-5.12.0.tar.bz2
+  curl -OL ${COLLECTD_SOURCE}
+  tar -xf collectd-5.12.0.tar.bz2
 
-    pushd collectd-5.12.0
-        ./configure && make -j$(nproc)
-    popd
+  pushd collectd-5.12.0
+  ./configure && make -j$(nproc)
+  popd
 
-    export COLLECTD_HOME=${PWD}/collectd-5.12.0/src
+  export COLLECTD_HOME=${PWD}/collectd-5.12.0/src
 }
 
-function setup_fdio_repo() {
-    DISTRIB_ID=${ID}
-
-    if [ "${DISTRIB_ID}" == "ubuntu" ]; then
-        curl -s ${PACKAGECLOUD_RELEASE_REPO_DEB} | sudo bash
-        curl -s ${PACKAGECLOUD_HICN_REPO_DEB} | sudo bash
-    elif [ "${DISTRIB_ID}" == "centos" ]; then
-        curl -s ${PACKAGECLOUD_RELEASE_REPO_RPM} | sudo bash
-        curl -s ${PACKAGECLOUD_HICN_REPO_RPM} | sudo bash
-    else
-        echo "Distribution ${DISTRIB_ID} is not supported"
-        exit 1
-    fi
+# Call a function once
+function call_once() {
+  # OP_NAME is the name of the function
+  OP_NAME=${1}
+  # If function was already called return
+  [[ -f /tmp/${OP_NAME} ]] && return 0
+  # Otherwise call the function
+  ${@}
+  # And mark the function as called if no error occurred
+  echo ${OP_NAME} >/tmp/${OP_NAME}
 }
 
 # Install dependencies
 function install_deps() {
-    DISTRIB_ID=${ID}
-    echo ${DEPS_UBUNTU[@]} | xargs sudo ${apt_get} install -y --allow-unauthenticated --no-install-recommends
-}
-
-function install_pkgcloud_deps() {
-    DISTRIB_ID=${ID}
-    echo ${DEPS_UBUNTU_PKGCLOUD[@]} | xargs sudo ${apt_get} install -y --allow-unauthenticated --no-install-recommends
-}
-
-# Call a function once
-function call_once() {
-    # OP_NAME is the name of the function
-    OP_NAME=${1}
-    # If function was already called return
-    [[ -f /tmp/${OP_NAME} ]] && return 0
-    # Otherwise call the function
-    ${@}
-    # And mark the function as called if no error occurred
-    echo ${OP_NAME} > /tmp/${OP_NAME}
+  make -C ${SCRIPT_PATH}/.. deps
 }
 
 function setup() {
-    echo DISTRIBUTION: ${PRETTY_NAME}
-    # export variables depending on the platform we are running
-
-    call_once setup_fdio_repo
-    call_once install_deps
-    call_once install_pkgcloud_deps
-    call_once install_collectd_headers
+  echo DISTRIBUTION: ${PRETTY_NAME}
+  # export variables depending on the platform we are running
+  call_once install_deps
+  call_once install_collectd_headers
 }
 
 function setup_extras() {
-    echo DISTRIBUTION: ${PRETTY_NAME}
-    # export variables depending on the platform we are running
+  echo DISTRIBUTION: ${PRETTY_NAME}
+  # export variables depending on the platform we are running
 
-    call_once install_deps
-    call_once install_collectd_headers
+  call_once install_deps
+  call_once install_collectd_headers
 }
diff --git a/scripts/install-vpp.sh b/scripts/install-vpp.sh
new file mode 100644
index 000000000..a58e1bcad
--- /dev/null
+++ b/scripts/install-vpp.sh
@@ -0,0 +1,38 @@
+#!/bin/bash
+
+################################################################
+# Install defined VPP version
+################################################################
+
+if [[ -z ${VERSION_PATH} ]]; then
+  echo >&2 "No version path provided. Exit now."
+  exit 1
+fi
+
+# Prevent vpp to set sysctl
+export VPP_INSTALL_SKIP_SYSCTL=1
+VPP_VERSION=$(cat "${VERSION_PATH}" | grep VPP_DEFAULT_VERSION | cut -d ' ' -f 2 | tr -d '"' | grep -Po '\d\d.\d\d')
+
+curl -s https://packagecloud.io/install/repositories/fdio/${VPP_VERSION//./}/script.deb.sh | bash
+curl -L https://packagecloud.io/fdio/${VPP_VERSION//./}/gpgkey | apt-key add -
+sed -E -i 's/(deb.*)(\[.*\])(.*)/\1\3/g' /etc/apt/sources.list.d/fdio_${VPP_VERSION//./}.list
+
+# create apt pinning
+cat << EOF | tee /etc/apt/preferences.d/vpp-pin
+Package: vpp*
+Pin: release o=packagecloud.io/fdio/${VPP_VERSION//./}
+Pin-Priority: 1000
+
+Package: libvpp*
+Pin: release o=packagecloud.io/fdio/${VPP_VERSION//./}
+Pin-Priority: 1000
+EOF
+
+apt-get update
+
+apt-get install -y \
+  vpp-dev \
+  libvppinfra-dev \
+  vpp-plugin-core \
+  vpp \
+  libvppinfra
diff --git a/telemetry/CMakeLists.txt b/telemetry/CMakeLists.txt
index fbb929529..eff855646 100644
--- a/telemetry/CMakeLists.txt
+++ b/telemetry/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2020 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -14,8 +14,16 @@
 
 cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
 
-if ((CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR) OR 
+##############################################################
+# Packaging and versioning
+##############################################################
+include(${CMAKE_CURRENT_SOURCE_DIR}/../versions.cmake)
+
+
+##############################################################
+# Subdirectories
+##############################################################
+if ((CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR) OR
     (BUILD_HICNPLUGIN AND "${CMAKE_SYSTEM_NAME}" STREQUAL "Linux"))
     add_subdirectory(vpp-collectd)
 endif ()
-
diff --git a/telemetry/vpp-collectd/CMakeLists.txt b/telemetry/vpp-collectd/CMakeLists.txt
index 7afb3f432..54a1a4b76 100644
--- a/telemetry/vpp-collectd/CMakeLists.txt
+++ b/telemetry/vpp-collectd/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2020 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,18 +11,50 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-set(COLLECTD_PLUGINS hicn-collectd-plugins)
 project(hicn-collectd-plugins)
 
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/" "${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/Modules/")
 
-include(BuildMacros)
+##############################################################
+# CMake Modules
+##############################################################
+set(CMAKE_MODULE_PATH
+	${CMAKE_MODULE_PATH}
+	${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/Modules/)
+
+
+##############################################################
+# Dependencies
+##############################################################
+find_package(Vpp ${VPP_DEFAULT_VERSION} REQUIRED)
+find_package(Collectd ${COLLECTD_DEFAULT_VERSION} REQUIRED)
+
+
+##############################################################
+# Libs and bins names
+##############################################################
+set(COLLECTD_PLUGINS hicn-collectd-plugins)
+
+
+##############################################################
+# Packaging
+##############################################################
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/packaging.cmake)
+
+
+##############################################################
+# Compiler Options
+##############################################################
+set(COMPILER_OPTIONS
+  ${DEFAULT_COMPILER_OPTIONS}
+)
+
 
+##############################################################
+# Subdirectories
+##############################################################
 add_subdirectory(vpp)
 add_subdirectory(vpp-hicn)
 
-include(Packaging)
 if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-    include(Packager)
-    make_packages()
+	make_packages()
 endif()
diff --git a/telemetry/vpp-collectd/cmake/Modules/Packaging.cmake b/telemetry/vpp-collectd/cmake/packaging.cmake
index 72da05d02..49a617342 100644
--- a/telemetry/vpp-collectd/cmake/Modules/Packaging.cmake
+++ b/telemetry/vpp-collectd/cmake/packaging.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2020 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -21,11 +21,11 @@ set(${COLLECTD_PLUGINS}_DESCRIPTION
 )
 
 set(${COLLECTD_PLUGINS}_DEB_DEPENDENCIES
-  "collectd, hicn-plugin-dev"
+  "collectd, hicn-plugin-dev (= stable_version)"
   CACHE STRING "Dependencies for deb/rpm package."
 )
 
 set(${COLLECTD_PLUGINS}_RPM_DEPENDENCIES
-  "collectd, hicn-plugin-dev"
+  "collectd, hicn-plugin-dev = stable_version"
   CACHE STRING "Dependencies for deb/rpm package."
 )
\ No newline at end of file
diff --git a/telemetry/vpp-collectd/common/plugin.h b/telemetry/vpp-collectd/common/plugin.h
index 0e75adc9b..bbd69e003 100644
--- a/telemetry/vpp-collectd/common/plugin.h
+++ b/telemetry/vpp-collectd/common/plugin.h
@@ -43,13 +43,11 @@
 #define DS_TYPE_ABSOLUTE 3
 
 #define DS_TYPE_TO_STRING(t)                                                   \
-  (t == DS_TYPE_COUNTER)                                                       \
-      ? "counter"                                                              \
-      : (t == DS_TYPE_GAUGE)                                                   \
-            ? "gauge"                                                          \
-            : (t == DS_TYPE_DERIVE)                                            \
-                  ? "derive"                                                   \
-                  : (t == DS_TYPE_ABSOLUTE) ? "absolute" : "unknown"
+  (t == DS_TYPE_COUNTER)    ? "counter"                                        \
+  : (t == DS_TYPE_GAUGE)    ? "gauge"                                          \
+  : (t == DS_TYPE_DERIVE)   ? "derive"                                         \
+  : (t == DS_TYPE_ABSOLUTE) ? "absolute"                                       \
+                            : "unknown"
 
 #ifndef LOG_ERR
 #define LOG_ERR 3
diff --git a/telemetry/vpp-collectd/vpp-hicn/CMakeLists.txt b/telemetry/vpp-collectd/vpp-hicn/CMakeLists.txt
index 9db20be38..d55aede80 100644
--- a/telemetry/vpp-collectd/vpp-hicn/CMakeLists.txt
+++ b/telemetry/vpp-collectd/vpp-hicn/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2020 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,45 +11,56 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
-
-# Dependencies
-find_package(Collectd REQUIRED)
-find_package(Vpp REQUIRED)
-
+##############################################################
+# Check if building as subproject or as root project
+##############################################################
 if(${CMAKE_SOURCE_DIR}/vpp-collectd STREQUAL ${PROJECT_SOURCE_DIR})
   message (STATUS "not compiling in the same folder")
-  find_package(HicnPlugin REQUIRED)
-  find_package(VapiSafe REQUIRED)
+  find_package(HicnPlugin ${CURRENT_VERSION} REQUIRED)
+  find_package(Vapisafe ${CURRENT_VERSION} REQUIRED)
 else()
   message (STATUS "compiling in the same folder")
   list(APPEND DEPENDENCIES
-    hicn_plugin
+    ${HICNPLUGIN_SHARED}
   )
 endif()
 
+
+##############################################################
+# Sources
+##############################################################
 list(APPEND SOURCE_FILES
-     ${CMAKE_CURRENT_SOURCE_DIR}/vpp_hicn.c)
+  ${CMAKE_CURRENT_SOURCE_DIR}/vpp_hicn.c
+)
 
 list(APPEND INCLUDE_DIRS
-    ${COLLECTD_INCLUDE_DIRS}
-    ${HICNPLUGIN_INCLUDE_DIRS}
-    ${SAFE_VAPI_INCLUDE_DIRS}
-    ${VPP_INCLUDE_DIRS}
-    ${CMAKE_CURRENT_SOURCE_DIR}
-    "${CMAKE_CURRENT_SOURCE_DIR}/../common")
+  ${COLLECTD_INCLUDE_DIRS}
+  ${HICNPLUGIN_INCLUDE_DIRS}
+  ${SAFE_VAPI_INCLUDE_DIRS}
+  ${VPP_INCLUDE_DIRS}
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  "${CMAKE_CURRENT_SOURCE_DIR}/../common"
+)
 
+
+##############################################################
+# Libs
+##############################################################
 list(APPEND LIBRARIES
-    ${VPP_LIBRARY_VAPICLIENT}
-    ${SAFE_VAPI_LIBRARIES})
+  ${VPP_LIBRARY_VAPICLIENT}
+  ${SAFE_VAPI_LIBRARIES}
+)
+
 
+##############################################################
+# Build library
+##############################################################
 build_library(vpp_hicn
-    SHARED
-    SOURCES ${SOURCE_FILES}
-    LINK_LIBRARIES ${LIBRARIES}
-    INCLUDE_DIRS ${INCLUDE_DIRS}
-    INSTALL_FULL_PATH_DIR ${CMAKE_INSTALL_PREFIX}/lib/collectd
-    COMPONENT "${COLLECTD_PLUGINS}"
-    DEPENDS ${DEPENDENCIES}
-    EMPTY_PREFIX true
-  )
+  SOURCES ${SOURCE_FILES}
+  LINK_LIBRARIES ${LIBRARIES}
+  INCLUDE_DIRS ${INCLUDE_DIRS}
+  INSTALL_FULL_PATH_DIR ${CMAKE_INSTALL_PREFIX}/lib/collectd
+  COMPONENT "${COLLECTD_PLUGINS}"
+  DEPENDS ${DEPENDENCIES}
+  COMPILE_OPTIONS ${COMPILER_OPTIONS}
+)
diff --git a/telemetry/vpp-collectd/vpp-hicn/vpp_hicn.c b/telemetry/vpp-collectd/vpp-hicn/vpp_hicn.c
index b6bc3af49..a724c1124 100644
--- a/telemetry/vpp-collectd/vpp-hicn/vpp_hicn.c
+++ b/telemetry/vpp-collectd/vpp-hicn/vpp_hicn.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,8 +14,8 @@
  */
 
 /* Keep order as it is */
-#include <config.h>
 #include "common.h"
+#include <config.h>
 
 #define counter_t vpp_counter_t
 #include <vapi/hicn.api.vapi.h>
diff --git a/telemetry/vpp-collectd/vpp/CMakeLists.txt b/telemetry/vpp-collectd/vpp/CMakeLists.txt
index c36787355..41c19208a 100644
--- a/telemetry/vpp-collectd/vpp/CMakeLists.txt
+++ b/telemetry/vpp-collectd/vpp/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2020 Cisco and/or its affiliates.
+# Copyright (c) 2021-2022 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,29 +11,39 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Dependencies
-find_package(Vpp REQUIRED)
-find_package(Collectd REQUIRED)
-
+##############################################################
+# Sources
+##############################################################
 list(APPEND SOURCE_FILES
-     ${CMAKE_CURRENT_SOURCE_DIR}/vpp.c)
+  ${CMAKE_CURRENT_SOURCE_DIR}/vpp.c
+)
+
 
+##############################################################
+# Include directories
+##############################################################
 list(APPEND INCLUDE_DIRS
-    ${COLLECTD_INCLUDE_DIRS}
-    ${VPP_INCLUDE_DIRS}
-    ${CMAKE_CURRENT_SOURCE_DIR}
-    "${CMAKE_CURRENT_SOURCE_DIR}/../common")
+  ${COLLECTD_INCLUDE_DIRS}
+  ${VPP_INCLUDE_DIRS}
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  "${CMAKE_CURRENT_SOURCE_DIR}/../common"
+)
 
+
+##############################################################
+# Libraries
+##############################################################
 list(APPEND LIBRARIES
-    ${VPP_LIBRARY_VPPAPICLIENT}
-    ${VPP_LIBRARY_INFRA})
+  ${VPP_LIBRARY_VPPAPICLIENT}
+  ${VPP_LIBRARY_INFRA}
+)
+
 
-build_library(vpp
-    SHARED
-    SOURCES ${SOURCE_FILES}
-    LINK_LIBRARIES ${LIBRARIES}
-    INCLUDE_DIRS ${INCLUDE_DIRS}
-    INSTALL_FULL_PATH_DIR ${CMAKE_INSTALL_PREFIX}/lib/collectd
-    COMPONENT ${COLLECTD_PLUGINS}
-    EMPTY_PREFIX true
-  )
+build_module(vpp
+  SOURCES ${SOURCE_FILES}
+  LINK_LIBRARIES ${LIBRARIES}
+  INCLUDE_DIRS ${INCLUDE_DIRS}
+  INSTALL_FULL_PATH_DIR ${CMAKE_INSTALL_PREFIX}/lib/collectd
+  COMPONENT ${COLLECTD_PLUGINS}
+  COMPILE_OPTIONS ${COMPILER_OPTIONS}
+)
diff --git a/telemetry/vpp-collectd/vpp/vpp.c b/telemetry/vpp-collectd/vpp/vpp.c
index dcf956c93..85d0971d0 100644
--- a/telemetry/vpp-collectd/vpp/vpp.c
+++ b/telemetry/vpp-collectd/vpp/vpp.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Cisco and/or its affiliates.
+ * Copyright (c) 2021 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
@@ -14,8 +14,8 @@
  */
 
 /* Keep order as it is */
-#include <config.h>
 #include "common.h"
+#include <config.h>
 
 #define counter_t vpp_counter_t
 #include <vpp-api/client/stat_client.h>
diff --git a/tests/.env b/tests/.env
new file mode 100644
index 000000000..35c861bda
--- /dev/null
+++ b/tests/.env
@@ -0,0 +1,13 @@
+# Topologies
+TOPOLOGY_2_NODES=2-nodes
+
+# Container names
+TEST_LIGHT=hicn-light
+TEST_VPP_BRIDGE=vpp-bridge
+TEST_VPP_MEMIF=vpp-memif
+TEST_VPP_MEMIF_REPLICATION=vpp-memif-replication
+
+# names
+RTC_PRODUCER=b002::1
+RAAQM_PRODUCER=b002::2
+PING_PRODUCER=b002::3
diff --git a/tests/2-nodes-hicn-light.yml b/tests/2-nodes-hicn-light.yml
new file mode 100644
index 000000000..e62a6c705
--- /dev/null
+++ b/tests/2-nodes-hicn-light.yml
@@ -0,0 +1,65 @@
+version: "3"
+services:
+  client:
+    container_name: ${TEST_LIGHT}-client
+    command:
+      - |
+        if [ -d /workspace/build-dev ]; then
+          ninja -C /workspace/build-dev install
+        fi
+
+        sudo ip link add br0 type bridge
+        sudo ip addr add 192.168.1.1/24 dev br0
+        sudo ip link set eth0 master br0
+        sudo ip link set eth0 up
+        sudo ip link set br0 up
+        sudo ip route add 192.168.1.2 via 192.168.1.1 dev br0
+        tee -a /tmp/hicn-light.conf <<EOF
+        add listener udp local0 192.168.1.1 9199 br0
+        add connection udp conn0 192.168.1.2 9199 192.168.1.1 9199
+        add route conn0 b002::/64 1
+        EOF
+
+        rm -f /tmp/lite_client.log
+
+        sudo hicn-light-daemon \
+          --daemon \
+          --log-file /tmp/lite_client.log \
+          --config /tmp/hicn-light.conf --capacity 0
+
+        tail -f /dev/null
+
+  server:
+    container_name: ${TEST_LIGHT}-server
+    command:
+      - |
+        if [ -d /workspace/build-dev ]; then
+          ninja -C /workspace/build-dev install
+        fi
+
+        sudo ip link add br0 type bridge
+        sudo ip addr add 192.168.1.2/24 dev br0
+        sudo ip link set eth0 master br0
+        sudo ip link set eth0 up
+        sudo ip link set br0 up
+
+        tee -a /tmp/hicn-light.conf <<EOF
+        add listener udp local0 192.168.1.2 9199 br0
+        add connection udp conn0 192.168.1.1 9199 192.168.1.2 9199
+        add route conn0 b002::/64 1
+        EOF
+
+        rm -f /tmp/lite_server.log
+
+        sudo hicn-light-daemon \
+          --daemon \
+          --log-file /tmp/lite_server.log \
+          --config /tmp/hicn-light.conf --capacity 0
+
+        sleep 4
+
+        hiperf -z hicnlightng_module -D -S -R -B 4000kbps ${RTC_PRODUCER}/128
+        hiperf -z hicnlightng_module -D -S ${RAAQM_PRODUCER}/128
+        hicn-ping-server -z hicnlightng_module -d -s 0 -n ${PING_PRODUCER}/128
+
+        tail -f /dev/null
diff --git a/tests/2-nodes-vpp-bridge.yml b/tests/2-nodes-vpp-bridge.yml
new file mode 100644
index 000000000..d9426844f
--- /dev/null
+++ b/tests/2-nodes-vpp-bridge.yml
@@ -0,0 +1,107 @@
+version: "3"
+services:
+  client:
+    container_name: ${TEST_VPP_BRIDGE}-client
+    volumes:
+      - ..:/workspace
+    command:
+      - |
+        if [ -d /workspace/build-dev ]; then
+          ninja -C /workspace/build-dev install
+        fi
+
+        sudo ip link add br0 type bridge
+        sudo ip link set eth0 master br0
+        sudo ip link set eth0 up
+        sudo ip link set br0 up
+        sudo mkdir -p /var/log/vpp
+        sudo tee /etc/vpp/startup.conf <<EOF
+        cpu { main-core 1 }
+        plugins {
+            path /usr/lib/x86_64-linux-gnu/vpp_plugins:/usr/lib/vpp_plugins
+            plugin default { disable }
+            plugin acl_plugin.so { enable }
+            plugin nat_plugin.so { enable }
+            plugin dhcp_plugin.so { enable }
+            plugin dpdk_plugin.so { enable }
+            plugin dns_plugin.so { enable }
+            plugin ping_plugin.so { enable }
+            plugin memif_plugin.so { enable }
+            plugin nsim_plugin.so { enable }
+            plugin hicn_plugin.so { enable }
+        }
+
+        unix {
+            startup-config /etc/vpp/client-up.txt
+            cli-listen /run/vpp/cli.sock
+            log /var/log/vpp/vpp.log
+        }
+        EOF
+
+        sudo tee /etc/vpp/client-up.txt <<EOF
+        create tap id 0 host-bridge br0
+        set int state tap0 up
+        set int ip addr tap0 192.168.1.1/24
+        set int ip addr tap0 2001::1/64
+        ip route add b002::1/64 via 2001::2 tap0
+        EOF
+
+        sudo vpp -c /etc/vpp/startup.conf
+        sleep 5
+        sudo vppctl hicn enable b002::1/64
+
+        tail -f /dev/null
+
+  server:
+    container_name: ${TEST_VPP_BRIDGE}-server
+    volumes:
+      - ..:/workspace
+    command:
+      - |
+        if [ -d /workspace/build-dev ]; then
+          ninja -C /workspace/build-dev install
+        fi
+
+        sudo ip link add br0 type bridge
+        sudo ip link set eth0 master br0
+        sudo ip link set eth0 up
+        sudo ip link set br0 up
+        sudo mkdir -p /var/log/vpp
+        sudo tee /etc/vpp/startup.conf <<EOF
+        cpu { main-core 2 }
+        plugins {
+            path /usr/lib/x86_64-linux-gnu/vpp_plugins:/usr/lib/vpp_plugins
+            plugin default { disable }
+            plugin acl_plugin.so { enable }
+            plugin nat_plugin.so { enable }
+            plugin dhcp_plugin.so { enable }
+            plugin dpdk_plugin.so { enable }
+            plugin dns_plugin.so { enable }
+            plugin ping_plugin.so { enable }
+            plugin memif_plugin.so { enable }
+            plugin nsim_plugin.so { enable }
+            plugin hicn_plugin.so { enable }
+        }
+        unix {
+            startup-config /etc/vpp/server-up.txt
+            cli-listen /run/vpp/cli.sock
+            log /var/log/vpp/vpp.log
+        }
+        EOF
+        sudo tee /etc/vpp/server-up.txt <<EOF
+        create tap id 0 host-bridge br0
+        set int state tap0 up
+        set int ip addr tap0 192.168.1.12/24
+        set int ip addr tap0 2001::2/64
+        EOF
+
+        sudo vpp -c /etc/vpp/startup.conf
+        sleep 5
+
+        sudo hiperf -D -S -R -B 4000kbps -z memif_module ${RTC_PRODUCER}/128
+        sleep 1
+        sudo hiperf -D -S -z memif_module ${RAAQM_PRODUCER}/128
+        sleep 1
+        sudo hicn-ping-server -d -s 0 -n ${PING_PRODUCER}/128 -z memif_module
+
+        tail -f /dev/null
diff --git a/tests/2-nodes-vpp-memif-replication.yml b/tests/2-nodes-vpp-memif-replication.yml
new file mode 100644
index 000000000..37f028dac
--- /dev/null
+++ b/tests/2-nodes-vpp-memif-replication.yml
@@ -0,0 +1,143 @@
+version: "3"
+services:
+  vpp_client_memif:
+    build:
+      context: ..
+      dockerfile: ${DOCKERFILE}
+      args:
+        BASE_IMAGE: ${BASE_IMAGE}
+    stdin_open: true
+    tty: true
+    working_dir: /workspace
+    container_name: ${TEST_VPP_MEMIF_REPLICATION}-client
+    hostname: client
+    volumes:
+      - /tmp/memif:/memif
+      - ..:/workspace
+    entrypoint: [/bin/bash, -c]
+    command:
+      - |
+        if [ -d /workspace/build-dev ]; then
+          ninja -C /workspace/build-dev install
+        fi
+
+        sudo mkdir -p /var/log/vpp
+        sudo tee /etc/vpp/startup.conf <<EOF
+        cpu { main-core 1 }
+        buffers { buffers-per-numa 600000 }
+        plugins {
+            path /hicn-root/lib/vpp_plugins:/usr/lib/x86_64-linux-gnu/vpp_plugins:/usr/lib/vpp_plugins
+            plugin default { disable }
+            plugin acl_plugin.so { enable }
+            plugin nat_plugin.so { enable }
+            plugin dhcp_plugin.so { enable }
+            plugin dpdk_plugin.so { enable }
+            plugin dns_plugin.so { enable }
+            plugin ping_plugin.so { enable }
+            plugin memif_plugin.so { enable }
+            plugin nsim_plugin.so { enable }
+            plugin hicn_plugin.so { enable }
+        }
+
+        unix {
+            startup-config /etc/vpp/client-up.txt
+            cli-listen /run/vpp/cli.sock
+            log /var/log/vpp/vpp.log
+        }
+        EOF
+
+        sudo tee /etc/vpp/client-up.txt <<EOF
+        create memif socket id 1 filename /memif/memif1.sock
+        create interface memif id 0 socket-id 1 hw-addr aa:bb:cc:dd:ee:01 master
+        set int state memif1/0 up
+        set int ip addr memif1/0 192.168.1.1/24
+        set int ip addr memif1/0 2001::1/64
+        set ip neighbor memif1/0 2001::2 aa:bb:cc:dd:ee:02 static
+        ip route add b002::1/64 via 2001::2 memif1/0
+        create interface memif id 1 socket-id 1 hw-addr aa:bb:bb:bb:ee:01 master
+        set int state memif1/1 up
+        set int ip addr memif1/1 192.168.2.1/24
+        set int ip addr memif1/1 2002::1/64
+        set ip neighbor memif1/1 2002::2 aa:bb:bb:bb:ee:02 static
+        ip route add b002::1/64 via 2002::2 memif1/1
+        EOF
+
+        sudo rm /memif/memif1.sock
+
+        sudo vpp -c /etc/vpp/startup.conf
+        sleep 5
+
+        sudo vppctl hicn enable b002::1/64
+        sudo vppctl hicn strategy set 2 prefix b002::/64
+
+        tail -f /dev/null
+  vpp_server_memif:
+    build:
+      context: ..
+      dockerfile: ${DOCKERFILE}
+      args:
+        BASE_IMAGE: ${BASE_IMAGE}
+    stdin_open: true
+    tty: true
+    working_dir: /workspace
+    container_name: ${TEST_VPP_MEMIF_REPLICATION}-server
+    hostname: server
+    volumes:
+      - /tmp/memif:/memif
+      - ..:/workspace
+    entrypoint: [/bin/bash, -c]
+    command:
+      - |
+        if [ -d /workspace/build-dev ]; then
+          ninja -C /workspace/build-dev install
+        fi
+
+        sudo mkdir -p /var/log/vpp
+        sudo tee /etc/vpp/startup.conf <<EOF
+        cpu { main-core 2 }
+        buffers { buffers-per-numa 600000 }
+
+        plugins {
+            path /hicn-root/lib/vpp_plugins:/usr/lib/x86_64-linux-gnu/vpp_plugins:/usr/lib/vpp_plugins
+            plugin default { disable }
+            plugin acl_plugin.so { enable }
+            plugin nat_plugin.so { enable }
+            plugin dhcp_plugin.so { enable }
+            plugin dpdk_plugin.so { enable }
+            plugin dns_plugin.so { enable }
+            plugin ping_plugin.so { enable }
+            plugin memif_plugin.so { enable }
+            plugin nsim_plugin.so { enable }
+            plugin hicn_plugin.so { enable }
+        }
+        unix {
+            startup-config /etc/vpp/server-up.txt
+            cli-listen /run/vpp/cli.sock
+            log /var/log/vpp/vpp.log
+        }
+        EOF
+
+        sudo tee /etc/vpp/server-up.txt <<EOF
+        create memif socket id 1 filename /memif/memif1.sock
+        create interface memif id 0 socket-id 1 hw-addr aa:bb:cc:dd:ee:02 slave
+        set int state memif1/0 up
+        set int ip addr memif1/0 192.168.1.2/24
+        set int ip addr memif1/0 2001::2/64
+        set ip neighbor memif1/0 2001::1 aa:bb:cc:dd:ee:01 static
+        create interface memif id 1 socket-id 1 hw-addr aa:bb:bb:bb:ee:02 slave
+        set int state memif1/1 up
+        set int ip addr memif1/1 192.168.2.2/24
+        set int ip addr memif1/1 2002::2/64
+        set ip neighbor memif1/1 2002::1 aa:bb:bb:bb:ee:01 static
+        EOF
+
+        sudo vpp -c /etc/vpp/startup.conf
+        sleep 10
+
+        sudo hiperf -D -S -R -B 4000kbps -z memif_module ${RTC_PRODUCER}/128
+        sleep 5
+        sudo hiperf -D -S -z memif_module ${RAAQM_PRODUCER}/128
+        sleep 5
+        sudo hicn-ping-server -d -s 0 -n ${PING_PRODUCER}/128 -z memif_module
+
+        tail -f /dev/null
diff --git a/tests/2-nodes-vpp-memif.yml b/tests/2-nodes-vpp-memif.yml
new file mode 100644
index 000000000..034437dbc
--- /dev/null
+++ b/tests/2-nodes-vpp-memif.yml
@@ -0,0 +1,116 @@
+version: "3"
+services:
+  client:
+    container_name: ${TEST_VPP_MEMIF}-client
+    networks: []
+    volumes:
+      - /tmp/memif:/memif
+      - ..:/workspace
+    command:
+      - |
+        if [ -d /workspace/build-dev ]; then
+          ninja -C /workspace/build-dev install
+        fi
+
+        sudo mkdir -p /var/log/vpp
+        sudo tee /etc/vpp/startup.conf <<EOF
+        cpu { main-core 1 }
+        buffers { buffers-per-numa 600000 }
+        plugins {
+            path /usr/lib/x86_64-linux-gnu/vpp_plugins:/usr/lib/vpp_plugins
+            plugin default { disable }
+            plugin acl_plugin.so { enable }
+            plugin nat_plugin.so { enable }
+            plugin dhcp_plugin.so { enable }
+            plugin dpdk_plugin.so { enable }
+            plugin dns_plugin.so { enable }
+            plugin ping_plugin.so { enable }
+            plugin memif_plugin.so { enable }
+            plugin nsim_plugin.so { enable }
+            plugin hicn_plugin.so { enable }
+        }
+
+        unix {
+            startup-config /etc/vpp/client-up.txt
+            cli-listen /run/vpp/cli.sock
+            log /var/log/vpp/vpp.log
+        }
+        EOF
+
+        sudo tee /etc/vpp/client-up.txt <<EOF
+        comment { Creating memif }
+        create memif socket id 1 filename /memif/memif1.sock
+        create interface memif id 0 socket-id 1 mode ip master
+        set int state memif1/0 up
+        comment { Configuring memif }
+        set int ip addr memif1/0 192.168.1.1/24
+        set int ip addr memif1/0 2001::1/64
+        comment { Add route }
+        ip route add b002::1/64 via 2001::2 memif1/0
+        EOF
+
+        sudo rm /memif/memif1.sock
+        sudo vpp -c /etc/vpp/startup.conf
+        sleep 5
+
+        sudo vppctl hicn enable b002::1/64
+
+        tail -f /dev/null
+
+  server:
+    container_name: ${TEST_VPP_MEMIF}-server
+    networks: []
+    volumes:
+      - /tmp/memif:/memif
+      - ..:/workspace
+    command:
+      - |
+        if [ -d /workspace/build-dev ]; then
+          ninja -C /workspace/build-dev install
+        fi
+
+        sudo mkdir -p /var/log/vpp
+        sudo tee /etc/vpp/startup.conf <<EOF
+        cpu { main-core 2 }
+        buffers { buffers-per-numa 600000 }
+
+        plugins {
+            path /usr/lib/x86_64-linux-gnu/vpp_plugins:/usr/lib/vpp_plugins
+            plugin default { disable }
+            plugin acl_plugin.so { enable }
+            plugin nat_plugin.so { enable }
+            plugin dhcp_plugin.so { enable }
+            plugin dpdk_plugin.so { enable }
+            plugin dns_plugin.so { enable }
+            plugin ping_plugin.so { enable }
+            plugin memif_plugin.so { enable }
+            plugin nsim_plugin.so { enable }
+            plugin hicn_plugin.so { enable }
+        }
+        unix {
+            startup-config /etc/vpp/server-up.txt
+            cli-listen /run/vpp/cli.sock
+            log /var/log/vpp/vpp.log
+        }
+        EOF
+
+        sudo tee /etc/vpp/server-up.txt <<EOF
+        comment { Creating memif }
+        create memif socket id 1 filename /memif/memif1.sock
+        create interface memif id 0 socket-id 1 mode ip slave
+        set int state memif1/0 up
+        comment { Configuring memif }
+        set int ip addr memif1/0 192.168.1.2/24
+        set int ip addr memif1/0 2001::2/64
+        EOF
+
+        sudo vpp -c /etc/vpp/startup.conf
+        sleep 10
+
+        sudo hiperf -D -S -R -B 4000kbps -z memif_module ${RTC_PRODUCER}/128
+        sleep 5
+        sudo hiperf -D -S -z memif_module ${RAAQM_PRODUCER}/128
+        sleep 5
+        sudo hicn-ping-server -d -s 0 -n ${PING_PRODUCER}/128 -z memif_module
+
+        tail -f /dev/null
diff --git a/tests/2-nodes.yml b/tests/2-nodes.yml
new file mode 100644
index 000000000..ce87e5876
--- /dev/null
+++ b/tests/2-nodes.yml
@@ -0,0 +1,43 @@
+version: "3"
+services:
+  client:
+    build:
+      context: ..
+      dockerfile: ${DOCKERFILE}
+      args:
+        BASE_IMAGE: ${BASE_IMAGE}
+    privileged: true
+    stdin_open: true
+    hostname: client
+    tty: true
+    working_dir: /workspace
+    networks:
+      - kernel
+    volumes:
+      - ..:/workspace
+    entrypoint: [/bin/bash, -x, -c]
+    command:
+      - tail -f /dev/null
+
+  server:
+    build:
+      context: ..
+      dockerfile: ${DOCKERFILE}
+      args:
+        BASE_IMAGE: ${BASE_IMAGE}
+    privileged: true
+    stdin_open: true
+    hostname: server
+    tty: true
+    working_dir: /workspace
+    networks:
+      - kernel
+    volumes:
+      - ..:/workspace
+    entrypoint: [/bin/bash, -x, -c]
+    command:
+      - tail -f /dev/null
+
+networks:
+  kernel:
+    driver: bridge
diff --git a/tests/Dockerfile.ci b/tests/Dockerfile.ci
new file mode 100644
index 000000000..29f2e9dac
--- /dev/null
+++ b/tests/Dockerfile.ci
@@ -0,0 +1,5 @@
+ARG BASE_IMAGE
+
+FROM ${BASE_IMAGE}
+
+RUN sudo sed -i 's,secure_path="\(.*\)",secure_path="/hicn-root/bin:\1",' /etc/sudoers
diff --git a/tests/channel.sh b/tests/channel.sh
new file mode 100755
index 000000000..28a187e72
--- /dev/null
+++ b/tests/channel.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -e
+
+DEV=$2
+RATE=$3mbit
+DELAY=$4ms
+JITTER=$5ms
+LOSS=$6
+
+if [[ $1 -eq "set" ]]; then
+    tc qdisc add dev "$DEV" root handle 1:0 htb default 1
+    tc class add dev "$DEV" parent 1:0 classid 1:1 htb rate "$RATE"
+    tc qdisc add dev "$DEV" parent 1:1 handle 2:0 netem delay "$DELAY"
+    "$JITTER" loss random "$LOSS"
+    echo "Dev: $DEV, rate: $RATE, delay: $DELAY, jitter: $JITTER, loss: $LOSS%"
+elif [[ $1 -eq "change" ]]; then
+    tc qdisc change dev "$DEV" parent 1:1 handle 2:0 netem delay "$DELAY" "$JITTER" loss random "$LOSS"
+    echo "Dev: $DEV, rate: $RATE, delay: $DELAY, jitter: $JITTER, loss: $LOSS%"
+else
+    echo "set or change"
+fi
diff --git a/tests/config.sh b/tests/config.sh
new file mode 100755
index 000000000..bcd27e0b9
--- /dev/null
+++ b/tests/config.sh
@@ -0,0 +1,290 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+SCRIPT_PATH=$(
+  cd "$(dirname "${BASH_SOURCE}")"
+  pwd -P
+)
+
+# Import test configurations and names
+source ${SCRIPT_PATH}/.env
+
+set -a
+DOCKERFILE=${DOCKERFILE:-Dockerfile.dev}
+BASE_IMAGE=${BASE_IMAGE:-hicn}
+BUILD_SOFTWARE=${BUILD_SOFTWARE:-1}
+set +a
+
+HIPERF_CMD_RTC="hiperf -n 50 -C -H -R ${RTC_PRODUCER}"
+HIPERF_CMD_MEMIF_RTC="${HIPERF_CMD_RTC} -z memif_module"
+POSTPROCESS_COMMAND_RAAQM_RTC='tail -n +3 | \
+  tr -s " " |                               \
+  cut -f 4 -d " " |                         \
+  sort -n |                                 \
+  tail -n 40 |                              \
+  head -n 35 |                              \
+  awk "BEGIN {                              \
+    c=0;                                    \
+    s=0;                                    \
+  }{                                        \
+    a[n++]=\$1;                             \
+    s+=\$1;                                 \
+  } END {                                   \
+    print int(a[0]), int(a[n-1]), int(s/n)  \
+  }"'
+
+HIPERF_CMD_RAAQM="hiperf -n 50 -i 200 -C -H ${RAAQM_PRODUCER}"
+HIPERF_CMD_CBR="${HIPERF_CMD_RAAQM} -W 350 -M 0"
+HIPERF_CMD_MEMIF_RAAQM="${HIPERF_CMD_RAAQM} -z memif_module"
+HIPERF_CMD_MEMIF_CBR="${HIPERF_CMD_CBR} -z memif_module"
+
+PING_CMD="hicn-ping-client -m 50 -i 200000 -n ${PING_PRODUCER}"
+PING_CMD_MEMIF="${PING_CMD} -z memif_module"
+POSTPROCESS_COMMAND_PING='grep trip |       \
+  cut -f 4 -d " " |                         \
+  sort -n |                                 \
+  tail -n 40 |                              \
+  head -n 35 |                              \
+  awk "BEGIN {                              \
+    c=0;                                    \
+    s=0;                                    \
+  }{                                        \
+    a[n++]=\$1;                             \
+    s+=\$1;                                 \
+  } END {                                   \
+    print int(a[0]), int(a[n-1]), int(s/n)  \
+  }"'
+
+declare -a topologies
+declare -a configurations
+
+# Fill topology array using the same values in the .env file
+for topology in $(compgen -A variable | grep TOPOLOGY_); do
+  topologies+=("${!topology}")
+done
+
+# Fill configurations array using the same values in the .env file
+for test in $(compgen -A variable | grep TEST_); do
+  configurations+=("${!test}")
+done
+
+declare -A tests=(
+  ["hicn-light-rtc"]="${HIPERF_CMD_RTC} | tee >(>&2 cat) |  ${POSTPROCESS_COMMAND_RAAQM_RTC}"
+  ["vpp-bridge-rtc"]="${HIPERF_CMD_MEMIF_RTC} | tee >(>&2 cat) | ${POSTPROCESS_COMMAND_RAAQM_RTC}"
+  ["vpp-memif-rtc"]="${HIPERF_CMD_MEMIF_RTC} | tee >(>&2 cat) | ${POSTPROCESS_COMMAND_RAAQM_RTC}"
+  ["vpp-memif-replication-rtc"]="${HIPERF_CMD_MEMIF_RTC} | tee >(>&2 cat) | ${POSTPROCESS_COMMAND_RAAQM_RTC}"
+
+  ["hicn-light-requin"]="${HIPERF_CMD_RAAQM} | tee >(>&2 cat) | ${POSTPROCESS_COMMAND_RAAQM_RTC}"
+  ["vpp-bridge-requin"]="${HIPERF_CMD_MEMIF_RAAQM} | tee >(>&2 cat) | ${POSTPROCESS_COMMAND_RAAQM_RTC}"
+  ["vpp-memif-requin"]="${HIPERF_CMD_MEMIF_RAAQM} | tee >(>&2 cat) | ${POSTPROCESS_COMMAND_RAAQM_RTC}"
+  ["vpp-memif-replication-requin"]="${HIPERF_CMD_MEMIF_RAAQM} | tee >(>&2 cat) | ${POSTPROCESS_COMMAND_RAAQM_RTC}"
+
+  ["hicn-light-cbr"]="${HIPERF_CMD_CBR} | tee >(>&2 cat) |  ${POSTPROCESS_COMMAND_RAAQM_RTC}"
+  ["vpp-bridge-cbr"]="${HIPERF_CMD_MEMIF_CBR} | tee >(>&2 cat) | ${POSTPROCESS_COMMAND_RAAQM_RTC}"
+  ["vpp-memif-cbr"]="${HIPERF_CMD_MEMIF_CBR} | tee >(>&2 cat) | ${POSTPROCESS_COMMAND_RAAQM_RTC}"
+  ["vpp-memif-replication-cbr"]="${HIPERF_CMD_MEMIF_CBR} | tee >(>&2 cat) | ${POSTPROCESS_COMMAND_RAAQM_RTC}"
+
+  ["hicn-light-latency"]="${PING_CMD} | tee >(>&2 cat) |  ${POSTPROCESS_COMMAND_PING}"
+  ["vpp-bridge-latency"]="${PING_CMD_MEMIF} | tee >(>&2 cat) | ${POSTPROCESS_COMMAND_PING}"
+  ["vpp-memif-latency"]="${PING_CMD_MEMIF} | tee >(>&2 cat) | ${POSTPROCESS_COMMAND_PING}"
+  ["vpp-memif-replication-latency"]="${PING_CMD_MEMIF} | tee >(>&2 cat) | ${POSTPROCESS_COMMAND_PING}"
+)
+
+declare -A link_model=(
+  ["500-0-0-0"]="500 0 0 0"
+  ["500-1-0-0"]="500 1 0 0"
+  ["500-5-0-0"]="500 5 0 0"
+  ["500-200-0-0"]="500 200 0 0"
+  ["100-1-0-0"]="100 1 0 0"
+  ["100-10-0-0"]="100 10 0 0"
+  ["100-15-0-0"]="100 15 0 0"
+  ["200-5-0-0"]="200 5 0 0"
+  ["300-5-0-0"]="300 5 0 0"
+  ["400-5-0-0"]="400 5 0 0"
+  ["1000-1-0-0"]="1000 1 0 0"
+  ["10-50-1-10"]="10 50 1 10"
+)
+
+function topology_exists() {
+  [[ "${topologies[*]}" =~ ${1} ]] && return 0 || return 1
+}
+
+function test_exists() {
+  [[ "${!tests[*]}" =~ ${1} ]] && return 0 || return 1
+}
+
+function conf_exists() {
+  [[ "${configurations[*]}" =~ ${1} ]] && return 0 || return 1
+}
+
+
+# test-name client/server link-model
+function setchannel() {
+  if ! conf_exists "${1}"; then
+    error "Error: topology does not exist."
+  fi
+
+  if ! test_exists "${1}"; then
+    error "Error: test does not exist."
+  fi
+  docker exec "${1}-${2}" bash -c "/workspace/tests/config.sh link set br0\
+                                                          ${link_model[${3}]}"
+}
+# test-name client/server link-model
+function changechannel() {
+  if ! conf_exists "${1}"; then
+    error "Error: topology does not exist."
+  fi
+
+  if ! test_exists "${1}"; then
+    error "Error: test does not exist."
+  fi
+  docker exec "${1}-${2}" bash -c "/workspace/tests/config.sh link change br0\
+                                                          ${link_model[${3}]}"
+}
+
+# channel set/change dev rate delay jitter lossrate
+function channel() {
+  DEV=${2}
+  RATE=${3}mbit
+  DELAY=${4}ms
+  JITTER=${5}ms
+  LOSS=${6}
+  if [[ $1 == set ]]; then
+    sudo tc qdisc add dev "${DEV}" root handle 1:0 htb default 1
+    sudo tc class add dev "${DEV}" parent 1:0 classid 1:1 htb rate "$RATE"
+    sudo tc qdisc add dev "${DEV}" parent 1:1 handle 2:0 netem delay "${DELAY}" \
+      "${JITTER}" loss random "${LOSS}"
+    echo "Dev: ${DEV}, rate: ${RATE}, delay: ${DELAY}, jitter: ${JITTER}, loss: ${LOSS}%"
+  elif [[ ${1} == change ]]; then
+    sudo tc qdisc change dev "$DEV" parent 1:1 handle 2:0 netem delay "$DELAY" \
+      "${JITTER}" loss random "${LOSS}"
+    echo "Dev: ${DEV}, rate: ${RATE}, delay: ${DELAY}, jitter: ${JITTER}, loss: ${LOSS}%"
+  else
+    sudo tc qdisc del dev "${DEV}" root
+    echo "set or change"
+  fi
+}
+function error() {
+  echo >&2 "${@}"
+  return 1
+}
+
+function build() {
+  docker-compose -f build.yml build
+  docker-compose -f build.yml up --force-recreate --remove-orphans >/dev/null
+}
+
+function setup() {
+  topology=${1}
+  conf=${2}
+
+  if ! topology_exists "${topology}"; then
+    error "Error: topology does not exist."
+  fi
+
+  if ! conf_exists "${conf}"; then
+    error "Error: topology does not exist."
+  fi
+
+  docker-compose -f "${topology}".yml -f "${topology}-${conf}".yml build
+  docker-compose -f "${topology}".yml -f "${topology}-${conf}".yml up --remove-orphans --force-recreate -d
+
+  sleep 10
+}
+
+function start() {
+  conf=${1}
+  test=${2}
+
+  if ! conf_exists "${conf}"; then
+    error "Error: configuration does not exist."
+  fi
+
+  TESTNAME="${conf}-${test}"
+
+  if ! test_exists "${TESTNAME}"; then
+    error "Error: test does not exist."
+  fi
+
+  docker exec "${1}"-client bash -c "/workspace/tests/config.sh runtest ${tests[${TESTNAME}]}"
+}
+
+function stop() {
+  topology="${1}"
+  conf="${2}"
+
+  if ! topology_exists "${topology}"; then
+    error "Error: topology does not exist."
+  fi
+
+  if ! conf_exists "${conf}"; then
+    error "Error: tect configuration does not exist."
+  fi
+
+  LOG_FILE="${SCRIPT_PATH}/${topology}-${conf}.log"
+  rm -f "${LOG_FILE}"
+  docker-compose -f "${topology}".yml -f "${topology}-${conf}".yml down || true
+}
+
+function stopall() {
+  for topology in "${topologies[@]}"; do
+    for conf in "${configurations[@]}"; do
+      stop "${topology}" "${conf}"
+    done
+  done
+}
+
+function runtest() {
+  echo "${@}" | sudo -i
+}
+
+while (("${#}")); do
+  case "$1" in
+  'build')
+    build
+    shift
+    ;;
+  'link')
+    shift
+    channel "$@"
+    shift 6
+    ;;
+  'setchannel')
+    shift
+    setchannel "$@"
+    shift 4
+    ;;
+  'changechannel')
+    shift
+    changechannel "$@"
+    shift 4
+    ;;
+  'setup')
+    setup "${2}" "${3}"
+    shift 3
+    ;;
+  'start')
+    start "${2}" "${3}"
+    shift 3
+    ;;
+  'stop')
+    stop "${2}" "${3}"
+    shift 3
+    ;;
+  'stopall')
+    stopall
+    shift
+    ;;
+  'runtest')
+    runtest "${@:2}"
+    break
+    ;;
+  *)
+    break
+    ;;
+  esac
+done
+
+exit 0
diff --git a/tests/forwarder.robot b/tests/forwarder.robot
new file mode 100644
index 000000000..60345dbb0
--- /dev/null
+++ b/tests/forwarder.robot
@@ -0,0 +1,45 @@
+*** Settings ***
+Library                 Process
+Test Template           Run Test
+Test Setup              Setup
+Test Teardown           Teardown
+Test Timeout            5 seconds
+
+*** Variables ***
+${cmd}                  bash test_forwarder.sh
+
+*** Test Cases ***
+# Commands
+Add listener                        test_add_listener
+Remove listener                     test_remove_listener
+Remove non-existing listener        test_remove_non_existing_listener
+Add duplicated listener             test_add_duplicated_listener
+List listeners                      test_list_listeners
+Commands from config file           test_commands_from_config
+
+# Ping
+Ping one packet                     test_ping_one_packet
+Ping two packets                    test_ping_two_packets
+Ping using CS                       test_ping_using_cs
+Ping using CS different order       test_ping_using_cs_different_order
+Ping timeout                        test_ping_timeout
+Ping aggregation                    test_ping_aggregation
+Ping with CS store disabled         test_ping_with_cs_store_disabled
+Ping with CS serve disabled         test_ping_with_cs_serve_disabled
+Ping with eviction                  test_ping_with_eviction
+Ping with zero data lifetime        test_ping_with_zero_data_lifetime
+
+*** Keywords ***
+Setup
+  ${result}=  Run Process  ${cmd} set_up  shell=True
+  Log Many  stdout: ${result.stdout}  stderr: ${result.stderr}
+
+Teardown
+  ${result}=  Run Process  ${cmd} tear_down  shell=True
+  Log Many  stdout: ${result.stdout}  stderr: ${result.stderr}
+
+Run Test
+  [Arguments]  ${test_name}
+  ${result}=  Run Process  ${cmd} ${test_name}  shell=True
+  Log Many  stdout: ${result.stdout}  stderr: ${result.stderr}
+  Should Be Equal As Integers  ${result.rc}  0
\ No newline at end of file
diff --git a/tests/functional-tests/2-nodes-hicn-light.robot b/tests/functional-tests/2-nodes-hicn-light.robot
new file mode 100644
index 000000000..9aa5923a0
--- /dev/null
+++ b/tests/functional-tests/2-nodes-hicn-light.robot
@@ -0,0 +1,24 @@
+*** Settings ***
+Resource          resources/libraries/robot/runtest.robot
+Resource          resources/libraries/robot/common.robot
+Suite Setup       Run Keywords
+...               Build Topology                             2-nodes    hicn-light    AND
+...               Check Environment
+Suite Teardown    Run Keywords
+...               Destroy Topology
+Resource          resources/libraries/robot/runtest.robot
+
+*** Test Cases ***
+
+Throughput Testing Raaqm Mobile
+    Run Throughput Test Raaqm    hicn-light    200    500    400
+
+Throughput Testing CBR Mobile
+    Run Throughput Test CBR    hicn-light    200    500    400
+
+RTC Testing Mobile
+    Run RTC Test    hicn-light    4    4    4
+
+Latency Testing Mobile
+    Set Link            hicn-light    500     1       0       0
+    Run Latency Test    hicn-light    3000    3000    3000
diff --git a/tests/functional-tests/2-nodes-vpp-bridge.robot b/tests/functional-tests/2-nodes-vpp-bridge.robot
new file mode 100644
index 000000000..83c8818ab
--- /dev/null
+++ b/tests/functional-tests/2-nodes-vpp-bridge.robot
@@ -0,0 +1,24 @@
+*** Settings ***
+Resource          resources/libraries/robot/runtest.robot
+Resource          resources/libraries/robot/common.robot
+Suite Setup       Run Keywords
+...               Build Topology                             2-nodes    vpp-bridge    AND
+...               Check Environment
+Suite Teardown    Run Keywords
+...               Destroy Topology
+Resource          resources/libraries/robot/runtest.robot
+
+*** Test Cases ***
+
+Throughput Testing Raaqm Server VPP bridge
+    Run Throughput Test Raaqm    vpp-bridge    500    500    500
+
+Throughput Testing CBR Server VPP bridge
+    Run Throughput Test CBR    vpp-bridge    1000    1300    1200
+
+RTC Testing Server VPP bridge
+    Run RTC Test    vpp-bridge    4    4    4
+
+Latency Testing Server VPP bridge
+    Set Link            hicn-light    500     1       0       0
+    Run Latency Test    vpp-bridge    3000    3000    3000
diff --git a/tests/functional-tests/2-nodes-vpp-memif-replication.robot b/tests/functional-tests/2-nodes-vpp-memif-replication.robot
new file mode 100644
index 000000000..8c13f4fb9
--- /dev/null
+++ b/tests/functional-tests/2-nodes-vpp-memif-replication.robot
@@ -0,0 +1,23 @@
+*** Settings ***
+Resource          resources/libraries/robot/runtest.robot
+Resource          resources/libraries/robot/common.robot
+Suite Setup       Run Keywords
+...               Build Topology                             2-nodes    vpp-memif-replication    AND
+...               Check Environment
+Suite Teardown    Run Keywords
+...               Destroy Topology
+Resource          resources/libraries/robot/runtest.robot
+
+*** Test Cases ***
+
+Throughput Testing Raaqm Server VPP memif replication
+    Run Throughput Test Raaqm     vpp-memif-replication    500    500    500
+
+Throughput Testing CBR Server VPP memif
+    Run Throughput Test CBR     vpp-memif-replication    2000    2000    2000
+
+RTC Testing Server VPP memif replication
+    Run RTC Test     vpp-memif-replication    4    4    4
+
+Latency Testing Server VPP memif replication
+    Run Latency Test     vpp-memif-replication    3000    3000    3000
diff --git a/tests/functional-tests/2-nodes-vpp-memif.robot b/tests/functional-tests/2-nodes-vpp-memif.robot
new file mode 100644
index 000000000..1a69da787
--- /dev/null
+++ b/tests/functional-tests/2-nodes-vpp-memif.robot
@@ -0,0 +1,23 @@
+*** Settings ***
+Resource          resources/libraries/robot/runtest.robot
+Resource          resources/libraries/robot/common.robot
+Suite Setup       Run Keywords
+...               Build Topology                             2-nodes    vpp-memif    AND
+...               Check Environment
+Suite Teardown    Run Keywords
+...               Destroy Topology
+Resource          resources/libraries/robot/runtest.robot
+
+*** Test Cases ***
+
+Throughput Testing Raaqm Server VPP memif
+    Run Throughput Test Raaqm    vpp-memif    500    500    500
+
+Throughput Testing CBR Server VPP memif
+    Run Throughput Test CBR    vpp-memif    2000    2000    2000
+
+RTC Testing Server VPP memif
+    Run RTC Test    vpp-memif    4    4    4
+
+Latency Testing Server VPP memif
+    Run Latency Test    vpp-memif    3000    3000    3000
diff --git a/tests/resources/libraries/robot/common.robot b/tests/resources/libraries/robot/common.robot
new file mode 100644
index 000000000..c1e3f20a4
--- /dev/null
+++ b/tests/resources/libraries/robot/common.robot
@@ -0,0 +1,23 @@
+*** Settings ***
+Library    OperatingSystem
+Library    Process
+Library    String
+
+*** Variables ***
+
+*** Keywords ***
+
+Build Topology
+    [Arguments]          ${TEST_TOPOLOGY}=${NONE}                                    ${TEST_CONFIGURATION}=${NONE}
+    Log to console       Building topology ${TEST_TOPOLOGY} ${TEST_CONFIGURATION}
+    ${result_setup} =    Run Process                                                 ${EXECDIR}/config.sh              build    setup    ${TEST_TOPOLOGY}    ${TEST_CONFIGURATION}
+    Log to console       Done
+    Log Many             stdout: ${result_setup.stdout}                              stderr: ${result_setup.stderr}
+
+Check Environment
+    ${result} =    Run Process                 docker                      ps
+    Log Many       stdout: ${result.stdout}    stderr: ${result.stderr}
+
+Destroy Topology
+    ${result_teardown} =    Run Process                          ${EXECDIR}/config.sh                 stopall
+    Log Many                stdout: ${result_teardown.stdout}    stderr: ${result_teardown.stderr}
diff --git a/tests/resources/libraries/robot/runtest.robot b/tests/resources/libraries/robot/runtest.robot
new file mode 100644
index 000000000..d5201d765
--- /dev/null
+++ b/tests/resources/libraries/robot/runtest.robot
@@ -0,0 +1,92 @@
+*** Settings ***
+Library    OperatingSystem
+Library    Process
+Library    String
+
+*** Variables ***
+
+*** Keywords ***
+
+Infra ${VALUE}
+    Run Process    ${EXECDIR}/config.sh    ${VALUE}
+
+Run Test
+    [Arguments]         ${TEST_SETUP}=${NONE}                    ${TESTID}=${NONE}                                                  ${EXPECTED_MIN}=${NONE}    ${EXPECTED_MAX}=${NONE}    ${EXPECTED_AVG}=${NONE}
+    ${result_test} =    Run Process                              ${EXECDIR}/config.sh                                               start                      ${TEST_SETUP}              ${TESTID}                  stdout=${TEMPDIR}/stdout.txt    stderr=${TEMPDIR}/stderr.txt
+    Log Many            stdout: ${result_test.stdout}            stderr: ${result_test.stderr}
+    @{min_max_avg} =    Split String                             ${result_test.stdout.strip()}
+    Log To Console      Min Max Average Array: @{min_max_avg}
+    IF                  '${TESTID}' == 'rtc'
+    Should Be True      ${min_max_avg}[0] == ${EXPECTED_MIN}     msg="Min does not match (${min_max_avg}[0] != ${EXPECTED_MIN})"
+    Should Be True      ${min_max_avg}[1] == ${EXPECTED_MAX}     msg="Max does not match (${min_max_avg}[1] != ${EXPECTED_MAX})"
+    Should Be True      ${min_max_avg}[2] == ${EXPECTED_AVG}     msg="Avg does not match (${min_max_avg}[2] != ${EXPECTED_AVG})"
+    ELSE IF             '${TESTID}' == 'requin'
+    Should Be True      ${min_max_avg}[0] >= ${EXPECTED_MIN}     msg="Min does not match (${min_max_avg}[0] < ${EXPECTED_MIN})"
+    Should Be True      ${min_max_avg}[1] >= ${EXPECTED_MAX}     msg="Max does not match (${min_max_avg}[1] < ${EXPECTED_MAX})"
+    Should Be True      ${min_max_avg}[2] >= ${EXPECTED_AVG}     msg="Avg does not match (${min_max_avg}[2] < ${EXPECTED_AVG})"
+    ELSE IF             '${TESTID}' == 'latency'
+    Should Be True      ${min_max_avg}[0] <= ${EXPECTED_MIN}     msg="Min does not match (${min_max_avg}[0] > ${EXPECTED_MIN})"
+    Should Be True      ${min_max_avg}[1] <= ${EXPECTED_MAX}     msg="Max does not match (${min_max_avg}[1] > ${EXPECTED_MAX})"
+    Should Be True      ${min_max_avg}[2] <= ${EXPECTED_AVG}     msg="Avg does not match (${min_max_avg}[2] > ${EXPECTED_AVG})"
+    ELSE IF             '${TESTID}' == 'cbr'
+    Should Be True      ${min_max_avg}[0] >= ${EXPECTED_MIN}     msg="Min does not match (${min_max_avg}[0] < ${EXPECTED_MIN})"
+    Should Be True      ${min_max_avg}[1] >= ${EXPECTED_MAX}     msg="Max does not match (${min_max_avg}[1] < ${EXPECTED_MAX})"
+    Should Be True      ${min_max_avg}[2] >= ${EXPECTED_AVG}     msg="Avg does not match (${min_max_avg}[2] < ${EXPECTED_AVG})"
+    ELSE
+    Fail                "Provided Test ID does not exist"
+    END
+
+Set Link
+    [Documentation]     Configure link rate/delay/jitter/loss
+    ...                 Arguments:
+    ...                 ${RATE} Rate of the link
+    ...                 ${DELAY} Delay of the link
+    ...                 ${JITTER} Jitter of the link
+    ...                 ${LOSS} Loss of the link
+    [Arguments]         ${TEST_SETUP}=${NONE}
+    ...                 ${RATE}=${NONE}
+    ...                 ${DELAY}=${NONE}
+    ...                 ${JITTER}=${NONE}
+    ...                 ${LOSS}=${NONE}
+    ${result_link} =    Run Process                              ${EXECDIR}/config.sh             setchannel    ${TEST_SETUP}    server    ${RATE}-${DELAY}-${JITTER}-${LOSS}
+    Log Many            stdout: ${result_link.stdout}            stderr: ${result_link.stderr}
+
+Run Latency Test
+    [Documentation]    Run hicn-ping on the ${TEST_SETUP} topology and measure latency.
+    ...                Arguments:
+    ...                ${TEST_SETUP} The setup of the test.
+    ...                ${EXPECTED_MIN} The expected min latency
+    ...                ${EXPECTED_MAX} The expected max latency
+    ...                ${EXPECTED_AVG} The expected avg latency
+    [Arguments]        ${TEST_SETUP}=${NONE}                                               ${EXPECTED_MIN}=${NONE}    ${EXPECTED_MAX}=${NONE}    ${EXPECTED_AVG}=${NONE}
+    Run Test           ${TEST_SETUP}                                                       latency                    ${EXPECTED_MIN}            ${EXPECTED_MAX}            ${EXPECTED_AVG}
+
+Run Throughput Test Raaqm
+    [Documentation]    Run hiperf on the ${TEST_SETUP} topology and measure throughput.
+    ...                Arguments:
+    ...                ${TEST_SETUP} The setup of the test.
+    ...                ${EXPECTED_MIN} The expected min throughput
+    ...                ${EXPECTED_MAX} The expected max throughput
+    ...                ${EXPECTED_AVG} The expected avg throughput
+    [Arguments]        ${TEST_SETUP}=${NONE}                                               ${EXPECTED_MIN}=${NONE}    ${EXPECTED_MAX}=${NONE}    ${EXPECTED_AVG}=${NONE}
+    Run Test           ${TEST_SETUP}                                                       requin                     ${EXPECTED_MIN}            ${EXPECTED_MAX}            ${EXPECTED_AVG}
+
+Run Throughput Test CBR
+    [Documentation]    Run hiperf on the ${TEST_SETUP} topology and measure throughput.
+    ...                Arguments:
+    ...                ${TEST_SETUP} The setup of the test.
+    ...                ${EXPECTED_MIN} The expected min throughput
+    ...                ${EXPECTED_MAX} The expected max throughput
+    ...                ${EXPECTED_AVG} The expected avg throughput
+    [Arguments]        ${TEST_SETUP}=${NONE}                                               ${EXPECTED_MIN}=${NONE}    ${EXPECTED_MAX}=${NONE}    ${EXPECTED_AVG}=${NONE}
+    Run Test           ${TEST_SETUP}                                                       cbr                        ${EXPECTED_MIN}            ${EXPECTED_MAX}            ${EXPECTED_AVG}
+
+Run RTC Test
+    [Documentation]    Run hiperf RTC on the ${TEST_SETUP} topology and check consumer syncs to producer bitrate.
+    ...                Arguments:
+    ...                ${TEST_SETUP} The setup of the test.
+    ...                ${EXPECTED_MIN} The expected min bitrate
+    ...                ${EXPECTED_MAX} The expected max bitrate
+    ...                ${EXPECTED_AVG} The expected avg bitrate
+    [Arguments]        ${TEST_SETUP}=${NONE}                                                                         ${EXPECTED_MIN}=${NONE}    ${EXPECTED_MAX}=${NONE}    ${EXPECTED_AVG}=${NONE}
+    Run Test           ${TEST_SETUP}                                                                                 rtc                        ${EXPECTED_MIN}            ${EXPECTED_MAX}            ${EXPECTED_AVG}
diff --git a/hicn-light/src/hicn/command_line/daemon/CMakeLists.txt b/tests/run-functional.sh
index a86826f09..b8dfbc437 100644
--- a/hicn-light/src/hicn/command_line/daemon/CMakeLists.txt
+++ b/tests/run-functional.sh
@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Cisco and/or its affiliates.
+# Copyright (c) 2021 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,20 +11,30 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-list(APPEND DAEMON_SRC
-  hicnLightDaemon_main.c
+SCRIPT_PATH=$(
+  cd "$(dirname "${BASH_SOURCE}")"
+  pwd -P
 )
 
-if (WIN32)
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /NODEFAULTLIB:\"LIBCMT\"")
-endif()
-
-if(NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Android")
-  build_executable(${HICN_LIGHT_DAEMON}
-    SOURCES ${DAEMON_SRC}
-    LINK_LIBRARIES ${LIBHICN_LIGHT_STATIC}
-    DEPENDS ${LIBHICN_LIGHT_STATIC}
-    COMPONENT ${HICN_LIGHT}
-    DEFINITIONS ${COMPILER_DEFINITIONS}
-  )
-endif ()
+pushd "${SCRIPT_PATH}" || exit 1
+
+declare -a REPORTS
+
+for t in functional-tests/*; do
+  [[ -e "$t" ]] || break  # handle the case of no test files
+
+  test=$(basename "$t")
+
+  robot --NoStatusRC \
+    --outputdir report_"${test}" \
+    -P ${PWD} functional-tests/"${test}"
+
+  REPORTS+=(report_"${test}"/output.xml)
+done
+
+rebot --output output.xml \
+  -l log.html -r report.html \
+  --nostatusrc \
+  "${REPORTS[@]}"
+
+popd || exit 1
diff --git a/tests/test_forwarder.sh b/tests/test_forwarder.sh
new file mode 100644
index 000000000..aba85d8d8
--- /dev/null
+++ b/tests/test_forwarder.sh
@@ -0,0 +1,437 @@
+#!/bin/bash
+
+############################################################################
+#                               CONSTANTS
+############################################################################
+INTERFACE_CMD="ip route get 1 | grep -Po '(?<=(dev )).*(?= src| proto)'"
+ADDRESS_CMD="ip route get 1 | sed -n '/src/{s/.*src *\([^ ]*\).*/\1/p;q}'"
+CTRL_CMD="docker exec test-hicn     \
+                /hicn-build/build/build-root/bin/hicn-light-control"
+PING_SERVER_CMD="docker exec -d test-hicn   \
+                    /hicn-build/build/build-root/bin/hicn-ping-server \
+                    -z hicnlightng_module"
+PING_CLIENT_CMD="docker exec test-hicn     \
+                    /hicn-build/build/build-root/bin/hicn-ping-client \
+                    -z hicnlightng_module"
+PING_CLIENT_DETACHED_CMD="docker exec -d test-hicn     \
+                    /hicn-build/build/build-root/bin/hicn-ping-client \
+                    -z hicnlightng_module"
+LISTENER_NAME="udp0"
+CONN_NAME="conn0"
+PREFIX="c001::/64"
+COST=1
+FIVE_SECONDS=5000
+
+############################################################################
+#                                   UTILS
+############################################################################
+set_up() {
+  docker build -t hicn-dev .
+  run_forwarder
+}
+
+tear_down() {
+  docker stop --time 0 test-hicn
+}
+
+get_address() {
+  echo $(docker exec test-hicn sh -c "${ADDRESS_CMD}")
+}
+
+get_interface() {
+  echo $(docker exec test-hicn sh -c "${INTERFACE_CMD}")
+}
+
+#---------------------------------------------------------------------------
+# Exec
+#---------------------------------------------------------------------------
+run_forwarder() {
+  capacity=${1:-"100000"}
+  loglevel=${2:-"trace"}
+  config=${3:-""}
+
+  config_file_arg=""
+  if [[ $config != "" ]]; then
+    config_file_arg="--config ${config}"
+  fi
+
+  docker run --rm -d --name test-hicn \
+    -v $(pwd)/..:/hicn-build \
+    -e LD_LIBRARY_PATH=/hicn-build/build/build-root/lib \
+    hicn-dev \
+    /hicn-build/build/build-root/bin/hicn-light-daemon \
+    --log ${loglevel} --capacity ${capacity} $config_file_arg
+}
+
+exec_controller() {
+  command=$1
+
+  # Redirect stderr to stdout
+  output=$(${CTRL_CMD} ${command} 2>&1)
+  assert_exit_code
+  echo ${output}
+}
+
+exec_ping_server() {
+  data_lifetime=${1:-""}
+
+  lifetime_arg=""
+  if [[ $data_lifetime != "" ]]; then
+    lifetime_arg="-l ${data_lifetime}"
+  fi
+
+  ${PING_SERVER_CMD} ${lifetime_arg}
+}
+
+exec_ping_client() {
+  num_packets=$1
+
+  output=$(${PING_CLIENT_CMD} -m ${num_packets})
+  assert_exit_code
+  echo ${output}
+}
+
+exec_ping_client_detached() {
+  num_packets=$1
+  interest_lifetime=$2
+
+  ${PING_CLIENT_DETACHED_CMD} -m ${num_packets} -l ${interest_lifetime}
+}
+
+#---------------------------------------------------------------------------
+# Asserts
+#---------------------------------------------------------------------------
+assert_exit_code() {
+  if [[ $? -ne 0 ]]; then
+    exit_with_failure
+  fi
+}
+
+assert_forwarder() {
+  # Print forwarder logs for debug info
+  echo "******** Forwarder Logs ********"
+  docker logs test-hicn
+  echo "********************************"
+
+  output=$(docker logs test-hicn)
+  if [[ $output == "" ]]; then
+    exit_with_failure
+  fi
+
+  if [[ "${output}" == *"ERROR"* ]]; then
+    exit_with_failure
+  fi
+
+  if [[ "${output}" == *"Aborted (core dumped)"* ]]; then
+    exit_with_failure
+  fi
+}
+
+assert_ack() {
+  # Print controller logs for debug info
+  echo "******** Controller Logs ********"
+  echo $1
+  echo "********************************"
+
+  output=$1
+
+  if [[ "$output" == *"Error"* ]]; then
+    exit_with_failure
+  fi
+}
+
+assert_nack() {
+  # Print controller logs for debug info
+  echo "******** Controller Logs ********"
+  echo $1
+  echo "********************************"
+
+  output=$1
+
+  if [[ "$output" != *"Error"* ]]; then
+    exit_with_failure
+  fi
+}
+
+assert_ping_client() {
+  # Print ping client logs for debug info
+  echo "******** Ping Client Logs ********"
+  echo $1
+  echo "********************************"
+
+  ping_client_output=$1
+  pkts_sent=$2
+  pkts_recv=$3
+  pkts_timeout=$4
+
+  match_str="Sent: ${pkts_sent} Received: ${pkts_recv} Timeouts: ${pkts_timeout}"
+  if [[ ! ${ping_client_output} == *"${match_str}"* ]]; then
+    exit_with_failure
+  fi
+}
+
+assert_forwarder_stats() {
+  satisfied_from_cs=${1:-""}
+  no_route_in_fib=${2:-""}
+  aggregated=${3:-""}
+
+  fwder_stats=$(docker logs test-hicn | grep "Forwarder: received" | tail -n 1)
+
+  if [[ $satisfied_from_cs != "" &&
+    "${fwder_stats}" != *"satisfied_from_cs = ${satisfied_from_cs}"* ]]; then
+    exit_with_failure
+  fi
+
+  if [[ $no_route_in_fib != "" &&
+    "${fwder_stats}" != *"no_route_in_fib = ${no_route_in_fib}"* ]]; then
+    exit_with_failure
+  fi
+
+  if [[ $aggregated != "" &&
+    "${fwder_stats}" != *"aggregated = ${aggregated}"* ]]; then
+    exit_with_failure
+  fi
+}
+
+assert_pkt_cache_stats() {
+  total_size=${1:-""}
+  pit_size=${2:-""}
+  cs_size=${3:-""}
+
+  pkt_cache_stats=$(docker logs test-hicn | grep "Packet cache:" | tail -n 1)
+
+  if [[ $total_size != "" &&
+    "${pkt_cache_stats}" != *"total size = ${total_size}"* ]]; then
+    exit_with_failure
+  fi
+
+  if [[ $pit_size != "" &&
+    "${pkt_cache_stats}" != *"PIT size = ${pit_size}"* ]]; then
+    exit_with_failure
+  fi
+
+  if [[ $cs_size != "" &&
+    "${pkt_cache_stats}" != *"CS size = ${cs_size}"* ]]; then
+    exit_with_failure
+  fi
+}
+
+assert_cs_stats() {
+  evictions=${1:-""}
+
+  cs_stats=$(docker logs test-hicn | grep "Content store:" | tail -n 1)
+
+  if [[ $evictions != "" &&
+    "${cs_stats}" != *"evictions = ${evictions}"* ]]; then
+    exit_with_failure
+  fi
+}
+
+############################################################################
+#                                TEST SUITE
+############################################################################
+
+#---------------------------------------------------------------------------
+# Commands
+#---------------------------------------------------------------------------
+test_add_listener() {
+  # Exec hicn-light-control command and capture its output
+  INTERFACE=$(get_interface)
+  ADDRESS=$(get_address)
+  command="add listener udp ${LISTENER_NAME} ${ADDRESS} 9695 ${INTERFACE}"
+  ctrl_output=$(exec_controller "${command}")
+
+  # Check hicn-light-control and hicn-light-daemon outputs
+  assert_ack "$ctrl_output"
+  assert_forwarder
+}
+
+test_remove_listener() {
+  INTERFACE=$(get_interface)
+  ADDRESS=$(get_address)
+  command="add listener udp ${LISTENER_NAME} ${ADDRESS} 9695 ${INTERFACE}"
+  ctrl_output=$(exec_controller "${command}")
+  assert_ack "$ctrl_output"
+
+  command="remove listener udp0"
+  ctrl_output=$(exec_controller "${command}")
+
+  assert_ack "$ctrl_output"
+  assert_forwarder
+}
+
+test_remove_non_existing_listener() {
+  command="remove listener udp0"
+  ctrl_output=$(exec_controller "${command}")
+
+  assert_nack "$ctrl_output"
+  assert_forwarder
+}
+
+test_add_duplicated_listener() {
+  # Exec hicn-light-control command and capture its output
+  INTERFACE=$(get_interface)
+  ADDRESS=$(get_address)
+  command="add listener udp ${LISTENER_NAME} ${ADDRESS} 9695 ${INTERFACE}"
+  exec_controller "${command}"
+  ctrl_output=$(exec_controller "${command}")
+
+  # Check hicn-light-control and hicn-light-daemon outputs
+  assert_nack "$ctrl_output"
+  assert_forwarder
+}
+
+test_list_listeners() {
+  # Exec hicn-light-control command and capture its output
+  command="list listener"
+  ctrl_output=$(exec_controller "${command}")
+
+  # Check hicn-light-control and hicn-light-daemon outputs
+  assert_forwarder
+  # Only the local listener should be present
+  [[ "${ctrl_output}" =~ "inet4://127.0.0.1:9695" ]] && return 0 || exit_with_failure
+}
+
+test_commands_from_config() {
+  # Create config file
+  INTERFACE=$(get_interface)
+  ADDRESS=$(get_address)
+  echo "# Teset config file
+    add listener udp $LISTENER_NAME $ADDRESS 9695 ${INTERFACE}
+    add connection udp $CONN_NAME $ADDRESS 12345 $ADDRESS 9695 ${INTERFACE}
+    add route $CONN_NAME $PREFIX $COST
+    set strategy c001::/64 random
+  " >forwarder.conf
+
+  # Restart the forwarder specifying the config file
+  tear_down
+  run_forwarder "" "" "/hicn-build/tests/forwarder.conf"
+  rm forwarder.conf
+
+  # Check for errors in the output
+  assert_forwarder
+}
+
+#---------------------------------------------------------------------------
+# Ping
+#---------------------------------------------------------------------------
+test_ping_one_packet() {
+  # Exec hicn-ping-server
+  exec_ping_server
+  # Exec hicn-ping-client (w/ 1 packet) and capture its output
+  output=$(exec_ping_client 1)
+
+  # Check hicn-ping-client (1 pkt sent, 1 pkt received, 0 timeouts)
+  # and hicn-light-daemon outputs
+  assert_ping_client "${output}" 1 1 0
+  assert_forwarder
+}
+
+test_ping_two_packets() {
+  exec_ping_server
+  output=$(exec_ping_client 2)
+
+  assert_ping_client "${output}" 2 2 0
+  assert_forwarder
+}
+
+test_ping_using_cs() {
+  exec_ping_server
+  exec_ping_client 2
+  output=$(exec_ping_client 1)
+
+  assert_ping_client "${output}" 1 1 0
+  assert_forwarder
+  assert_forwarder_stats 1
+}
+
+test_ping_using_cs_different_order() {
+  exec_ping_server
+  exec_ping_client 1
+  output=$(exec_ping_client 2)
+
+  assert_ping_client "${output}" 2 2 0
+  assert_forwarder
+  assert_forwarder_stats 1
+}
+
+test_ping_timeout() {
+  # Send ping without the ping server being run
+  output=$(exec_ping_client 1)
+
+  assert_ping_client "${output}" 1 0 1
+  assert_forwarder
+  assert_forwarder_stats 0 1
+}
+
+test_ping_aggregation() {
+  # Send ping without server, waiting for a reply
+  exec_ping_client_detached 1 ${FIVE_SECONDS}
+  exec_ping_server
+  # This new ping interest will be aggregated with the previous one
+  # and the forwarder will reply to both ping clients
+  output=$(exec_ping_client 1)
+
+  assert_ping_client "${output}" 1 1 0
+  assert_forwarder
+  assert_forwarder_stats "" "" 1
+}
+
+test_ping_with_cs_store_disabled() {
+  command="store cache off"
+  exec_controller "${command}"
+
+  exec_ping_server
+  exec_ping_client 1
+  output=$(exec_ping_client 1)
+
+  assert_ping_client "${output}" 1 1 0
+  assert_forwarder
+  assert_forwarder_stats 0 "" ""
+  # The packet is not stored in the CS
+  assert_pkt_cache_stats "" "" 0
+}
+
+test_ping_with_cs_serve_disabled() {
+  command="serve cache off"
+  exec_controller "${command}"
+
+  exec_ping_server
+  exec_ping_client 1
+  output=$(exec_ping_client 1)
+
+  assert_ping_client "${output}" 1 1 0
+  assert_forwarder
+  assert_forwarder_stats 0 "" ""
+  # The packet is stored in the CS, but CS is not used
+  assert_pkt_cache_stats "" "" 1
+}
+
+test_ping_with_eviction() {
+  # Restart the forwarder with CS capacity = 1
+  tear_down
+  run_forwarder 1
+
+  exec_ping_server
+  exec_ping_client 1
+  output=$(exec_ping_client 2)
+
+  assert_ping_client "${output}" 2 2 0
+  assert_forwarder
+  # Check if eviction happened
+  assert_cs_stats 1
+  assert_pkt_cache_stats "" "" 1
+}
+
+test_ping_with_zero_data_lifetime() {
+  exec_ping_server 0
+  exec_ping_client 1
+  output=$(exec_ping_client 1)
+
+  assert_ping_client "${output}" 1 1 0
+  assert_forwarder
+  # The data is not taken from the CS because expired
+  assert_forwarder_stats 0 "" ""
+}
+
+"$@"
diff --git a/versions.cmake b/versions.cmake
new file mode 100644
index 000000000..3bce94504
--- /dev/null
+++ b/versions.cmake
@@ -0,0 +1,8 @@
+set(OPENSSL_DEFAULT_VERSION "1.1.1" "EXACT")
+set(LIBEVENT_DEFAULT_VERSION "2.1.11")
+set(ASIO_DEFAULT_VERSION "1.12.2")
+set(VPP_DEFAULT_VERSION "22.02.0" "EXACT")
+set(LIBMEMIF_DEFAULT_VERSION "22.02" "EXACT")
+set(LIBCONFIG_DEFAULT_VERSION "1.5.0")
+set(COLLECTD_DEFAULT_VERSION "5.9.2" "EXACT")
+set(ANDORID_SDK_DEP_DEFAULT_VERSION "2.1.1" "EXACT")